159 files changed, 120933 insertions, 0 deletions

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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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.
+
+  <signature of Ty Coon>, 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-<enc>.hxx header,
+    where <enc> 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<DOMDocument>& 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<C>*. 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.,
+
+    <complexType name="Type">
+      <choice>
+        <sequence>
+          <element name="a" type="string"/>
+          <element name="c" type="string"/>
+        </sequence>
+        <sequence>
+          <element name="b" type="string"/>
+          <element name="c" type="string"/>
+        </sequence>
+      </choice>
+    </complexType>
+
+
+  * 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.,
+
+    <!-- base.xsd -->
+    <schema xmlns="http://codesynthesis.com/xmlns/test/foo"
+            targetNamespace="http://codesynthesis.com/xmlns/test/foo">
+
+      <element name="foo" type="int"/>
+    </schema>
+
+    <schema xmlns="http://codesynthesis.com/xmlns/test/bar"
+	    xmlns:f="http://codesynthesis.com/xmlns/test/foo"
+            targetNamespace="http://codesynthesis.com/xmlns/test/bar">
+
+      <import namespace="http://codesynthesis.com/xmlns/test/foo"
+              schemaLocation="base.xsd"/>
+
+      <element name="foo" type="string"/>
+
+      <complexType name="Foo">
+        <sequence>
+          <element ref="foo"/>
+          <element name="foo" type="long"/>
+          <element ref="f:foo"/>
+          <element ref="f:foo"/>
+        </sequence>
+        <attribute name="foo" type="string"/>
+      </complexType>
+    </schema>
+
+
+  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 <jf at magnu.polymtl.ca> 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 <jf at magnu.polymtl.ca>
+      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 <david.r.moss at selex-comm.com> 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 <cyrille at chepelov.org> 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 @@
+<?xml version="1.0"?>
+
+<!--
+
+file      : doc/custom-literals.xsd
+copyright : not copyrighted - public domain
+
+This schema describes the XML format used to provide the custom string
+to C++ string literal mapping with the -custom-literals XSD compiler
+command line option. Here is a sample instance:
+
+<string-literal-map>
+  <entry>
+    <string>hello</string>
+    <literal>"hello"</literal>
+  </entry>
+  <entry>
+    <string>greeting</string>
+    <literal>"greeting"</literal>
+  </entry>
+</string-literal-map>
+
+-->
+
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+
+  <xsd:simpleType name="literal_t">
+    <xsd:restriction base="xsd:string">
+      <xsd:pattern value='".+"'/>
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:complexType name="entry_t">
+    <xsd:sequence>
+      <xsd:element name="string" type="xsd:string"/>
+      <xsd:element name="literal" type="literal_t"/>
+    </xsd:sequence>
+  </xsd:complexType>
+
+  <xsd:complexType name="string_literal_map_t">
+    <xsd:sequence>
+      <xsd:element name="entry" type="entry_t" maxOccurs="unbounded"/>
+    </xsd:sequence>
+  </xsd:complexType>
+
+  <xsd:element name="string-literal-map" type="string_literal_map_t"/>
+
+</xsd:schema>
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
--- /dev/null
+++ b/doc/cxx/parser/guide/figure-1.png
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 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://web.resource.org/cc/"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="744.09448819"
+   height="1052.3622047"
+   id="svg2"
+   sodipodi:version="0.32"
+   inkscape:version="0.44.1"
+   sodipodi:docbase="/tmp"
+   sodipodi:docname="figure-1.svg"
+   inkscape:export-filename="/home/boris/tmp/figure-1.png"
+   inkscape:export-xdpi="76.195885"
+   inkscape:export-ydpi="76.195885">
+  <defs
+     id="defs4">
+    <marker
+       inkscape:stockid="Arrow1Lend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Lend"
+       style="overflow:visible;">
+      <path
+         id="path2934"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
+         transform="scale(0.8) rotate(180) translate(12.5,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Dot_l"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Dot_l"
+       style="overflow:visible">
+      <path
+         id="path2875"
+         d="M -2.5,-1.0 C -2.5,1.7600000 -4.7400000,4.0 -7.5,4.0 C -10.260000,4.0 -12.5,1.7600000 -12.5,-1.0 C -12.5,-3.7600000 -10.260000,-6.0 -7.5,-6.0 C -4.7400000,-6.0 -2.5,-3.7600000 -2.5,-1.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;marker-end:none"
+         transform="scale(0.8) translate(7.4, 1)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Mend"
+       style="overflow:visible;">
+      <path
+         id="path2928"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
+         transform="scale(0.4) rotate(180) translate(10,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Dot_m"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Dot_m"
+       style="overflow:visible">
+      <path
+         id="path2872"
+         d="M -2.5,-1.0 C -2.5,1.7600000 -4.7400000,4.0 -7.5,4.0 C -10.260000,4.0 -12.5,1.7600000 -12.5,-1.0 C -12.5,-3.7600000 -10.260000,-6.0 -7.5,-6.0 C -4.7400000,-6.0 -2.5,-3.7600000 -2.5,-1.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;marker-end:none"
+         transform="scale(0.4) translate(7.4, 1)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Lstart"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Lstart"
+       style="overflow:visible">
+      <path
+         id="path2937"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(0.8) translate(12.5,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow2Mend"
+       style="overflow:visible;">
+      <path
+         id="path2910"
+         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
+         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
+         transform="scale(0.6) rotate(180) translate(0,0)" />
+    </marker>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     gridtolerance="10000"
+     guidetolerance="10"
+     objecttolerance="10"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.98994949"
+     inkscape:cx="328.23027"
+     inkscape:cy="733.01096"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     inkscape:window-width="1280"
+     inkscape:window-height="991"
+     inkscape:window-x="154"
+     inkscape:window-y="44" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <g
+       id="g3902">
+      <rect
+         y="194.64178"
+         x="24.142784"
+         height="106.2678"
+         width="149.70432"
+         id="rect1872"
+         style="fill:#c5ddf8;fill-opacity:1;fill-rule:evenodd;stroke:#c5ddf8;stroke-width:5.29799986;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <text
+         sodipodi:linespacing="125%"
+         id="text3038"
+         y="219.99649"
+         x="28.284279"
+         style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;color:black;fill:black;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;font-family:Monospace"
+         xml:space="preserve"><tspan
+           y="219.99649"
+           x="28.284279"
+           id="tspan3064"
+           sodipodi:role="line">class people_pimpl</tspan><tspan
+           y="236.24649"
+           x="28.284279"
+           id="tspan3066"
+           sodipodi:role="line">{</tspan><tspan
+           y="252.49649"
+           x="28.284279"
+           id="tspan3068"
+           sodipodi:role="line">  void </tspan><tspan
+           y="268.74649"
+           x="28.284279"
+           id="tspan3070"
+           sodipodi:role="line">  person ();</tspan><tspan
+           y="284.99649"
+           x="28.284279"
+           id="tspan3072"
+           sodipodi:role="line">};</tspan></text>
+    </g>
+    <g
+       id="g3881">
+      <rect
+         y="124.93772"
+         x="252.43373"
+         height="245.67592"
+         width="180.01601"
+         id="rect5750"
+         style="fill:#c5ddf8;fill-opacity:1;fill-rule:evenodd;stroke:#c5ddf8;stroke-width:9.12976837;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <text
+         sodipodi:linespacing="100%"
+         id="text5752"
+         y="148.27567"
+         x="257.5889"
+         style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;color:black;fill:black;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;font-family:Monospace"
+         xml:space="preserve"><tspan
+           y="148.27567"
+           x="257.5889"
+           id="tspan5900"
+           sodipodi:role="line">class person_pimpl</tspan><tspan
+           y="161.27567"
+           x="257.5889"
+           id="tspan5902"
+           sodipodi:role="line">{</tspan><tspan
+           y="174.27567"
+           x="257.5889"
+           id="tspan5904"
+           sodipodi:role="line">  void</tspan><tspan
+           y="187.27567"
+           x="257.5889"
+           id="tspan5906"
+           sodipodi:role="line">  first_name (string);</tspan><tspan
+           y="200.27567"
+           x="257.5889"
+           id="tspan5908"
+           sodipodi:role="line" /><tspan
+           y="213.27567"
+           x="257.5889"
+           id="tspan5910"
+           sodipodi:role="line">  void</tspan><tspan
+           y="226.27567"
+           x="257.5889"
+           id="tspan5912"
+           sodipodi:role="line">  last_name (string);</tspan><tspan
+           y="239.27567"
+           x="257.5889"
+           id="tspan5914"
+           sodipodi:role="line" /><tspan
+           y="252.27567"
+           x="257.5889"
+           id="tspan5916"
+           sodipodi:role="line">  void</tspan><tspan
+           y="265.27567"
+           x="257.5889"
+           id="tspan5918"
+           sodipodi:role="line">  gender ();</tspan><tspan
+           y="278.27567"
+           x="257.5889"
+           id="tspan5920"
+           sodipodi:role="line" /><tspan
+           y="291.27567"
+           x="257.5889"
+           id="tspan5922"
+           sodipodi:role="line">  void</tspan><tspan
+           y="304.27567"
+           x="257.5889"
+           id="tspan5924"
+           sodipodi:role="line">  age (short);</tspan><tspan
+           y="317.27567"
+           x="257.5889"
+           id="tspan5926"
+           sodipodi:role="line">  </tspan><tspan
+           y="330.27567"
+           x="257.5889"
+           id="tspan5928"
+           sodipodi:role="line">  void</tspan><tspan
+           y="343.27567"
+           x="257.5889"
+           id="tspan5930"
+           sodipodi:role="line">  post_person ();</tspan><tspan
+           y="356.27567"
+           x="257.5889"
+           id="tspan5932"
+           sodipodi:role="line">};</tspan></text>
+    </g>
+    <g
+       id="g3845">
+      <rect
+         y="77.741814"
+         x="506.28357"
+         height="99.610825"
+         width="151.1286"
+         id="rect5955"
+         style="fill:#c5ddf8;fill-opacity:1;fill-rule:evenodd;stroke:#c5ddf8;stroke-width:5.69227886;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <flowRoot
+         transform="translate(-5.050762,12.10153)"
+         style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace"
+         id="flowRoot5957"
+         xml:space="preserve"><flowRegion
+           id="flowRegion5959"><rect
+             style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace"
+             y="74.534515"
+             x="516.18793"
+             height="88.893425"
+             width="143.44167"
+             id="rect5961" /></flowRegion><flowPara
+           id="flowPara5965">class string_pimpl</flowPara><flowPara
+           id="flowPara5967">{</flowPara><flowPara
+           id="flowPara5969">  string</flowPara><flowPara
+           id="flowPara5971">  post_string ();</flowPara><flowPara
+           id="flowPara5973">};</flowPara><flowPara
+           id="flowPara5975" /></flowRoot>    </g>
+    <g
+       id="g3857">
+      <rect
+         style="fill:#c5ddf8;fill-opacity:1;fill-rule:evenodd;stroke:#c5ddf8;stroke-width:5.69227886;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect5977"
+         width="151.1286"
+         height="99.610825"
+         x="506.28357"
+         y="316.15808" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot5979"
+         style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace"
+         transform="translate(-5.050761,250.5178)"
+         inkscape:export-filename="/tmp/figure-1.png"
+         inkscape:export-xdpi="546.53815"
+         inkscape:export-ydpi="546.53815"><flowRegion
+           id="flowRegion5981"><rect
+             id="rect5983"
+             width="143.44167"
+             height="88.893425"
+             x="516.18793"
+             y="74.534515"
+             style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace" /></flowRegion><flowPara
+           id="flowPara5985">class short_pimpl</flowPara><flowPara
+           id="flowPara5987">{</flowPara><flowPara
+           id="flowPara5989">  short</flowPara><flowPara
+           id="flowPara5991">  post_short ();</flowPara><flowPara
+           id="flowPara5993">};</flowPara><flowPara
+           id="flowPara5995" /></flowRoot>    </g>
+    <g
+       id="g3869">
+      <rect
+         style="fill:#c5ddf8;fill-opacity:1;fill-rule:evenodd;stroke:#c5ddf8;stroke-width:5.69227886;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect6023"
+         width="151.1286"
+         height="99.610825"
+         x="505.7785"
+         y="196.93977" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot6025"
+         style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace"
+         transform="translate(-5.555838,129.2792)"><flowRegion
+           id="flowRegion6027"><rect
+             id="rect6029"
+             width="143.44167"
+             height="88.893425"
+             x="516.18793"
+             y="74.534515"
+             style="font-size:13px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Monospace" /></flowRegion><flowPara
+           id="flowPara6031">class gender_pimpl</flowPara><flowPara
+           id="flowPara6033">{</flowPara><flowPara
+           id="flowPara6035">  void</flowPara><flowPara
+           id="flowPara6037">  post_gender ();</flowPara><flowPara
+           id="flowPara6039">};</flowPara><flowPara
+           id="flowPara6041" /></flowRoot>    </g>
+    <path
+       style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;display:inline;marker-start:url(#Dot_l);marker-end:url(#Arrow1Lend)"
+       d="M 265.67011,339.69956 L 210.41811,339.34242 L 210.77124,264.14332 L 127.7843,264.4432"
+       id="path6051"
+       inkscape:connector-type="polyline"
+       sodipodi:nodetypes="cccs" />
+    <path
+       sodipodi:nodetypes="cccc"
+       inkscape:connector-type="polyline"
+       id="path6077"
+       d="M 518.20825,383.6412 L 471.23616,384.14628 L 471.4887,300.55615 L 368.70568,300.80869"
+       style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#Dot_l);marker-end:url(#Arrow1Lend);stroke-opacity:1;display:inline" />
+    <path
+       style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#Dot_l);marker-end:url(#Arrow1Lend);stroke-opacity:1;display:inline"
+       d="M 517.1981,262.42289 L 353.55339,262.42289"
+       id="path6081"
+       inkscape:connector-type="polyline"
+       sodipodi:nodetypes="cccs" />
+    <path
+       style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#Dot_l);marker-end:url(#Arrow1Lend);stroke-opacity:1;display:inline"
+       d="M 518.57143,145.93361 L 470.35714,146.14281 L 470.53572,183.07646 L 431.42857,183.79075"
+       id="path6089"
+       inkscape:connector-type="polyline"
+       sodipodi:nodetypes="cccc" />
+    <path
+       style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-end:url(#Arrow1Lend);stroke-opacity:1;display:inline"
+       d="M 470.46175,178.43361 L 470.89286,222.36218 L 423.21428,222.71932"
+       id="path6091"
+       inkscape:connector-type="polyline"
+       sodipodi:nodetypes="ccc" />
+  </g>
+</svg>
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: "
+<div align=center>
+  <h1><big>C++/Parser Mapping</big></h1>
+  <h1><big>Getting Started Guide</big></h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+</div>
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href='https://www.codesynthesis.com/licenses/fdl-1.2.txt'>GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/index.xhtml'>XHTML</a>,
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.pdf'>PDF</a>, and
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.ps'>PostScript</a>.</p>";
+  }
+
+  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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Parser Mapping Getting Started Guide</title>
+
+  <meta name="copyright" content="&#169; 2005-2023 Code Synthesis"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,parser,validation"/>
+  <meta name="description" content="C++/Parser Mapping Getting Started Guide"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+    line-height: 1.2em;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 140%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage .title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+  }
+
+  #titlepage #first-title {
+    padding: 1em 0 0.4em 0;
+  }
+
+  #titlepage #second-title {
+    padding: 0.4em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+  ol.steps {
+    padding-left     : 1.8em;
+  }
+
+  ol.steps li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+
+  div.img {
+    text-align: center;
+    padding: 2em 0 2em 0;
+  }
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+  /* XML Schema features table. */
+  #features {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #features th, #features td {
+    border: 1px solid;
+    padding           : 0.6em 0.6em 0.6em 0.6em;
+  }
+
+  #features th {
+    background : #cde8f6;
+  }
+
+  #features td {
+    text-align: left;
+  }
+
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div class="title" id="first-title">C++/Parser Mapping</div>
+    <div class="title" id="second-title">Getting Started Guide</div>
+
+  <p>Copyright &#169; 2005-2023 Code Synthesis.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.ps">PostScript</a>.</p>
+
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+          <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a>
+        <table class="toc">
+          <tr><th>1.1</th><td><a href="#1.1">Mapping Overview</a></td></tr>
+          <tr><th>1.2</th><td><a href="#1.2">Benefits</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">Hello World Example</a>
+        <table class="toc">
+          <tr><th>2.1</th><td><a href="#2.1">Writing XML Document and Schema</a></td></tr>
+          <tr><th>2.2</th><td><a href="#2.2">Translating Schema to C++</a></td></tr>
+          <tr><th>2.3</th><td><a href="#2.3">Implementing Application Logic</a></td></tr>
+          <tr><th>2.4</th><td><a href="#2.4">Compiling and Running</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Parser Skeletons</a>
+        <table class="toc">
+          <tr><th>3.1</th><td><a href="#3.1">Implementing the Gender Parser</a></td></tr>
+          <tr><th>3.2</th><td><a href="#3.2">Implementing the Person Parser</a></td></tr>
+          <tr><th>3.3</th><td><a href="#3.3">Implementing the People Parser</a></td></tr>
+          <tr><th>3.4</th><td><a href="#3.4">Connecting the Parsers Together</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Type Maps</a>
+        <table class="toc">
+          <tr><th>4.1</th><td><a href="#4.1">Object Model</a></td></tr>
+          <tr><th>4.2</th><td><a href="#4.2">Type Map File Format</a></td></tr>
+          <tr><th>4.3</th><td><a href="#4.3">Parser Implementations</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Mapping Configuration</a>
+        <table class="toc">
+          <tr><th>5.1</th><td><a href="#5.1">C++ Standard</a></td></tr>
+          <tr><th>5.2</th><td><a href="#5.2">Character Type and Encoding</a></td></tr>
+          <tr><th>5.3</th><td><a href="#5.3">Underlying XML Parser</a></td></tr>
+	  <tr><th>5.4</th><td><a href="#5.4">XML Schema Validation</a></td></tr>
+	  <tr><th>5.5</th><td><a href="#5.5">Support for Polymorphism</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>6</th><td><a href="#6">Built-In XML Schema Type Parsers</a>
+        <table class="toc">
+          <tr><th>6.1</th><td><a href="#6.1"><code>QName</code> Parser</a></td></tr>
+          <tr><th>6.2</th><td><a href="#6.2"><code>NMTOKENS</code> and <code>IDREFS</code> Parsers</a></td></tr>
+          <tr><th>6.3</th><td><a href="#6.3"><code>base64Binary</code> and <code>hexBinary</code> Parsers</a></td></tr>
+	  <tr><th>6.4</th><td><a href="#6.4">Time Zone Representation</a></td></tr>
+	  <tr><th>6.5</th><td><a href="#6.5"><code>date</code> Parser</a></td></tr>
+	  <tr><th>6.6</th><td><a href="#6.6"><code>dateTime</code> Parser</a></td></tr>
+	  <tr><th>6.7</th><td><a href="#6.7"><code>duration</code> Parser</a></td></tr>
+	  <tr><th>6.8</th><td><a href="#6.8"><code>gDay</code> Parser</a></td></tr>
+	  <tr><th>6.9</th><td><a href="#6.9"><code>gMonth</code> Parser</a></td></tr>
+	  <tr><th>6.10</th><td><a href="#6.10"><code>gMonthDay</code> Parser</a></td></tr>
+	  <tr><th>6.11</th><td><a href="#6.11"><code>gYear</code> Parser</a></td></tr>
+	  <tr><th>6.12</th><td><a href="#6.12"><code>gYearMonth</code> Parser</a></td></tr>
+	  <tr><th>6.13</th><td><a href="#6.13"><code>time</code> Parser</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>7</th><td><a href="#7">Document Parser and Error Handling</a>
+        <table class="toc">
+          <tr><th>7.1</th><td><a href="#7.1">Xerces-C++ Document Parser</a></td></tr>
+          <tr><th>7.2</th><td><a href="#7.2">Expat Document Parser</a></td></tr>
+          <tr><th>7.3</th><td><a href="#7.3">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th></th><td><a href="#A">Appendix A &mdash; Supported XML Schema Constructs</a></td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this guide, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/parser/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is the place to ask technical questions about XSD and the C++/Parser mapping.
+        Furthermore, the <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+
+  </ul>
+
+  <!-- Introduction -->
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.
+  </p>
+
+  <h2><a name="1.1">1.1 Mapping Overview</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="1.2">1.2 Benefits</a></h2>
+
+  <p>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:
+  </p>
+
+  <ul class="list">
+    <li>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.</li>
+
+    <li>String-based flow control defers error detection to runtime.
+        It also reduces code readability and maintainability.</li>
+
+    <li>Lack of type safety because the data is represented
+        as text.</li>
+
+    <li>Resulting applications are hard to debug, change, and
+        maintain.</li>
+  </ul>
+
+  <p>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:</p>
+
+  <ul class="list">
+    <li><b>Ease of use.</b> 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.</li>
+
+    <li><b>Natural representation.</b> 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.
+    </li>
+
+    <li><b>Concise code.</b> With a separate parser skeleton for each
+        XML Schema type, the application implementation is
+        simpler and thus easier to read and understand.</li>
+
+    <li><b>Safety.</b> 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.</li>
+
+    <li><b>Maintainability.</b> 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.</li>
+
+   <li><b>Efficiency.</b> 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.</li>
+  </ul>
+
+  <!-- Hello World Parser -->
+
+
+  <h1><a name="2">2 Hello World Example</a></h1>
+
+  <p>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 <code>hello</code>
+     example which can be found in the <code>cxx/parser/</code> directory in
+     the <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <h2><a name="2.1">2.1 Writing XML Document and Schema</a></h2>
+
+  <p>First, we need to get an idea about the structure
+     of the XML documents we are going to process. Our
+     <code>hello.xml</code>, for example, could look like this:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello>
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>Then we can write a description of the above XML in the
+     XML Schema language and save it into <code>hello.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello">
+    &lt;xs:sequence>
+      &lt;xs:element name="greeting" type="xs:string"/>
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Even if you are not familiar with XML Schema, it
+     should be easy to connect declarations in <code>hello.xsd</code>
+     to elements in <code>hello.xml</code>. The <code>hello</code> type
+     is defined as a sequence of the nested <code>greeting</code> and
+     <code>name</code> 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 <code>name</code>
+     element has its <code>maxOccurs</code> property set to
+     <code>unbounded</code> which means it can appear multiple times
+     in an XML document. Finally, the globally-defined <code>hello</code>
+     element prescribes the root element for our vocabulary. For an
+     easily-approachable introduction to XML Schema refer to
+     <a href="http://www.w3.org/TR/xmlschema-0/">XML Schema Part 0:
+     Primer</a>.</p>
+
+  <p>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.</p>
+
+  <h2><a name="2.2">2.2 Translating Schema to C++</a></h2>
+
+  <p>Now we are ready to translate our <code>hello.xsd</code> to C++ parser
+     skeletons. To do this we invoke the XSD compiler from a terminal
+     (UNIX) or a command prompt (Windows):
+  </p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --xml-parser expat hello.xsd
+  </pre>
+
+  <p>The <code>--xml-parser</code> option indicates that we want to
+     use Expat as the underlying XML parser (see <a href="#5.3">Section
+     5.3, "Underlying XML Parser"</a>). The XSD compiler produces two
+     C++ files: <code>hello-pskel.hxx</code> and <code>hello-pskel.cxx</code>.
+     The following code fragment is taken from <code>hello-pskel.hxx</code>;
+     it should give you an idea about what gets generated:
+  </p>
+
+  <pre class="c++">
+class hello_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  greeting (const std::string&amp;);
+
+  virtual void
+  name (const std::string&amp;);
+
+  virtual void
+  post_hello ();
+
+  // Parser construction API.
+  //
+  void
+  greeting_parser (xml_schema::string_pskel&amp;);
+
+  void
+  name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  parsers (xml_schema::string_pskel&amp; /* greeting */,
+           xml_schema::string_pskel&amp; /* name */);
+
+private:
+  ...
+};
+  </pre>
+
+  <p>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.</p>
+
+  <p>The <code>pre()</code> function is an initialization callback. It is
+    called when a new element of type <code>hello</code> 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.</p>
+
+  <p>The <code>post_hello()</code> function is a finalization callback. Its
+     name is constructed by adding the parser skeleton name to the
+     <code>post_</code> 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
+     <code>post_hello()</code> is <code>void</code> which means there
+     is nothing to return. More on parser return types later.
+  </p>
+
+  <p>You may be wondering why the finalization callback is called
+     <code>post_hello()</code> instead of <code>post()</code> just
+     like <code>pre()</code>. 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.</p>
+
+  <p>The <code>greeting()</code> and <code>name()</code> functions are
+     called when the <code>greeting</code> and <code>name</code> elements
+     have been parsed, respectively. Their arguments are of type
+     <code>std::string</code> and contain the data extracted from XML.</p>
+
+  <p>The last three functions are for connecting parsers to each other.
+     For example, there is a predefined parser for built-in XML Schema type
+     <code>string</code> in the XSD runtime. We will be using
+     it to parse the contents of <code>greeting</code> and
+     <code>name</code> elements, as shown in the next section.</p>
+
+  <h2><a name="2.3">2.3 Implementing Application Logic</a></h2>
+
+  <p>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:
+  </p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello-pskel.hxx"
+
+class hello_pimpl: public hello_pskel
+{
+public:
+  virtual void
+  greeting (const std::string&amp; g)
+  {
+    greeting_ = g;
+  }
+
+  virtual void
+  name (const std::string&amp; n)
+  {
+    std::cout &lt;&lt; greeting_ &lt;&lt; ", " &lt;&lt; n &lt;&lt; "!" &lt;&lt; std::endl;
+  }
+
+private:
+  std::string greeting_;
+};
+  </pre>
+
+  <p>We left both <code>pre()</code> and <code>post_hello()</code> 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.</p>
+
+  <p>An observant reader my ask what happens if the <code>name</code>
+     element comes before <code>greeting</code>? Don't we need to
+     make sure <code>greeting_</code> was initialized and report
+     an error otherwise? The answer is no, we don't have to do
+     any of this. The <code>hello_pskel</code> 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 <code>greeting</code> and <code>name</code> elements
+     and report an error if it is violated.</p>
+
+  <p>Now it is time to put this parser implementation to work:</p>
+
+  <pre class="c++">
+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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>The first part of this code snippet instantiates individual parsers
+     and assembles them into a complete vocabulary parser.
+     <code>xml_schema::string_pimpl</code> is an implementation of a parser
+     for built-in XML Schema type <code>string</code>. It is provided by
+     the XSD runtime along with parsers for other built-in types (for
+     more information on the built-in parsers see <a href="#6">Chapter 6,
+     "Built-In XML Schema Type Parsers"</a>). We use <code>string_pimpl</code>
+     to parse the <code>greeting</code> and <code>name</code> elements as
+     indicated by the calls to <code>greeting_parser()</code> and
+     <code>name_parser()</code>.
+  </p>
+
+  <p>Then we instantiate a document parser (<code>doc_p</code>). The
+     first argument to its constructor is the parser for
+     the root element (<code>hello_p</code> in our case). The
+     second argument is the root element name.
+   </p>
+
+  <p>The final piece is the calls to <code>pre()</code>, <code>parse()</code>,
+     and <code>post_hello()</code>. The call to <code>parse()</code>
+     perform the actual XML parsing while the calls to <code>pre()</code> and
+     <code>post_hello()</code> make sure that the parser for the root
+     element can perform proper initialization and cleanup.</p>
+
+  <p>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 <code>--generate-noop-impl</code>
+     option. Or you can generate a sample implementation that prints the
+     data store in XML by using the <code>--generate-print-impl</code>
+     option. To request the generation of a test driver you can use the
+     <code>--generate-test-driver</code> option. For more information
+     on these options refer to the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>. The <code>'generated'</code> example
+     in the <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+     shows the sample implementation generation feature in action.</p>
+
+
+  <h2><a name="2.4">2.4 Compiling and Running</a></h2>
+
+  <p>After saving all the parts from the previous section in
+     <code>driver.cxx</code>, 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:
+  </p>
+
+  <pre class="terminal">
+$ 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!
+  </pre>
+
+  <p>Here <code>.../libxsd</code> represents the path to the
+     <a href="https://cppget.org/libxsd">libxsd</a> package root
+     directory. We can also test the error handling. To test XML
+     well-formedness checking, we can try to parse
+     <code>hello-pskel.hxx</code>:</p>
+
+  <pre class="terminal">
+$ ./driver hello-pskel.hxx
+hello-pskel.hxx:1:0: not well-formed (invalid token)
+  </pre>
+
+  <p>We can also try to parse a valid XML but not from our
+     vocabulary, for example <code>hello.xsd</code>:</p>
+
+  <pre class="terminal">
+$ ./driver hello.xsd
+hello.xsd:2:0: expected element 'hello' instead of
+'http://www.w3.org/2001/XMLSchema#schema'
+  </pre>
+
+
+  <!-- Chapater 3 -->
+
+
+  <h1><a name="3">3 Parser Skeletons</a></h1>
+
+  <p>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.</p>
+
+  <p>In this and subsequent chapters we will use the following schema
+     that describes a collection of person records. We save it in
+     <code>people.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:simpleType name="gender">
+    &lt;xs:restriction base="xs:string">
+      &lt;xs:enumeration value="male"/>
+      &lt;xs:enumeration value="female"/>
+    &lt;/xs:restriction>
+  &lt;/xs:simpleType>
+
+  &lt;xs:complexType name="person">
+    &lt;xs:sequence>
+      &lt;xs:element name="first-name" type="xs:string"/>
+      &lt;xs:element name="last-name" type="xs:string"/>
+      &lt;xs:element name="gender" type="gender"/>
+      &lt;xs:element name="age" type="xs:short"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:complexType name="people">
+    &lt;xs:sequence>
+      &lt;xs:element name="person" type="person" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="people" type="people"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>A sample XML instance to go along with this schema is saved
+     in <code>people.xml</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people>
+  &lt;person>
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+  &lt;person>
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+&lt;/people>
+  </pre>
+
+  <p>Compiling <code>people.xsd</code> with the XSD compiler results
+     in three parser skeletons being generated: <code>gender_pskel</code>,
+     <code>person_pskel</code>, and <code>people_pskel</code>. We are going
+     to examine and implement each of them in the subsequent sections.</p>
+
+  <h2><a name="3.1">3.1 Implementing the Gender Parser</a></h2>
+
+  <p>The generated <code>gender_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post_gender ();
+};
+  </pre>
+
+  <p>Notice that <code>gender_pskel</code> inherits from
+     <code>xml_schema::string_skel</code> which is a parser skeleton
+     for built-in XML Schema type <code>string</code> 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.</p>
+
+  <p>The <code>pre()</code> and <code>post_gender()</code> callbacks
+     should look familiar from the previous chapter. Let's now
+     implement the parser. Our implementation will simply print
+     the gender to <code>cout</code>:</p>
+
+
+  <pre class="c++">
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual void
+  post_gender ()
+  {
+    std::string s = post_string ();
+    cout &lt;&lt; "gender: " &lt;&lt; s &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>While the code is quite short, there is a lot going on. First,
+     notice that we are inheriting from <code>gender_pskel</code> <em>and</em>
+     from <code>xml_schema::string_pimpl</code>. We've encountered
+     <code>xml_schema::string_pimpl</code> already; it is an
+     implementation of the <code>xml_schema::string_pskel</code> parser
+     skeleton for built-in XML Schema type <code>string</code>.</p>
+
+  <p>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, <code>string_pimpl</code> will
+     do all the dirty work of extracting the data and we can just get
+     it at the end with the call to <code>post_string()</code>.</p>
+
+  <p>In case you are curious, here is what
+     <code>xml_schema::string_pskel</code> and
+     <code>xml_schema::string_pimpl</code> look like:</p>
+
+  <pre class="c++">
+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&amp;);
+
+    virtual std::string
+    post_string ();
+
+  protected:
+    std::string str_;
+  };
+}
+  </pre>
+
+  <p>There are three new pieces in this code that we haven't seen yet.
+     They are the <code>simple_content</code> class as well as
+     the <code>_pre()</code> and <code>_characters()</code> functions.
+     The <code>simple_content</code> 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&mdash;only text
+     and attributes. There is also the <code>complex_content</code>
+     class which corresponds to the complex content mode (types with
+     nested elements, for example, <code>person</code> from
+     <code>people.xsd</code>).</p>
+
+  <p>The <code>_pre()</code> function is a parser callback. Remember we
+     talked about the <code>pre()</code> and <code>post_*()</code> callbacks
+     in the previous chapter? There are actually two more callbacks
+     with similar roles: <code>_pre()</code> and <code>_post ()</code>.
+     As a result, each parser skeleton has four special callbacks:</p>
+
+  <pre class="c++">
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post_name ();
+  </pre>
+
+  <p><code>pre()</code> and <code>_pre()</code> are initialization
+     callbacks. They get called in that order before a new instance of the type
+     is about to be parsed. The difference between <code>pre()</code> and
+     <code>_pre()</code> is conventional: <code>pre()</code> can
+     be completely overridden by a derived parser. The derived
+     parser can also override <code>_pre()</code> but has to always call
+     the original version. This allows you to partition initialization
+     into customizable and required parts.</p>
+
+  <p>Similarly, <code>_post()</code> and <code>post_name()</code> are
+     finalization callbacks with exactly the same semantics:
+    <code>post_name()</code> can be completely overridden by the derived
+     parser while the original <code>_post()</code> should always be called.
+  </p>
+
+  <p>The final bit we need to discuss in this section is the
+     <code>_characters()</code> 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.</p>
+
+  <p>At this point you might be wondering why some <code>post_*()</code>
+     callbacks, for example <code>post_string()</code>, return some data
+     while others, for example <code>post_gender()</code>, have
+     <code>void</code> as a return type. This is a valid concern
+     and it will be addressed in the next chapter.</p>
+
+  <h2><a name="3.2">3.2 Implementing the Person Parser</a></h2>
+
+  <p>The generated <code>person_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+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&amp;);
+
+  virtual void
+  last_name (const std::string&amp;);
+
+  virtual void
+  gender ();
+
+  virtual void
+  age (short);
+
+  virtual void
+  post_person ();
+
+  // Parser construction API.
+  //
+  void
+  first_name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  last_name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  gender_parser (gender_pskel&amp;);
+
+  void
+  age_parser (xml_schema::short_pskel&amp;);
+
+  void
+  parsers (xml_schema::string_pskel&amp; /* first-name */,
+           xml_schema::string_pskel&amp; /* last-name */,
+           gender_pskel&amp;             /* gender */,
+           xml_schema::short_pskel&amp;  /* age */);
+};
+  </pre>
+
+
+  <p>As you can see, we have a parser callback for each of the nested
+     elements found in the <code>person</code> XML Schema type.
+     The implementation of this parser is straightforward:</p>
+
+  <pre class="c++">
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string&amp; n)
+  {
+    cout &lt;&lt; "first: " &lt;&lt; f &lt;&lt; endl;
+  }
+
+  virtual void
+  last_name (const std::string&amp; l)
+  {
+    cout &lt;&lt; "last: " &lt;&lt; l &lt;&lt; endl;
+  }
+
+  virtual void
+  age (short a)
+  {
+    cout &lt;&lt; "age: " &lt;&lt; a &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Notice that we didn't override the <code>gender()</code> callback
+     because all the printing is done by <code>gender_pimpl</code>.</p>
+
+
+  <h2><a name="3.3">3.3 Implementing the People Parser</a></h2>
+
+  <p>The generated <code>people_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+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&amp;);
+
+  void
+  parsers (person_pskel&amp; /* person */);
+};
+  </pre>
+
+  <p>The <code>person()</code> callback will be called after parsing each
+     <code>person</code> element. While <code>person_pimpl</code> 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:</p>
+
+  <pre class="c++">
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    cout &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Now it is time to put everything together.</p>
+
+
+  <h2><a name="3.4">3.4 Connecting the Parsers Together</a></h2>
+
+  <p>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:</p>
+
+  <pre class="c++">
+xml_schema::short_pimpl short_p;
+xml_schema::string_pimpl string_p;
+
+gender_pimpl gender_p;
+person_pimpl person_p;
+people_pimpl people_p;
+  </pre>
+
+  <p>Notice that our schema uses two built-in XML Schema types:
+     <code>string</code> for the <code>first-name</code> and
+     <code>last-name</code> elements as well as <code>short</code>
+     for <code>age</code>. 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 <code>*_parser()</code> functions:</p>
+
+  <pre class="c++">
+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);
+  </pre>
+
+  <p>You might be wondering what happens if you do not provide
+     a parser by not calling one of the <code>*_parser()</code> 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.</p>
+
+
+  <p>An alternative, shorter, way to connect the parsers is by using
+     the <code>parsers()</code> functions which connects all the parsers
+     for a given type at once:</p>
+
+  <pre class="c++">
+person_p.parsers (string_p, string_p, gender_p, short_p);
+people_p.parsers (person_p);
+  </pre>
+
+  <p>The following figure illustrates the resulting connections. Notice
+     the correspondence between return types of the <code>post_*()</code>
+     functions and argument types of element callbacks that are connected
+     by the arrows.</p>
+
+  <!-- align=center is needed for html2ps -->
+  <div class="img" align="center"><img src="figure-1.png"/></div>
+
+  <p>The last step is the construction of the document parser and
+     invocation of the complete parser on our sample XML instance:</p>
+
+  <pre class="c++">
+xml_schema::document doc_p (people_p, "people");
+
+people_p.pre ();
+doc_p.parse ("people.xml");
+people_p.post_people ();
+  </pre>
+
+  <p>Let's consider <code>xml_schema::document</code> in
+     more detail. While the exact definition of this class
+     varies depending on the underlying parser selected,
+     here is the common part:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class document
+  {
+  public:
+    document (xml_schema::parser_base&amp;,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    document (xml_schema::parser_base&amp;,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    void
+    parse (const std::string&amp; file);
+
+    void
+    parse (std::istream&amp;);
+
+    ...
+
+  };
+}
+  </pre>
+
+   <p><code>xml_schema::document</code> is a root parser for
+     the vocabulary. The first argument to its constructors is the
+     parser for the type of the root element (<code>people_impl</code>
+     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
+     <code>document</code>'s constructors.</p>
+
+   <p>There are also two overloaded <code>parse()</code> functions
+      defined in the <code>document</code> 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 <code>xml_schema::document</code> class
+      refer to <a href="#7">Chapter 7, "Document Parser and Error
+      Handling"</a>.</p>
+
+   <p>Let's now consider a step-by-step list of actions that happen
+      as we parse through <code>people.xml</code>. The content of
+      <code>people.xml</code> is repeated below for convenience.</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people>
+  &lt;person>
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+  &lt;person>
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+&lt;/people>
+  </pre>
+
+
+   <ol class="steps">
+     <li><code>people_p.pre()</code> is called from
+         <code>main()</code>. We did not provide any implementation
+         for this callback so this call is a no-op.</li>
+
+     <li><code>doc_p.parse("people.xml")</code> is called from
+         <code>main()</code>. The parser opens the file and starts
+         parsing its content.</li>
+
+     <li>The parser encounters the root element. <code>doc_p</code>
+         verifies that the root element is correct and calls
+         <code>_pre()</code> on <code>people_p</code> which is also
+         a no-op. Parsing is now delegated to <code>people_p</code>.</li>
+
+     <li>The parser encounters the <code>person</code> element.
+         <code>people_p</code> determines that <code>person_p</code>
+         is responsible for parsing this element. <code>pre()</code>
+         and <code>_pre()</code> callbacks are called on <code>person_p</code>.
+         Parsing is now delegated to <code>person_p</code>.</li>
+
+     <li>The parser encounters the <code>first-name</code> element.
+         <code>person_p</code> determines that <code>string_p</code>
+         is responsible for parsing this element. <code>pre()</code>
+         and <code>_pre()</code> callbacks are called on <code>string_p</code>.
+         Parsing is now delegated to <code>string_p</code>.</li>
+
+     <li>The parser encounters character content consisting of
+         <code>"John"</code>. The <code>_characters()</code> callback is
+         called on <code>string_p</code>.</li>
+
+     <li>The parser encounters the end of <code>first-name</code>
+         element. The <code>_post()</code> and <code>post_string()</code>
+         callbacks are called on <code>string_p</code>. The
+         <code>first_name()</code> callback is called on <code>person_p</code>
+         with the return value of <code>post_string()</code>. The
+         <code>first_name()</code> implementation prints
+         <code>"first: John"</code> to <code>cout</code>.
+         Parsing is now returned to <code>person_p</code>.</li>
+
+     <li>Steps analogous to 5-7 are performed for the <code>last-name</code>,
+         <code>gender</code>, and <code>age</code> elements.</li>
+
+     <li>The parser encounters the end of <code>person</code>
+         element. The <code>_post()</code> and <code>post_person()</code>
+         callbacks are called on <code>person_p</code>. The
+         <code>person()</code> callback is called on <code>people_p</code>.
+         The <code>person()</code> implementation prints a new line
+         to <code>cout</code>. Parsing is now returned to
+         <code>people_p</code>.</li>
+
+     <li>Steps 4-9 are performed for the second <code>person</code>
+         element.</li>
+
+     <li>The parser encounters the end of <code>people</code>
+         element. The <code>_post()</code> callback is called on
+         <code>people_p</code>. The <code>doc_p.parse("people.xml")</code>
+         call returns to <code>main()</code>.</li>
+
+     <li><code>people_p.post_people()</code> is called from
+         <code>main()</code> which is a no-op.</li>
+
+   </ol>
+
+
+  <!-- Chpater 4 -->
+
+
+  <h1><a name="4">4 Type Maps</a></h1>
+
+  <p>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 <em>parent</em> parser
+     which can then incorporate this sub-tree into the whole tree.</p>
+
+  <p>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.</p>
+
+  <h2><a name="4.1">4.1 Object Model</a></h2>
+
+  <p>An object model for our person record example could
+     look like this (saved in the <code>people.hxx</code> file):</p>
+
+  <pre class="c++">
+#include &lt;string>
+#include &lt;vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string&amp; first,
+          const std::string&amp; last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&amp;
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&amp;
+  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&lt;person> people;
+  </pre>
+
+  <p>While it is clear which parser is responsible for which part of
+     the object model, it is not exactly clear how, for
+     example, <code>gender_pimpl</code> will deliver <code>gender</code>
+     to <code>person_pimpl</code>. You might have noticed that
+     <code>string_pimpl</code> manages to deliver its value to the
+     <code>first_name()</code> callback of <code>person_pimpl</code>. Let's
+     see how we can utilize the same mechanism to propagate our
+     own data.</p>
+
+  <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 <code>post_*()</code> 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
+     <code>gender</code> we can specify the return type for
+     <code>post_gender()</code> in the <code>gender_pskel</code>
+     skeleton and the argument type for the <code>gender()</code> callback
+     in the <code>person_pskel</code> skeleton. As you might have guessed,
+     the generated code will then pass the return value from the
+     <code>post_*()</code> callback as an argument to the element or
+     attribute callback.</p>
+
+  <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 <code>gender</code> type from the previous paragraph:</p>
+
+  <pre class="type-map">
+include "people.hxx";
+gender ::gender ::gender;
+  </pre>
+
+  <p>The first line indicates that the generated code must include
+     <code>people.hxx</code> in order to get the definition for the
+     <code>gender</code> type. The second line specifies that both
+     argument and return types for the <code>gender</code>
+     XML Schema type should be the <code>::gender</code> 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 <code>people.map</code> and
+     then translate our schemas with the <code>--type-map</code>
+     option to let the XSD compiler know about our type map:</p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --type-map people.map people.xsd
+  </pre>
+
+  <p>If we now look at the generated <code>people-pskel.hxx</code>,
+     we will see the following changes in the <code>gender_pskel</code> and
+     <code>person_pskel</code> skeletons:</p>
+
+  <pre class="c++">
+#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);
+
+  ...
+};
+  </pre>
+
+  <p>Notice that <code>#include "people.hxx"</code> was added to
+     the generated header file from the type map to provide the
+     definition for the <code>gender</code> enum.</p>
+
+  <h2><a name="4.2">4.2 Type Map File Format</a></h2>
+
+  <p>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 <code>post_*()</code>
+     callbacks in parser skeletons corresponding to XML Schema
+     types as well as argument types for callbacks corresponding
+     to elements and attributes of these types.</p>
+
+  <p>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 <code>void</code>.
+     By providing your own type maps you can override these predefined
+     rules. The format of the type map file is presented below:
+  </p>
+
+  <pre class="type-map">
+namespace &lt;schema-namespace> [&lt;cxx-namespace>]
+{
+  (include &lt;file-name>;)*
+  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
+}
+  </pre>
+
+  <p>Both <code><i>&lt;schema-namespace></i></code> and
+     <code><i>&lt;schema-type></i></code> are regex patterns while
+     <code><i>&lt;cxx-namespace></i></code>,
+     <code><i>&lt;cxx-ret-type></i></code>, and
+     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
+     substitutions. All names can be optionally enclosed in
+     <code>" "</code>, for example, to include white-spaces.</p>
+
+  <p><code><i>&lt;schema-namespace></i></code> determines XML
+     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
+     is prefixed to every C++ type name in this namespace declaration.
+     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
+     used as a return type for the <code>post_*()</code> callback.
+     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
+     type for callbacks corresponding to elements and attributes
+     of this type. If <code><i>&lt;cxx-arg-type></i></code> is not
+     specified, it defaults to <code><i>&lt;cxx-ret-type></i></code>
+     if <code><i>&lt;cxx-ret-type></i></code> ends with <code>*</code> or
+     <code>&amp;</code> (that is, it is a pointer or a reference) and
+     <code>const&nbsp;<i>&lt;cxx-ret-type></i>&amp;</code>
+     otherwise.
+     <code><i>&lt;file-name></i></code> is a file name either in the
+     <code>" "</code> or <code>&lt; ></code> format
+     and is added with the <code>#include</code> directive to
+     the generated code.</p>
+
+  <p>The <code><b>#</b></code> character starts a comment that ends
+     with a new line or end of file. To specify a name that contains
+     <code><b>#</b></code> enclose it in <code><b>" "</b></code>.
+     For example:</p>
+
+  <pre>
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  </pre>
+
+  <p>In the example above, for the
+     <code>http://www.example.com/xmlns/my#orange</code>
+     XML Schema type, the <code>my::orange_t*</code> C++ type will
+     be used as both return and argument types.</p>
+
+  <p>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:</p>
+
+  <pre class="type-map">
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  </pre>
+
+  <p>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 <code>std::string</code> or
+     <code>std::wstring</code> depending on the character type
+     selected (see <a href="#5.2"> Section 5.2, "Character Type and
+     Encoding"</a> for more information). The binary XML Schema
+     types are mapped to either <code>std::unique_ptr&lt;xml_schema::buffer></code>
+     or <code>std::auto_ptr&lt;xml_schema::buffer></code>
+     depending on the C++ standard selected (C++11 or C++98,
+     respectively; refer to the <code>--std</code> XSD compiler
+     command line option for details).</p>
+
+  <pre class="type-map">
+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&lt;xml_schema::buffer>
+               std::[unique|auto]_ptr&lt;xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr&lt;xml_schema::buffer>
+            std::[unique|auto]_ptr&lt;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;
+}
+  </pre>
+
+  <p>For more information about the mapping of the built-in XML Schema types
+     to C++ types refer to <a href="#6">Chapter 6, "Built-In XML Schema Type
+     Parsers"</a>. The last predefined rule maps anything that wasn't
+     mapped by previous rules to <code>void</code>:</p>
+
+  <pre class="type-map">
+namespace .*
+{
+  .* void void;
+}
+  </pre>
+
+
+  <p>When you provide your own type maps with the
+     <code>--type-map</code> 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 <code>xml_schema</code> namespace. You can include the
+     custom definitions into the generated header file using the
+     <code>--hxx-prologue-*</code> options.</p>
+
+  <h2><a name="4.3">4.3 Parser Implementations</a></h2>
+
+  <p>With the knowledge from the previous section, we can proceed
+     with creating a type map that maps types in the <code>people.xsd</code>
+     schema to our object model classes in
+     <code>people.hxx</code>. In fact, we already have the beginning
+     of our type map file in <code>people.map</code>. Let's extend
+     it with the rest of the types:</p>
+
+  <pre class="type-map">
+include "people.hxx";
+
+gender ::gender ::gender;
+person ::person;
+people ::people;
+  </pre>
+
+  <p>There are a few things to note about this type map. We did not
+     provide the argument types for <code>person</code> and
+     <code>people</code> because the default constant reference is
+     exactly what we need. We also did not provide any mappings
+     for built-in XML Schema types <code>string</code> and
+     <code>short</code> 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:</p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --xml-parser expat --type-map people.map people.xsd
+  </pre>
+
+  <p>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.</p>
+
+
+  <pre class="c++">
+#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&amp; f)
+  {
+    first_ = f;
+  }
+
+  virtual void
+  last_name (const std::string&amp; 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&amp; p)
+  {
+    people_.push_back (p);
+  }
+
+  virtual ::people
+  post_people ()
+  {
+    ::people r;
+    r.swap (people_);
+    return r;
+  }
+
+private:
+  ::people people_;
+};
+  </pre>
+
+  <p>This code fragment should look familiar by now. Just note that
+     all the <code>post_*()</code> callbacks now have return types instead
+     of <code>void</code>. Here is the implementation of the test
+     driver for this example:</p>
+
+  <pre class="c++">
+#include &lt;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 &lt;&lt; "first:  " &lt;&lt; i->first () &lt;&lt; endl
+         &lt;&lt; "last:   " &lt;&lt; i->last () &lt;&lt; endl
+         &lt;&lt; "gender: " &lt;&lt; (i->gender () == male ? "male" : "female") &lt;&lt; endl
+         &lt;&lt; "age:    " &lt;&lt; i->age () &lt;&lt; endl
+         &lt;&lt; endl;
+  }
+}
+  </pre>
+
+  <p>The parser creation and assembly part is exactly the same as in
+     the previous chapter. The parsing part is a bit different:
+     <code>post_people()</code> now has a return value which is the
+     complete object model. We store it in the
+     <code>ppl</code> variable. The last bit of the code simply iterates
+     over the <code>people</code> vector and prints the information
+     for each person. We save the last two code fragments to
+     <code>driver.cxx</code> and proceed to compile and test
+     our new application:</p>
+
+
+  <pre class="terminal">
+$ 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
+  </pre>
+
+
+  <!-- Mapping Configuration -->
+
+
+  <h1><a name="5">5 Mapping Configuration</a></h1>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.
+  </p>
+
+  <h2><a name="5.1">5.1 C++ Standard</a></h2>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h2><a name="5.2">5.2 Character Type and Encoding</a></h2>
+
+  <p>The C++/Parser mapping has built-in support for two character types:
+    <code>char</code> and <code>wchar_t</code>. You can select the
+    character type with the <code>--char-type</code> command line
+    option. The default character type is <code>char</code>. The
+    string-based built-in XML Schema types are returned as either
+    <code>std::string</code> or <code>std::wstring</code> depending
+    on the character type selected.</p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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 <code>--char-encoding</code> command
+     line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <p>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.</p>
+
+  <h2><a name="5.3">5.3 Underlying XML Parser</a></h2>
+
+  <p>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 <code>--xml-parser</code> command line option. Valid values
+     for this option are <code>xerces</code> and <code>expat</code>.
+     The default XML parser is Xerces-C++.</p>
+
+  <p>The generated code is identical for both parsers except for the
+     <code>xml_schema::document</code> class in which some of the
+     <code>parse()</code> functions are parser-specific as described
+     in <a href="#7">Chapter 7, "Document Parser and Error Handling"</a>.</p>
+
+
+  <h2><a name="5.4">5.4 XML Schema Validation</a></h2>
+
+  <p>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
+     <a href="#A">Appendix A, "Supported XML Schema Constructs"</a>.</p>
+
+  <p>By default validation in the generated code is disabled if
+     the underlying XML parser is validating (Xerces-C++) and
+     enabled otherwise (Expat). See <a href="#5.3">Section 5.3,
+     "Underlying XML Parser"</a> for more information about
+     the underlying XML parser. You can override the default
+     behavior with the <code>--generate-validation</code>
+     and <code>--suppress-validation</code> command line options.</p>
+
+
+  <h2><a name="5.5">5.5 Support for Polymorphism</a></h2>
+
+  <p>By default the XSD compiler generates non-polymorphic code. If your
+     vocabulary uses XML Schema polymorphism in the form of <code>xsi:type</code>
+     and/or substitution groups, then you will need to compile your schemas
+     with the <code>--generate-polymorphic</code> option to produce
+     polymorphism-aware code as well as pass <code>true</code> as the last
+     argument to the <code>xml_schema::document</code>'s constructors.</p>
+
+  <p>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 <code>xsi:type</code> attribute value or an element
+     name from a substitution group. Consider the following schema as an
+     example:</p>
+
+  <pre class="xml">
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="person">
+    &lt;xs:sequence>
+      &lt;xs:element name="name" type="xs:string"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;!-- substitution group root -->
+  &lt;xs:element name="person" type="person"/>
+
+  &lt;xs:complexType name="superman">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="person">
+        &lt;xs:attribute name="can-fly" type="xs:boolean"/>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  &lt;xs:complexType name="batman">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="superman">
+        &lt;xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  &lt;xs:complexType name="supermen">
+    &lt;xs:sequence>
+      &lt;xs:element ref="person" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="supermen" type="supermen"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Conforming XML documents can use the <code>superman</code>
+     and <code>batman</code> types in place of the <code>person</code>
+     type either by specifying the type with the <code>xsi:type</code>
+     attributes or by using the elements from the substitution
+     group, for instance:</p>
+
+
+  <pre class="xml">
+&lt;supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  &lt;person>
+    &lt;name>John Doe&lt;/name>
+  &lt;/person>
+
+  &lt;superman can-fly="false">
+    &lt;name>James "007" Bond&lt;/name>
+  &lt;/superman>
+
+  &lt;superman can-fly="true" wing-span="10" xsi:type="batman">
+    &lt;name>Bruce Wayne&lt;/name>
+  &lt;/superman>
+
+&lt;/supermen>
+  </pre>
+
+  <p>To print the data stored in such XML documents we can implement
+     the parsers as follows:</p>
+
+  <pre class="c++">
+class person_pimpl: public virtual person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse person" &lt;&lt; endl;
+  }
+
+  virtual void
+  name (const std::string&amp; v)
+  {
+    cout &lt;&lt; "name: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    cout &lt;&lt; "finished parsing person" &lt;&lt; endl;
+  }
+};
+
+class superman_pimpl: public virtual superman_pskel,
+                      public person_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse superman" &lt;&lt; endl;
+  }
+
+  virtual void
+  can_fly (bool v)
+  {
+    cout &lt;&lt; "can-fly: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    cout &lt;&lt; "finished parsing superman" &lt;&lt; endl
+  }
+};
+
+class batman_pimpl: public virtual batman_pskel,
+                    public superman_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse batman" &lt;&lt; endl;
+  }
+
+  virtual void
+  wing_span (unsigned int v)
+  {
+    cout &lt;&lt; "wing-span: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_superman ()
+  {
+    post_batman ();
+  }
+
+  virtual void
+  post_batman ()
+  {
+    cout &lt;&lt; "finished parsing batman" &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Note that because the derived type parsers (<code>superman_pskel</code>
+     and <code>batman_pskel</code>) are called via the <code>person_pskel</code>
+     interface, we have to override the <code>post_person()</code>
+     virtual function in <code>superman_pimpl</code> to call
+     <code>post_superman()</code> and the <code>post_superman()</code>
+     virtual function in <code>batman_pimpl</code> to call
+     <code>post_batman()</code>.</p>
+
+  <p>The following code fragment shows how to connect the parsers together.
+     Notice that for the <code>person</code> element in the <code>supermen_p</code>
+     parser we specify a parser map instead of a specific parser and we pass
+     <code>true</code> as the last argument to the document parser constructor
+     to indicate that we are parsing potentially-polymorphic XML documents:</p>
+
+  <pre class="c++">
+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 ();
+}
+  </pre>
+
+  <p>When polymorphism-aware code is generated, each element's
+     <code>*_parser()</code> function is overloaded to also accept
+     an object of the <code>xml_schema::parser_map</code> type.
+     For example, the <code>supermen_pskel</code> class from the
+     above example looks like this:</p>
+
+  <pre class="c++">
+class supermen_pskel: public xml_schema::parser_complex_content
+{
+public:
+
+  ...
+
+  // Parser construction API.
+  //
+  void
+  parsers (person_pskel&amp;);
+
+  // Individual element parsers.
+  //
+  void
+  person_parser (person_pskel&amp;);
+
+  void
+  person_parser (const xml_schema::parser_map&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>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
+     <code>xsi:type</code> 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:</p>
+
+  <pre class="c++">
+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);
+
+  ...
+}
+  </pre>
+
+
+  <p>The <code>xml_schema::parser_map</code> interface and the
+     <code>xml_schema::parser_map_impl</code> default implementation
+     are presented below:</p>
+
+  <pre class="c++">
+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&amp;);
+
+    virtual parser_base*
+    find (const ro_string* type) const;
+
+  private:
+    parser_map_impl (const parser_map_impl&amp;);
+
+    parser_map_impl&amp;
+    operator= (const parser_map_impl&amp;);
+
+    ...
+  };
+}
+  </pre>
+
+  <p>The <code>type</code> argument in the <code>find()</code> 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
+     <code>"&lt;name>&nbsp;&lt;namespace>"</code> 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 <code>_dynamic_type()</code> function. The static
+     type can be obtained by calling the static <code>_static_type()</code>
+     function, for example <code>person_pskel::_static_type()</code>.
+     Both functions return a C string (<code>const char*</code> or
+     <code>const wchar_t*</code>, 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 <code>std::map</code>:</p>
+
+
+  <pre class="c++">
+#include &lt;map>
+#include &lt;string>
+
+class parser_map: public xml_schema::parser_map
+{
+public:
+ void
+ insert (xml_schema::parser_base&amp; p)
+ {
+   map_[p._dynamic_type ()] = &amp;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&lt;std::string, xml_schema::parser_base*> map;
+  map map_;
+};
+  </pre>
+
+  <p>Most of code presented in this section is taken from the
+     <code>polymorphism</code> example which can be found in the
+     <code>cxx/parser/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> package.
+     Handling of <code>xsi:type</code> and substitution groups when used on
+     root elements requires a number of special actions as shown in
+     the <code>polyroot</code> example.</p>
+
+
+  <!-- Built-in XML Schema Type Parsers -->
+
+
+  <h1><a name="6">6 Built-In XML Schema Type Parsers</a></h1>
+
+  <p>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 <code>std::string</code> or
+     <code>std::wstring</code> depending on the character type selected.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Parser implementation in the <code>xml_schema</code> namespace</th>
+      <th>Parser return type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">anyType and anySimpleType types</th>
+    </tr>
+    <tr>
+      <td><code>anyType</code></td>
+      <td><code>any_type_pimpl</code></td>
+      <td><code>void</code></td>
+    </tr>
+    <tr>
+      <td><code>anySimpleType</code></td>
+      <td><code>any_simple_type_pimpl</code></td>
+      <td><code>void</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte_pimpl</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte_pimpl</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_pimpl</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short_pimpl</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_pimpl</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int_pimpl</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long_pimpl</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer_pimpl</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer_pimpl</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean_pimpl</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_pimpl</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_pimpl</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal_pimpl</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string-based types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname_pimpl</code></td>
+      <td><code>xml_schema::qname</code><br/><a href="#6.1">Section 6.1,
+          "<code>QName</code> Parser"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">list types</th>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens_pimpl</code></td>
+      <td><code>xml_schema::string_sequence</code><br/><a href="#6.2">Section
+          6.2, "<code>NMTOKENS</code> and <code>IDREFS</code> Parsers"</a></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs_pimpl</code></td>
+      <td><code>xml_schema::string_sequence</code><br/><a href="#6.2">Section
+          6.2, "<code>NMTOKENS</code> and <code>IDREFS</code> Parsers"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary_pimpl</code></td>
+      <td><code>std::[unique|auto]_ptr&lt; xml_schema::buffer></code><br/>
+          <a href="#6.3">Section 6.3, "<code>base64Binary</code> and
+          <code>hexBinary</code> Parsers"</a></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary_pimpl</code></td>
+      <td><code>std::[unique|auto]_ptr&lt; xml_schema::buffer></code><br/>
+          <a href="#6.3">Section 6.3, "<code>base64Binary</code> and
+          <code>hexBinary</code> Parsers"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date_pimpl</code></td>
+      <td><code>xml_schema::date</code><br/><a href="#6.5">Section 6.5,
+          "<code>date</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time_pimpl</code></td>
+      <td><code>xml_schema::date_time</code><br/><a href="#6.6">Section 6.6,
+          "<code>dateTime</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration_pimpl</code></td>
+      <td><code>xml_schema::duration</code><br/><a href="#6.7">Section 6.7,
+          "<code>duration</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday_pimpl</code></td>
+      <td><code>xml_schema::gday</code><br/><a href="#6.8">Section 6.8,
+          "<code>gDay</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth_pimpl</code></td>
+      <td><code>xml_schema::gmonth</code><br/><a href="#6.9">Section 6.9,
+          "<code>gMonth</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day_pimpl</code></td>
+      <td><code>xml_schema::gmonth_day</code><br/><a href="#6.10">Section 6.10,
+          "<code>gMonthDay</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear_pimpl</code></td>
+      <td><code>xml_schema::gyear</code><br/><a href="#6.11">Section 6.11,
+          "<code>gYear</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month_pimpl</code></td>
+      <td><code>xml_schema::gyear_month</code><br/><a href="#6.12">Section
+          6.12, "<code>gYearMonth</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time_pimpl</code></td>
+      <td><code>xml_schema::time</code><br/><a href="#6.13">Section 6.13,
+          "<code>time</code> Parser"</a></td>
+    </tr>
+
+  </table>
+
+  <h2><a name="6.1">6.1 <code>QName</code> Parser</a></h2>
+
+  <p>The return type of the <code>qname_pimpl</code> parser implementation
+     is <code>xml_schema::qname</code> which represents an XML qualified
+     name. Its interface is presented below.
+     Note that the <code>std::string</code> type in the interface becomes
+     <code>std::wstring</code> if the selected character type is
+     <code>wchar_t</code>.</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    explicit
+    qname (const std::string&amp; name);
+    qname (const std::string&amp; prefix, const std::string&amp; name);
+
+    const std::string&amp;
+    prefix () const;
+
+    void
+    prefix (const std::string&amp;);
+
+    const std::string&amp;
+    name () const;
+
+    void
+    name (const std::string&amp;);
+  };
+
+  bool
+  operator== (const qname&amp;, const qname&amp;);
+
+  bool
+  operator!= (const qname&amp;, const qname&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.2">6.2 <code>NMTOKENS</code> and <code>IDREFS</code> Parsers</a></h2>
+
+  <p>The return type of the <code>nmtokens_pimpl</code> and
+     <code>idrefs_pimpl</code> parser implementations is
+     <code>xml_schema::string_sequence</code> which represents a
+     sequence of strings. Its interface is presented below.
+     Note that the <code>std::string</code> type in the interface becomes
+     <code>std::wstring</code> if the selected character type is
+     <code>wchar_t</code>.</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class string_sequence: public std::vector&lt;std::string>
+  {
+  public:
+    string_sequence ();
+
+    explicit
+    string_sequence (std::vector&lt;std::string>::size_type n,
+                     const std::string&amp; x = std::string ());
+
+    template &lt;typename I>
+    string_sequence (const I&amp; begin, const I&amp; end);
+  };
+
+  bool
+  operator== (const string_sequence&amp;, const string_sequence&amp;);
+
+  bool
+  operator!= (const string_sequence&amp;, const string_sequence&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.3">6.3 <code>base64Binary</code> and <code>hexBinary</code> Parsers</a></h2>
+
+  <p>The return type of the <code>base64_binary_pimpl</code> and
+     <code>hex_binary_pimpl</code> parser implementations is either
+     <code>std::unique_ptr&lt;xml_schema::buffer></code> (C++11) or
+     <code>std::auto_ptr&lt;xml_schema::buffer></code> (C++98),
+     depending on the C++ standard selected (<code>--std</code> XSD
+     compiler option). The <code>xml_schema::buffer</code> type
+     represents a binary buffer and its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;);
+
+    buffer&amp;
+    operator= (const buffer&amp;);
+
+    void
+    swap (buffer&amp;);
+
+  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&amp;, const buffer&amp;);
+
+  bool
+  operator!= (const buffer&amp;, const buffer&amp;);
+}
+  </pre>
+
+  <p>If the <code>assume_ownership</code> argument to the constructor
+     is <code>true</code>, the instance assumes the ownership of the
+     memory block pointed to by the <code>data</code> argument and will
+     eventually release it by calling <code>operator delete()</code>. The
+     <code>capacity()</code> and <code>size()</code> modifier functions
+     return <code>true</code> if the underlying buffer has moved.
+  </p>
+
+  <p>The <code>bounds</code> exception is thrown if the constructor
+     arguments violate the <code>(size&nbsp;&lt;=&nbsp;capacity)</code>
+     constraint.</p>
+
+
+  <h2><a name="6.4">6.4 Time Zone Representation</a></h2>
+
+  <p>The <code>date</code>, <code>dateTime</code>, <code>gDay</code>,
+     <code>gMonth</code>, <code>gMonthDay</code>, <code>gYear</code>,
+     <code>gYearMonth</code>, and <code>time</code> XML Schema built-in
+     types all include an optional time zone component. The following
+     <code>xml_schema::time_zone</code> base class is used to represent
+     this information:</p>
+
+  <pre class="c++">
+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&amp;, const time_zone&amp;);
+
+  bool
+  operator!= (const time_zone&amp;, const time_zone&amp;);
+}
+  </pre>
+
+  <p>The <code>zone_present()</code> accessor function returns <code>true</code>
+     if the time zone is specified. The <code>zone_reset()</code> modifier
+     function resets the time zone object to the <em>not specified</em>
+     state. If the time zone offset is negative then both hours and
+     minutes components are represented as negative integers.</p>
+
+
+  <h2><a name="6.5">6.5 <code>date</code> Parser</a></h2>
+
+ <p>The return type of the <code>date_pimpl</code> parser implementation
+     is <code>xml_schema::date</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const date&amp;);
+
+  bool
+  operator!= (const date&amp;, const date&amp;);
+}
+  </pre>
+
+  <h2><a name="6.6">6.6 <code>dateTime</code> Parser</a></h2>
+
+  <p>The return type of the <code>date_time_pimpl</code> parser implementation
+     is <code>xml_schema::date_time</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const date_time&amp;);
+
+  bool
+  operator!= (const date_time&amp;, const date_time&amp;);
+}
+  </pre>
+
+  <h2><a name="6.7">6.7 <code>duration</code> Parser</a></h2>
+
+  <p>The return type of the <code>duration_pimpl</code> parser implementation
+     is <code>xml_schema::duration</code> which represents a potentially
+     negative duration in the form of years, months, days, hours, minutes,
+     and seconds. Its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;, const duration&amp;);
+
+  bool
+  operator!= (const duration&amp;, const duration&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.8">6.8 <code>gDay</code> Parser</a></h2>
+
+  <p>The return type of the <code>gday_pimpl</code> parser implementation
+     is <code>xml_schema::gday</code> which represents a day of the month with
+     an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gday&amp;);
+
+  bool
+  operator!= (const gday&amp;, const gday&amp;);
+}
+  </pre>
+
+  <h2><a name="6.9">6.9 <code>gMonth</code> Parser</a></h2>
+
+  <p>The return type of the <code>gmonth_pimpl</code> parser implementation
+     is <code>xml_schema::gmonth</code> which represents a month of the year
+     with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gmonth&amp;);
+
+  bool
+  operator!= (const gmonth&amp;, const gmonth&amp;);
+}
+  </pre>
+
+  <h2><a name="6.10">6.10 <code>gMonthDay</code> Parser</a></h2>
+
+  <p>The return type of the <code>gmonth_day_pimpl</code> parser implementation
+     is <code>xml_schema::gmonth_day</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gmonth_day&amp;);
+
+  bool
+  operator!= (const gmonth_day&amp;, const gmonth_day&amp;);
+}
+  </pre>
+
+  <h2><a name="6.11">6.11 <code>gYear</code> Parser</a></h2>
+
+  <p>The return type of the <code>gyear_pimpl</code> parser implementation
+     is <code>xml_schema::gyear</code> which represents a year with
+     an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gyear&amp;);
+
+  bool
+  operator!= (const gyear&amp;, const gyear&amp;);
+}
+  </pre>
+
+  <h2><a name="6.12">6.12 <code>gYearMonth</code> Parser</a></h2>
+
+  <p>The return type of the <code>gyear_month_pimpl</code> parser implementation
+     is <code>xml_schema::gyear_month</code> which represents a year and a month
+     with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gyear_month&amp;);
+
+  bool
+  operator!= (const gyear_month&amp;, const gyear_month&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.13">6.13 <code>time</code> Parser</a></h2>
+
+ <p>The return type of the <code>time_pimpl</code> parser implementation
+     is <code>xml_schema::time</code> which represents hours, minutes,
+     and seconds with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const time&amp;);
+
+  bool
+  operator!= (const time&amp;, const time&amp;);
+}
+  </pre>
+
+
+  <!-- Error Handling -->
+
+
+  <h1><a name="7">7 Document Parser and Error Handling</a></h1>
+
+  <p>In this chapter we will discuss the <code>xml_schema::document</code>
+     type as well as the error handling mechanisms provided by the mapping
+     in more detail. As mentioned in <a href="#3.4">Section 3.4,
+     "Connecting the Parsers Together"</a>, the interface of
+     <code>xml_schema::document</code> depends on the underlying XML
+     parser selected (<a href="#5.3">Section 5.3, "Underlying XML
+     Parser"</a>). The following sections describe the
+     <code>document</code> type interface for Xerces-C++ and
+     Expat as underlying parsers.</p>
+
+  <h2><a name="7.1">7.1 Xerces-C++ Document Parser</a></h2>
+
+  <p>When Xerces-C++ is used as the underlying XML parser, the
+     <code>document</code> type has the following interface. Note that
+     if the character type is <code>wchar_t</code>, then the string type
+     in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+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&amp; namespace_,
+                     const std::string&amp; location);
+
+    // Add a location for a schema without a target namespace.
+    //
+    void
+    no_namespace_schema_location (const std::string&amp; location);
+  };
+
+  class document
+  {
+  public:
+    document (parser_base&amp; root,
+              const std::string&amp; root_element_name,
+	      bool polymorphic = false);
+
+    document (parser_base&amp; root,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; root_element_name,
+	      bool polymorphic = false);
+
+  public:
+    // Parse URI or a local file.
+    //
+    void
+    parse (const std::string&amp; uri,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse URI or a local file with a user-provided error_handler
+    // object.
+    //
+    void
+    parse (const std::string&amp; uri,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp; uri,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp; uri,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse InputSource. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+  };
+}
+  </pre>
+
+  <p>The <code>document</code> 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 <code>parser_base</code>
+     class is the base type for all parser skeletons. The second and
+     third arguments to the <code>document</code>'s constructors are
+     the root element's name and namespace. The last argument,
+     <code>polymorphic</code>, 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 <a href="#5.5">Section 5.5, "Support for Polymorphism"</a>.</p>
+
+  <p>The rest of the <code>document</code> interface consists of overloaded
+     <code>parse()</code> functions. The last two arguments in each of these
+     functions are <code>flags</code> and <code>properties</code>. The
+     <code>flags</code> argument allows you to modify the default behavior
+     of the parsing functions. The <code>properties</code> 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 <code>file:///absolute/path/to/your/schema</code>.</p>
+
+  <p>A number of overloaded <code>parse()</code> functions have the
+     <code>system_id</code> and <code>public_id</code> arguments. The
+     system id is a <em>system</em> identifier of the resources being
+     parsed (for example, URI or a full file path). The public id is a
+     <em>public</em> 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.</p>
+
+  <p>The error handling mechanisms employed by the <code>document</code>
+     parser are described in <a href="#7.3">Section 7.3, "Error
+     Handling"</a>.</p>
+
+  <h2><a name="7.2">7.2 Expat Document Parser</a></h2>
+
+  <p>When Expat is used as the underlying XML parser, the
+     <code>document</code> type has the following interface. Note that
+     if the character type is <code>wchar_t</code>, then the string type
+     in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class document
+  {
+  public:
+    document (parser_base&amp;,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    document (parser_base&amp;,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; 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&amp; 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&amp; file, error_handler&amp;);
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&amp;);
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&amp;, error_handler&amp;);
+
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&amp;, const std::string&amp; system_id);
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           error_handler&amp;);
+
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id);
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;);
+
+  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&amp;);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           error_handler&amp;);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;);
+
+  public:
+    // Low-level Expat-specific parsing API.
+    //
+    void
+    parse_begin (XML_Parser);
+
+    void
+    parse_begin (XML_Parser, const std::string&amp; public_id);
+
+    void
+    parse_begin (XML_Parser, error_handler&amp;);
+
+    void
+    parse_begin (XML_Parser,
+                 const std::string&amp; public_id,
+                 error_handler&amp;);
+    void
+    parse_end ();
+  };
+}
+  </pre>
+
+  <p>The <code>document</code> 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 <code>parser_base</code>
+     class is the base type for all parser skeletons. The second and
+     third arguments to the <code>document</code>'s constructors are
+     the root element's name and namespace. The last argument,
+     <code>polymorphic</code>, 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 <a href="#5.5">Section 5.5, "Support for Polymorphism"</a>.</p>
+
+  <p>A number of overloaded <code>parse()</code> functions have the
+     <code>system_id</code> and <code>public_id</code> arguments. The
+     system id is a <em>system</em> identifier of the resources being
+     parsed (for example, URI or a full file path). The public id is a
+     <em>public</em> 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.</p>
+
+  <p>The <code>parse_begin()</code> and <code>parse_end()</code> functions
+     present a low-level, Expat-specific parsing API for maximum control.
+     A typical use-case would look like this (pseudo-code):</p>
+
+  <pre class="c++">
+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 ());
+  </pre>
+
+  <p>Note that if your vocabulary uses XML namespaces, the
+     <code>XML_ParserCreateNS()</code> functions should be used to create
+     the XML parser. Space (<code>XML_Char (' ')</code>) should be used
+     as a separator (the second argument to <code>XML_ParserCreateNS()</code>).
+  </p>
+
+  <p>The error handling mechanisms employed by the <code>document</code>
+     parser are described in <a href="#7.3">Section 7.3, "Error
+     Handling"</a>.</p>
+
+
+  <h2><a name="7.3">7.3 Error Handling</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>The System errors are mapped to the standard exceptions. The
+     out of memory condition is indicated by throwing an instance
+     of <code>std::bad_alloc</code>. The stream operation errors
+     are reported either by throwing an instance of
+     <code>std::ios_base::failure</code> if exceptions are enabled
+     or by setting the stream state.</p>
+
+  <p>Note that if you are parsing <code>std::istream</code> on
+     which exceptions are not enabled, then you will need to
+     check the stream state before calling the <code>post()</code>
+     callback, as shown in the following example:</p>
+
+  <pre class="c++">
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  std::ifstream ifs (argv[1]);
+
+  if (ifs.fail ())
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": unable to open" &lt;&lt; endl;
+    return 1;
+  }
+
+  root_p.pre ();
+  doc_p.parse (ifs);
+
+  if (ifs.fail ())
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": io failure" &lt;&lt; endl;
+    return 1;
+  }
+
+  result_type result (root_p.post_xxx ());
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions
+     as shown below:</p>
+
+  <pre class="c++">
+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&amp;)
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": unable to open or io failure" &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+
+  <p>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.</p>
+
+  <p>The XML errors can be reported either by throwing the
+     <code>xml_schema::parsing</code> exception or by a callback
+     to the <code>xml_schema::error_handler</code> object (and
+     <code>xercesc::ErrorHandler</code> object in case of Xerces-C++).</p>
+
+  <p>The <code>xml_schema::parsing</code> 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
+     <code>xml_schema::parsing</code> exception. Note that if the
+     character type is <code>wchar_t</code>, then the string type
+     and output stream type in the definition become
+     <code>std::wstring</code> and <code>std::wostream</code>,
+     respectively (see <a href="#5.2">Section 5.2, "Character Type
+     and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class exception: public std::exception
+  {
+  protected:
+    virtual void
+    print (std::ostream&amp;) const = 0;
+  };
+
+  inline std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp; os, const exception&amp; e)
+  {
+    e.print (os);
+    return os;
+  }
+
+
+  class severity
+  {
+  public:
+    enum value
+    {
+      warning,
+      error
+    };
+  };
+
+
+  class error
+  {
+  public:
+    error (xml_schema::severity,
+           const std::string&amp; id,
+           unsigned long line,
+           unsigned long column,
+           const std::string&amp; message);
+
+    xml_schema::severity
+    severity () const;
+
+    const std::string&amp;
+    id () const;
+
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    const std::string&amp;
+    message () const;
+  };
+
+  std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp;, const error&amp;);
+
+
+  class diagnostics: public std::vector&lt;error>
+  {
+  };
+
+  std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp;, const diagnostics&amp;);
+
+
+  class parsing: public exception
+  {
+  public:
+    parsing ();
+    parsing (const xml_schema::diagnostics&amp;);
+
+    const xml_schema::diagnostics&amp;
+    diagnostics () const;
+
+    virtual const char*
+    what () const throw ();
+
+  protected:
+    virtual void
+    print (std::ostream&amp;) const;
+  };
+}
+  </pre>
+
+  <p>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.</p>
+
+  <pre class="c++">
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+  }
+  catch (const xml_schema::parsing&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>With the <code>error_handler</code> approach the diagnostics
+     messages are delivered as parsing progresses. The following
+     listing presents the definition of the <code>error_handler</code>
+     interface. Note that if the character type is <code>wchar_t</code>,
+     then the string type in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class error_handler
+  {
+  public:
+    class severity
+    {
+    public:
+      enum value
+      {
+        warning,
+        error,
+        fatal
+      };
+    };
+
+    virtual bool
+    handle (const std::string&amp; id,
+            unsigned long line,
+            unsigned long column,
+            severity,
+            const std::string&amp; message) = 0;
+  };
+}
+  </pre>
+
+  <p>The return value of the <code>handle()</code> 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  <code>error_handler</code> object, an empty
+     <code>xml_schema::parsing</code> exception is thrown to indicate
+     the failure to the caller. You can alter this behavior by throwing
+     your own exception from the <code>handle()</code> function.</p>
+
+
+  <!-- Appendix A -->
+
+
+  <h1><a name="A">Appendix A &mdash; Supported XML Schema Constructs</a></h1>
+
+  <p>The C++/Parser mapping supports validation of the following W3C XML
+     Schema constructs in the generated code.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="features" border="1">
+    <tr><th>Construct</th><th>Notes</th></tr>
+    <tr><th colspan="2">Structure</th></tr>
+
+    <tr><td>element</td><td></td></tr>
+    <tr><td>attribute</td><td></td></tr>
+
+    <tr><td>any</td><td></td></tr>
+    <tr><td>anyAttribute</td><td></td></tr>
+
+    <tr><td>all</td><td></td></tr>
+    <tr><td>sequence</td><td></td></tr>
+    <tr><td>choice</td><td></td></tr>
+
+    <tr><td>complex type, empty content</td><td></td></tr>
+    <tr><td>complex type, mixed content</td><td></td></tr>
+    <tr><td>complex type, simple content extension</td><td></td></tr>
+    <tr><td>complex type, simple content restriction</td>
+        <td>Simple type facets are not validated.</td></tr>
+    <tr><td>complex type, complex content extension</td><td></td></tr>
+    <tr><td>complex type, complex content restriction</td><td></td></tr>
+
+    <tr><td>list</td><td></td></tr>
+
+    <tr><th colspan="2">Datatypes</th></tr>
+
+    <tr><td>byte</td><td></td></tr>
+    <tr><td>unsignedByte</td><td></td></tr>
+    <tr><td>short</td><td></td></tr>
+    <tr><td>unsignedShort</td><td></td></tr>
+    <tr><td>int</td><td></td></tr>
+    <tr><td>unsignedInt</td><td></td></tr>
+    <tr><td>long</td><td></td></tr>
+    <tr><td>unsignedLong</td><td></td></tr>
+    <tr><td>integer</td><td></td></tr>
+    <tr><td>nonPositiveInteger</td><td></td></tr>
+    <tr><td>nonNegativeInteger</td><td></td></tr>
+    <tr><td>positiveInteger</td><td></td></tr>
+    <tr><td>negativeInteger</td><td></td></tr>
+
+    <tr><td>boolean</td><td></td></tr>
+
+    <tr><td>float</td><td></td></tr>
+    <tr><td>double</td><td></td></tr>
+    <tr><td>decimal</td><td></td></tr>
+
+    <tr><td>string</td><td></td></tr>
+    <tr><td>normalizedString</td><td></td></tr>
+    <tr><td>token</td><td></td></tr>
+    <tr><td>Name</td><td></td></tr>
+    <tr><td>NMTOKEN</td><td></td></tr>
+    <tr><td>NCName</td><td></td></tr>
+    <tr><td>language</td><td></td></tr>
+    <tr><td>anyURI</td><td></td></tr>
+
+    <tr><td>ID</td><td>Identity constraint is not enforced.</td></tr>
+    <tr><td>IDREF</td><td>Identity constraint is not enforced.</td></tr>
+
+    <tr><td>NMTOKENS</td><td></td></tr>
+    <tr><td>IDREFS</td><td>Identity constraint is not enforced.</td></tr>
+
+    <tr><td>QName</td><td></td></tr>
+
+    <tr><td>base64Binary</td><td></td></tr>
+    <tr><td>hexBinary</td><td></td></tr>
+
+    <tr><td>date</td><td></td></tr>
+    <tr><td>dateTime</td><td></td></tr>
+    <tr><td>duration</td><td></td></tr>
+    <tr><td>gDay</td><td></td></tr>
+    <tr><td>gMonth</td><td></td></tr>
+    <tr><td>gMonthDay</td><td></td></tr>
+    <tr><td>gYear</td><td></td></tr>
+    <tr><td>gYearMonth</td><td></td></tr>
+    <tr><td>time</td><td></td></tr>
+  </table>
+
+
+  </div>
+</div>
+
+</body>
+</html>
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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Parser Mapping Getting Started Guide</title>
+
+  <meta name="copyright" content="&#169; @copyright@"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,parser,validation"/>
+  <meta name="description" content="C++/Parser Mapping Getting Started Guide"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+    line-height: 1.2em;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 140%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage .title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+  }
+
+  #titlepage #first-title {
+    padding: 1em 0 0.4em 0;
+  }
+
+  #titlepage #second-title {
+    padding: 0.4em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+  ol.steps {
+    padding-left     : 1.8em;
+  }
+
+  ol.steps li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+
+  div.img {
+    text-align: center;
+    padding: 2em 0 2em 0;
+  }
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+  /* XML Schema features table. */
+  #features {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #features th, #features td {
+    border: 1px solid;
+    padding           : 0.6em 0.6em 0.6em 0.6em;
+  }
+
+  #features th {
+    background : #cde8f6;
+  }
+
+  #features td {
+    text-align: left;
+  }
+
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div class="title" id="first-title">C++/Parser Mapping</div>
+    <div class="title" id="second-title">Getting Started Guide</div>
+
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.ps">PostScript</a>.</p>
+
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+          <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a>
+        <table class="toc">
+          <tr><th>1.1</th><td><a href="#1.1">Mapping Overview</a></td></tr>
+          <tr><th>1.2</th><td><a href="#1.2">Benefits</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">Hello World Example</a>
+        <table class="toc">
+          <tr><th>2.1</th><td><a href="#2.1">Writing XML Document and Schema</a></td></tr>
+          <tr><th>2.2</th><td><a href="#2.2">Translating Schema to C++</a></td></tr>
+          <tr><th>2.3</th><td><a href="#2.3">Implementing Application Logic</a></td></tr>
+          <tr><th>2.4</th><td><a href="#2.4">Compiling and Running</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Parser Skeletons</a>
+        <table class="toc">
+          <tr><th>3.1</th><td><a href="#3.1">Implementing the Gender Parser</a></td></tr>
+          <tr><th>3.2</th><td><a href="#3.2">Implementing the Person Parser</a></td></tr>
+          <tr><th>3.3</th><td><a href="#3.3">Implementing the People Parser</a></td></tr>
+          <tr><th>3.4</th><td><a href="#3.4">Connecting the Parsers Together</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Type Maps</a>
+        <table class="toc">
+          <tr><th>4.1</th><td><a href="#4.1">Object Model</a></td></tr>
+          <tr><th>4.2</th><td><a href="#4.2">Type Map File Format</a></td></tr>
+          <tr><th>4.3</th><td><a href="#4.3">Parser Implementations</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Mapping Configuration</a>
+        <table class="toc">
+          <tr><th>5.1</th><td><a href="#5.1">C++ Standard</a></td></tr>
+          <tr><th>5.2</th><td><a href="#5.2">Character Type and Encoding</a></td></tr>
+          <tr><th>5.3</th><td><a href="#5.3">Underlying XML Parser</a></td></tr>
+	  <tr><th>5.4</th><td><a href="#5.4">XML Schema Validation</a></td></tr>
+	  <tr><th>5.5</th><td><a href="#5.5">Support for Polymorphism</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>6</th><td><a href="#6">Built-In XML Schema Type Parsers</a>
+        <table class="toc">
+          <tr><th>6.1</th><td><a href="#6.1"><code>QName</code> Parser</a></td></tr>
+          <tr><th>6.2</th><td><a href="#6.2"><code>NMTOKENS</code> and <code>IDREFS</code> Parsers</a></td></tr>
+          <tr><th>6.3</th><td><a href="#6.3"><code>base64Binary</code> and <code>hexBinary</code> Parsers</a></td></tr>
+	  <tr><th>6.4</th><td><a href="#6.4">Time Zone Representation</a></td></tr>
+	  <tr><th>6.5</th><td><a href="#6.5"><code>date</code> Parser</a></td></tr>
+	  <tr><th>6.6</th><td><a href="#6.6"><code>dateTime</code> Parser</a></td></tr>
+	  <tr><th>6.7</th><td><a href="#6.7"><code>duration</code> Parser</a></td></tr>
+	  <tr><th>6.8</th><td><a href="#6.8"><code>gDay</code> Parser</a></td></tr>
+	  <tr><th>6.9</th><td><a href="#6.9"><code>gMonth</code> Parser</a></td></tr>
+	  <tr><th>6.10</th><td><a href="#6.10"><code>gMonthDay</code> Parser</a></td></tr>
+	  <tr><th>6.11</th><td><a href="#6.11"><code>gYear</code> Parser</a></td></tr>
+	  <tr><th>6.12</th><td><a href="#6.12"><code>gYearMonth</code> Parser</a></td></tr>
+	  <tr><th>6.13</th><td><a href="#6.13"><code>time</code> Parser</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>7</th><td><a href="#7">Document Parser and Error Handling</a>
+        <table class="toc">
+          <tr><th>7.1</th><td><a href="#7.1">Xerces-C++ Document Parser</a></td></tr>
+          <tr><th>7.2</th><td><a href="#7.2">Expat Document Parser</a></td></tr>
+          <tr><th>7.3</th><td><a href="#7.3">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th></th><td><a href="#A">Appendix A &mdash; Supported XML Schema Constructs</a></td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this guide, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/parser/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is the place to ask technical questions about XSD and the C++/Parser mapping.
+        Furthermore, the <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+
+  </ul>
+
+  <!-- Introduction -->
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.
+  </p>
+
+  <h2><a name="1.1">1.1 Mapping Overview</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="1.2">1.2 Benefits</a></h2>
+
+  <p>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:
+  </p>
+
+  <ul class="list">
+    <li>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.</li>
+
+    <li>String-based flow control defers error detection to runtime.
+        It also reduces code readability and maintainability.</li>
+
+    <li>Lack of type safety because the data is represented
+        as text.</li>
+
+    <li>Resulting applications are hard to debug, change, and
+        maintain.</li>
+  </ul>
+
+  <p>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:</p>
+
+  <ul class="list">
+    <li><b>Ease of use.</b> 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.</li>
+
+    <li><b>Natural representation.</b> 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.
+    </li>
+
+    <li><b>Concise code.</b> With a separate parser skeleton for each
+        XML Schema type, the application implementation is
+        simpler and thus easier to read and understand.</li>
+
+    <li><b>Safety.</b> 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.</li>
+
+    <li><b>Maintainability.</b> 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.</li>
+
+   <li><b>Efficiency.</b> 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.</li>
+  </ul>
+
+  <!-- Hello World Parser -->
+
+
+  <h1><a name="2">2 Hello World Example</a></h1>
+
+  <p>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 <code>hello</code>
+     example which can be found in the <code>cxx/parser/</code> directory in
+     the <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <h2><a name="2.1">2.1 Writing XML Document and Schema</a></h2>
+
+  <p>First, we need to get an idea about the structure
+     of the XML documents we are going to process. Our
+     <code>hello.xml</code>, for example, could look like this:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello>
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>Then we can write a description of the above XML in the
+     XML Schema language and save it into <code>hello.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello">
+    &lt;xs:sequence>
+      &lt;xs:element name="greeting" type="xs:string"/>
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Even if you are not familiar with XML Schema, it
+     should be easy to connect declarations in <code>hello.xsd</code>
+     to elements in <code>hello.xml</code>. The <code>hello</code> type
+     is defined as a sequence of the nested <code>greeting</code> and
+     <code>name</code> 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 <code>name</code>
+     element has its <code>maxOccurs</code> property set to
+     <code>unbounded</code> which means it can appear multiple times
+     in an XML document. Finally, the globally-defined <code>hello</code>
+     element prescribes the root element for our vocabulary. For an
+     easily-approachable introduction to XML Schema refer to
+     <a href="http://www.w3.org/TR/xmlschema-0/">XML Schema Part 0:
+     Primer</a>.</p>
+
+  <p>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.</p>
+
+  <h2><a name="2.2">2.2 Translating Schema to C++</a></h2>
+
+  <p>Now we are ready to translate our <code>hello.xsd</code> to C++ parser
+     skeletons. To do this we invoke the XSD compiler from a terminal
+     (UNIX) or a command prompt (Windows):
+  </p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --xml-parser expat hello.xsd
+  </pre>
+
+  <p>The <code>--xml-parser</code> option indicates that we want to
+     use Expat as the underlying XML parser (see <a href="#5.3">Section
+     5.3, "Underlying XML Parser"</a>). The XSD compiler produces two
+     C++ files: <code>hello-pskel.hxx</code> and <code>hello-pskel.cxx</code>.
+     The following code fragment is taken from <code>hello-pskel.hxx</code>;
+     it should give you an idea about what gets generated:
+  </p>
+
+  <pre class="c++">
+class hello_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  greeting (const std::string&amp;);
+
+  virtual void
+  name (const std::string&amp;);
+
+  virtual void
+  post_hello ();
+
+  // Parser construction API.
+  //
+  void
+  greeting_parser (xml_schema::string_pskel&amp;);
+
+  void
+  name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  parsers (xml_schema::string_pskel&amp; /* greeting */,
+           xml_schema::string_pskel&amp; /* name */);
+
+private:
+  ...
+};
+  </pre>
+
+  <p>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.</p>
+
+  <p>The <code>pre()</code> function is an initialization callback. It is
+    called when a new element of type <code>hello</code> 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.</p>
+
+  <p>The <code>post_hello()</code> function is a finalization callback. Its
+     name is constructed by adding the parser skeleton name to the
+     <code>post_</code> 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
+     <code>post_hello()</code> is <code>void</code> which means there
+     is nothing to return. More on parser return types later.
+  </p>
+
+  <p>You may be wondering why the finalization callback is called
+     <code>post_hello()</code> instead of <code>post()</code> just
+     like <code>pre()</code>. 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.</p>
+
+  <p>The <code>greeting()</code> and <code>name()</code> functions are
+     called when the <code>greeting</code> and <code>name</code> elements
+     have been parsed, respectively. Their arguments are of type
+     <code>std::string</code> and contain the data extracted from XML.</p>
+
+  <p>The last three functions are for connecting parsers to each other.
+     For example, there is a predefined parser for built-in XML Schema type
+     <code>string</code> in the XSD runtime. We will be using
+     it to parse the contents of <code>greeting</code> and
+     <code>name</code> elements, as shown in the next section.</p>
+
+  <h2><a name="2.3">2.3 Implementing Application Logic</a></h2>
+
+  <p>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:
+  </p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello-pskel.hxx"
+
+class hello_pimpl: public hello_pskel
+{
+public:
+  virtual void
+  greeting (const std::string&amp; g)
+  {
+    greeting_ = g;
+  }
+
+  virtual void
+  name (const std::string&amp; n)
+  {
+    std::cout &lt;&lt; greeting_ &lt;&lt; ", " &lt;&lt; n &lt;&lt; "!" &lt;&lt; std::endl;
+  }
+
+private:
+  std::string greeting_;
+};
+  </pre>
+
+  <p>We left both <code>pre()</code> and <code>post_hello()</code> 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.</p>
+
+  <p>An observant reader my ask what happens if the <code>name</code>
+     element comes before <code>greeting</code>? Don't we need to
+     make sure <code>greeting_</code> was initialized and report
+     an error otherwise? The answer is no, we don't have to do
+     any of this. The <code>hello_pskel</code> 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 <code>greeting</code> and <code>name</code> elements
+     and report an error if it is violated.</p>
+
+  <p>Now it is time to put this parser implementation to work:</p>
+
+  <pre class="c++">
+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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>The first part of this code snippet instantiates individual parsers
+     and assembles them into a complete vocabulary parser.
+     <code>xml_schema::string_pimpl</code> is an implementation of a parser
+     for built-in XML Schema type <code>string</code>. It is provided by
+     the XSD runtime along with parsers for other built-in types (for
+     more information on the built-in parsers see <a href="#6">Chapter 6,
+     "Built-In XML Schema Type Parsers"</a>). We use <code>string_pimpl</code>
+     to parse the <code>greeting</code> and <code>name</code> elements as
+     indicated by the calls to <code>greeting_parser()</code> and
+     <code>name_parser()</code>.
+  </p>
+
+  <p>Then we instantiate a document parser (<code>doc_p</code>). The
+     first argument to its constructor is the parser for
+     the root element (<code>hello_p</code> in our case). The
+     second argument is the root element name.
+   </p>
+
+  <p>The final piece is the calls to <code>pre()</code>, <code>parse()</code>,
+     and <code>post_hello()</code>. The call to <code>parse()</code>
+     perform the actual XML parsing while the calls to <code>pre()</code> and
+     <code>post_hello()</code> make sure that the parser for the root
+     element can perform proper initialization and cleanup.</p>
+
+  <p>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 <code>--generate-noop-impl</code>
+     option. Or you can generate a sample implementation that prints the
+     data store in XML by using the <code>--generate-print-impl</code>
+     option. To request the generation of a test driver you can use the
+     <code>--generate-test-driver</code> option. For more information
+     on these options refer to the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>. The <code>'generated'</code> example
+     in the <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+     shows the sample implementation generation feature in action.</p>
+
+
+  <h2><a name="2.4">2.4 Compiling and Running</a></h2>
+
+  <p>After saving all the parts from the previous section in
+     <code>driver.cxx</code>, 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:
+  </p>
+
+  <pre class="terminal">
+$ 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!
+  </pre>
+
+  <p>Here <code>.../libxsd</code> represents the path to the
+     <a href="https://cppget.org/libxsd">libxsd</a> package root
+     directory. We can also test the error handling. To test XML
+     well-formedness checking, we can try to parse
+     <code>hello-pskel.hxx</code>:</p>
+
+  <pre class="terminal">
+$ ./driver hello-pskel.hxx
+hello-pskel.hxx:1:0: not well-formed (invalid token)
+  </pre>
+
+  <p>We can also try to parse a valid XML but not from our
+     vocabulary, for example <code>hello.xsd</code>:</p>
+
+  <pre class="terminal">
+$ ./driver hello.xsd
+hello.xsd:2:0: expected element 'hello' instead of
+'http://www.w3.org/2001/XMLSchema#schema'
+  </pre>
+
+
+  <!-- Chapater 3 -->
+
+
+  <h1><a name="3">3 Parser Skeletons</a></h1>
+
+  <p>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.</p>
+
+  <p>In this and subsequent chapters we will use the following schema
+     that describes a collection of person records. We save it in
+     <code>people.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:simpleType name="gender">
+    &lt;xs:restriction base="xs:string">
+      &lt;xs:enumeration value="male"/>
+      &lt;xs:enumeration value="female"/>
+    &lt;/xs:restriction>
+  &lt;/xs:simpleType>
+
+  &lt;xs:complexType name="person">
+    &lt;xs:sequence>
+      &lt;xs:element name="first-name" type="xs:string"/>
+      &lt;xs:element name="last-name" type="xs:string"/>
+      &lt;xs:element name="gender" type="gender"/>
+      &lt;xs:element name="age" type="xs:short"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:complexType name="people">
+    &lt;xs:sequence>
+      &lt;xs:element name="person" type="person" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="people" type="people"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>A sample XML instance to go along with this schema is saved
+     in <code>people.xml</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people>
+  &lt;person>
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+  &lt;person>
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+&lt;/people>
+  </pre>
+
+  <p>Compiling <code>people.xsd</code> with the XSD compiler results
+     in three parser skeletons being generated: <code>gender_pskel</code>,
+     <code>person_pskel</code>, and <code>people_pskel</code>. We are going
+     to examine and implement each of them in the subsequent sections.</p>
+
+  <h2><a name="3.1">3.1 Implementing the Gender Parser</a></h2>
+
+  <p>The generated <code>gender_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post_gender ();
+};
+  </pre>
+
+  <p>Notice that <code>gender_pskel</code> inherits from
+     <code>xml_schema::string_skel</code> which is a parser skeleton
+     for built-in XML Schema type <code>string</code> 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.</p>
+
+  <p>The <code>pre()</code> and <code>post_gender()</code> callbacks
+     should look familiar from the previous chapter. Let's now
+     implement the parser. Our implementation will simply print
+     the gender to <code>cout</code>:</p>
+
+
+  <pre class="c++">
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual void
+  post_gender ()
+  {
+    std::string s = post_string ();
+    cout &lt;&lt; "gender: " &lt;&lt; s &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>While the code is quite short, there is a lot going on. First,
+     notice that we are inheriting from <code>gender_pskel</code> <em>and</em>
+     from <code>xml_schema::string_pimpl</code>. We've encountered
+     <code>xml_schema::string_pimpl</code> already; it is an
+     implementation of the <code>xml_schema::string_pskel</code> parser
+     skeleton for built-in XML Schema type <code>string</code>.</p>
+
+  <p>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, <code>string_pimpl</code> will
+     do all the dirty work of extracting the data and we can just get
+     it at the end with the call to <code>post_string()</code>.</p>
+
+  <p>In case you are curious, here is what
+     <code>xml_schema::string_pskel</code> and
+     <code>xml_schema::string_pimpl</code> look like:</p>
+
+  <pre class="c++">
+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&amp;);
+
+    virtual std::string
+    post_string ();
+
+  protected:
+    std::string str_;
+  };
+}
+  </pre>
+
+  <p>There are three new pieces in this code that we haven't seen yet.
+     They are the <code>simple_content</code> class as well as
+     the <code>_pre()</code> and <code>_characters()</code> functions.
+     The <code>simple_content</code> 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&mdash;only text
+     and attributes. There is also the <code>complex_content</code>
+     class which corresponds to the complex content mode (types with
+     nested elements, for example, <code>person</code> from
+     <code>people.xsd</code>).</p>
+
+  <p>The <code>_pre()</code> function is a parser callback. Remember we
+     talked about the <code>pre()</code> and <code>post_*()</code> callbacks
+     in the previous chapter? There are actually two more callbacks
+     with similar roles: <code>_pre()</code> and <code>_post ()</code>.
+     As a result, each parser skeleton has four special callbacks:</p>
+
+  <pre class="c++">
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post_name ();
+  </pre>
+
+  <p><code>pre()</code> and <code>_pre()</code> are initialization
+     callbacks. They get called in that order before a new instance of the type
+     is about to be parsed. The difference between <code>pre()</code> and
+     <code>_pre()</code> is conventional: <code>pre()</code> can
+     be completely overridden by a derived parser. The derived
+     parser can also override <code>_pre()</code> but has to always call
+     the original version. This allows you to partition initialization
+     into customizable and required parts.</p>
+
+  <p>Similarly, <code>_post()</code> and <code>post_name()</code> are
+     finalization callbacks with exactly the same semantics:
+    <code>post_name()</code> can be completely overridden by the derived
+     parser while the original <code>_post()</code> should always be called.
+  </p>
+
+  <p>The final bit we need to discuss in this section is the
+     <code>_characters()</code> 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.</p>
+
+  <p>At this point you might be wondering why some <code>post_*()</code>
+     callbacks, for example <code>post_string()</code>, return some data
+     while others, for example <code>post_gender()</code>, have
+     <code>void</code> as a return type. This is a valid concern
+     and it will be addressed in the next chapter.</p>
+
+  <h2><a name="3.2">3.2 Implementing the Person Parser</a></h2>
+
+  <p>The generated <code>person_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+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&amp;);
+
+  virtual void
+  last_name (const std::string&amp;);
+
+  virtual void
+  gender ();
+
+  virtual void
+  age (short);
+
+  virtual void
+  post_person ();
+
+  // Parser construction API.
+  //
+  void
+  first_name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  last_name_parser (xml_schema::string_pskel&amp;);
+
+  void
+  gender_parser (gender_pskel&amp;);
+
+  void
+  age_parser (xml_schema::short_pskel&amp;);
+
+  void
+  parsers (xml_schema::string_pskel&amp; /* first-name */,
+           xml_schema::string_pskel&amp; /* last-name */,
+           gender_pskel&amp;             /* gender */,
+           xml_schema::short_pskel&amp;  /* age */);
+};
+  </pre>
+
+
+  <p>As you can see, we have a parser callback for each of the nested
+     elements found in the <code>person</code> XML Schema type.
+     The implementation of this parser is straightforward:</p>
+
+  <pre class="c++">
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string&amp; n)
+  {
+    cout &lt;&lt; "first: " &lt;&lt; f &lt;&lt; endl;
+  }
+
+  virtual void
+  last_name (const std::string&amp; l)
+  {
+    cout &lt;&lt; "last: " &lt;&lt; l &lt;&lt; endl;
+  }
+
+  virtual void
+  age (short a)
+  {
+    cout &lt;&lt; "age: " &lt;&lt; a &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Notice that we didn't override the <code>gender()</code> callback
+     because all the printing is done by <code>gender_pimpl</code>.</p>
+
+
+  <h2><a name="3.3">3.3 Implementing the People Parser</a></h2>
+
+  <p>The generated <code>people_pskel</code> parser skeleton looks like
+     this:</p>
+
+  <pre class="c++">
+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&amp;);
+
+  void
+  parsers (person_pskel&amp; /* person */);
+};
+  </pre>
+
+  <p>The <code>person()</code> callback will be called after parsing each
+     <code>person</code> element. While <code>person_pimpl</code> 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:</p>
+
+  <pre class="c++">
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    cout &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Now it is time to put everything together.</p>
+
+
+  <h2><a name="3.4">3.4 Connecting the Parsers Together</a></h2>
+
+  <p>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:</p>
+
+  <pre class="c++">
+xml_schema::short_pimpl short_p;
+xml_schema::string_pimpl string_p;
+
+gender_pimpl gender_p;
+person_pimpl person_p;
+people_pimpl people_p;
+  </pre>
+
+  <p>Notice that our schema uses two built-in XML Schema types:
+     <code>string</code> for the <code>first-name</code> and
+     <code>last-name</code> elements as well as <code>short</code>
+     for <code>age</code>. 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 <code>*_parser()</code> functions:</p>
+
+  <pre class="c++">
+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);
+  </pre>
+
+  <p>You might be wondering what happens if you do not provide
+     a parser by not calling one of the <code>*_parser()</code> 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.</p>
+
+
+  <p>An alternative, shorter, way to connect the parsers is by using
+     the <code>parsers()</code> functions which connects all the parsers
+     for a given type at once:</p>
+
+  <pre class="c++">
+person_p.parsers (string_p, string_p, gender_p, short_p);
+people_p.parsers (person_p);
+  </pre>
+
+  <p>The following figure illustrates the resulting connections. Notice
+     the correspondence between return types of the <code>post_*()</code>
+     functions and argument types of element callbacks that are connected
+     by the arrows.</p>
+
+  <!-- align=center is needed for html2ps -->
+  <div class="img" align="center"><img src="figure-1.png"/></div>
+
+  <p>The last step is the construction of the document parser and
+     invocation of the complete parser on our sample XML instance:</p>
+
+  <pre class="c++">
+xml_schema::document doc_p (people_p, "people");
+
+people_p.pre ();
+doc_p.parse ("people.xml");
+people_p.post_people ();
+  </pre>
+
+  <p>Let's consider <code>xml_schema::document</code> in
+     more detail. While the exact definition of this class
+     varies depending on the underlying parser selected,
+     here is the common part:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class document
+  {
+  public:
+    document (xml_schema::parser_base&amp;,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    document (xml_schema::parser_base&amp;,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    void
+    parse (const std::string&amp; file);
+
+    void
+    parse (std::istream&amp;);
+
+    ...
+
+  };
+}
+  </pre>
+
+   <p><code>xml_schema::document</code> is a root parser for
+     the vocabulary. The first argument to its constructors is the
+     parser for the type of the root element (<code>people_impl</code>
+     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
+     <code>document</code>'s constructors.</p>
+
+   <p>There are also two overloaded <code>parse()</code> functions
+      defined in the <code>document</code> 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 <code>xml_schema::document</code> class
+      refer to <a href="#7">Chapter 7, "Document Parser and Error
+      Handling"</a>.</p>
+
+   <p>Let's now consider a step-by-step list of actions that happen
+      as we parse through <code>people.xml</code>. The content of
+      <code>people.xml</code> is repeated below for convenience.</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people>
+  &lt;person>
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+  &lt;person>
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+&lt;/people>
+  </pre>
+
+
+   <ol class="steps">
+     <li><code>people_p.pre()</code> is called from
+         <code>main()</code>. We did not provide any implementation
+         for this callback so this call is a no-op.</li>
+
+     <li><code>doc_p.parse("people.xml")</code> is called from
+         <code>main()</code>. The parser opens the file and starts
+         parsing its content.</li>
+
+     <li>The parser encounters the root element. <code>doc_p</code>
+         verifies that the root element is correct and calls
+         <code>_pre()</code> on <code>people_p</code> which is also
+         a no-op. Parsing is now delegated to <code>people_p</code>.</li>
+
+     <li>The parser encounters the <code>person</code> element.
+         <code>people_p</code> determines that <code>person_p</code>
+         is responsible for parsing this element. <code>pre()</code>
+         and <code>_pre()</code> callbacks are called on <code>person_p</code>.
+         Parsing is now delegated to <code>person_p</code>.</li>
+
+     <li>The parser encounters the <code>first-name</code> element.
+         <code>person_p</code> determines that <code>string_p</code>
+         is responsible for parsing this element. <code>pre()</code>
+         and <code>_pre()</code> callbacks are called on <code>string_p</code>.
+         Parsing is now delegated to <code>string_p</code>.</li>
+
+     <li>The parser encounters character content consisting of
+         <code>"John"</code>. The <code>_characters()</code> callback is
+         called on <code>string_p</code>.</li>
+
+     <li>The parser encounters the end of <code>first-name</code>
+         element. The <code>_post()</code> and <code>post_string()</code>
+         callbacks are called on <code>string_p</code>. The
+         <code>first_name()</code> callback is called on <code>person_p</code>
+         with the return value of <code>post_string()</code>. The
+         <code>first_name()</code> implementation prints
+         <code>"first: John"</code> to <code>cout</code>.
+         Parsing is now returned to <code>person_p</code>.</li>
+
+     <li>Steps analogous to 5-7 are performed for the <code>last-name</code>,
+         <code>gender</code>, and <code>age</code> elements.</li>
+
+     <li>The parser encounters the end of <code>person</code>
+         element. The <code>_post()</code> and <code>post_person()</code>
+         callbacks are called on <code>person_p</code>. The
+         <code>person()</code> callback is called on <code>people_p</code>.
+         The <code>person()</code> implementation prints a new line
+         to <code>cout</code>. Parsing is now returned to
+         <code>people_p</code>.</li>
+
+     <li>Steps 4-9 are performed for the second <code>person</code>
+         element.</li>
+
+     <li>The parser encounters the end of <code>people</code>
+         element. The <code>_post()</code> callback is called on
+         <code>people_p</code>. The <code>doc_p.parse("people.xml")</code>
+         call returns to <code>main()</code>.</li>
+
+     <li><code>people_p.post_people()</code> is called from
+         <code>main()</code> which is a no-op.</li>
+
+   </ol>
+
+
+  <!-- Chpater 4 -->
+
+
+  <h1><a name="4">4 Type Maps</a></h1>
+
+  <p>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 <em>parent</em> parser
+     which can then incorporate this sub-tree into the whole tree.</p>
+
+  <p>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.</p>
+
+  <h2><a name="4.1">4.1 Object Model</a></h2>
+
+  <p>An object model for our person record example could
+     look like this (saved in the <code>people.hxx</code> file):</p>
+
+  <pre class="c++">
+#include &lt;string>
+#include &lt;vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string&amp; first,
+          const std::string&amp; last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&amp;
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&amp;
+  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&lt;person> people;
+  </pre>
+
+  <p>While it is clear which parser is responsible for which part of
+     the object model, it is not exactly clear how, for
+     example, <code>gender_pimpl</code> will deliver <code>gender</code>
+     to <code>person_pimpl</code>. You might have noticed that
+     <code>string_pimpl</code> manages to deliver its value to the
+     <code>first_name()</code> callback of <code>person_pimpl</code>. Let's
+     see how we can utilize the same mechanism to propagate our
+     own data.</p>
+
+  <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 <code>post_*()</code> 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
+     <code>gender</code> we can specify the return type for
+     <code>post_gender()</code> in the <code>gender_pskel</code>
+     skeleton and the argument type for the <code>gender()</code> callback
+     in the <code>person_pskel</code> skeleton. As you might have guessed,
+     the generated code will then pass the return value from the
+     <code>post_*()</code> callback as an argument to the element or
+     attribute callback.</p>
+
+  <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 <code>gender</code> type from the previous paragraph:</p>
+
+  <pre class="type-map">
+include "people.hxx";
+gender ::gender ::gender;
+  </pre>
+
+  <p>The first line indicates that the generated code must include
+     <code>people.hxx</code> in order to get the definition for the
+     <code>gender</code> type. The second line specifies that both
+     argument and return types for the <code>gender</code>
+     XML Schema type should be the <code>::gender</code> 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 <code>people.map</code> and
+     then translate our schemas with the <code>--type-map</code>
+     option to let the XSD compiler know about our type map:</p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --type-map people.map people.xsd
+  </pre>
+
+  <p>If we now look at the generated <code>people-pskel.hxx</code>,
+     we will see the following changes in the <code>gender_pskel</code> and
+     <code>person_pskel</code> skeletons:</p>
+
+  <pre class="c++">
+#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);
+
+  ...
+};
+  </pre>
+
+  <p>Notice that <code>#include "people.hxx"</code> was added to
+     the generated header file from the type map to provide the
+     definition for the <code>gender</code> enum.</p>
+
+  <h2><a name="4.2">4.2 Type Map File Format</a></h2>
+
+  <p>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 <code>post_*()</code>
+     callbacks in parser skeletons corresponding to XML Schema
+     types as well as argument types for callbacks corresponding
+     to elements and attributes of these types.</p>
+
+  <p>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 <code>void</code>.
+     By providing your own type maps you can override these predefined
+     rules. The format of the type map file is presented below:
+  </p>
+
+  <pre class="type-map">
+namespace &lt;schema-namespace> [&lt;cxx-namespace>]
+{
+  (include &lt;file-name>;)*
+  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
+}
+  </pre>
+
+  <p>Both <code><i>&lt;schema-namespace></i></code> and
+     <code><i>&lt;schema-type></i></code> are regex patterns while
+     <code><i>&lt;cxx-namespace></i></code>,
+     <code><i>&lt;cxx-ret-type></i></code>, and
+     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
+     substitutions. All names can be optionally enclosed in
+     <code>" "</code>, for example, to include white-spaces.</p>
+
+  <p><code><i>&lt;schema-namespace></i></code> determines XML
+     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
+     is prefixed to every C++ type name in this namespace declaration.
+     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
+     used as a return type for the <code>post_*()</code> callback.
+     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
+     type for callbacks corresponding to elements and attributes
+     of this type. If <code><i>&lt;cxx-arg-type></i></code> is not
+     specified, it defaults to <code><i>&lt;cxx-ret-type></i></code>
+     if <code><i>&lt;cxx-ret-type></i></code> ends with <code>*</code> or
+     <code>&amp;</code> (that is, it is a pointer or a reference) and
+     <code>const&nbsp;<i>&lt;cxx-ret-type></i>&amp;</code>
+     otherwise.
+     <code><i>&lt;file-name></i></code> is a file name either in the
+     <code>" "</code> or <code>&lt; ></code> format
+     and is added with the <code>#include</code> directive to
+     the generated code.</p>
+
+  <p>The <code><b>#</b></code> character starts a comment that ends
+     with a new line or end of file. To specify a name that contains
+     <code><b>#</b></code> enclose it in <code><b>" "</b></code>.
+     For example:</p>
+
+  <pre>
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  </pre>
+
+  <p>In the example above, for the
+     <code>http://www.example.com/xmlns/my#orange</code>
+     XML Schema type, the <code>my::orange_t*</code> C++ type will
+     be used as both return and argument types.</p>
+
+  <p>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:</p>
+
+  <pre class="type-map">
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  </pre>
+
+  <p>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 <code>std::string</code> or
+     <code>std::wstring</code> depending on the character type
+     selected (see <a href="#5.2"> Section 5.2, "Character Type and
+     Encoding"</a> for more information). The binary XML Schema
+     types are mapped to either <code>std::unique_ptr&lt;xml_schema::buffer></code>
+     or <code>std::auto_ptr&lt;xml_schema::buffer></code>
+     depending on the C++ standard selected (C++11 or C++98,
+     respectively; refer to the <code>--std</code> XSD compiler
+     command line option for details).</p>
+
+  <pre class="type-map">
+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&lt;xml_schema::buffer>
+               std::[unique|auto]_ptr&lt;xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr&lt;xml_schema::buffer>
+            std::[unique|auto]_ptr&lt;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;
+}
+  </pre>
+
+  <p>For more information about the mapping of the built-in XML Schema types
+     to C++ types refer to <a href="#6">Chapter 6, "Built-In XML Schema Type
+     Parsers"</a>. The last predefined rule maps anything that wasn't
+     mapped by previous rules to <code>void</code>:</p>
+
+  <pre class="type-map">
+namespace .*
+{
+  .* void void;
+}
+  </pre>
+
+
+  <p>When you provide your own type maps with the
+     <code>--type-map</code> 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 <code>xml_schema</code> namespace. You can include the
+     custom definitions into the generated header file using the
+     <code>--hxx-prologue-*</code> options.</p>
+
+  <h2><a name="4.3">4.3 Parser Implementations</a></h2>
+
+  <p>With the knowledge from the previous section, we can proceed
+     with creating a type map that maps types in the <code>people.xsd</code>
+     schema to our object model classes in
+     <code>people.hxx</code>. In fact, we already have the beginning
+     of our type map file in <code>people.map</code>. Let's extend
+     it with the rest of the types:</p>
+
+  <pre class="type-map">
+include "people.hxx";
+
+gender ::gender ::gender;
+person ::person;
+people ::people;
+  </pre>
+
+  <p>There are a few things to note about this type map. We did not
+     provide the argument types for <code>person</code> and
+     <code>people</code> because the default constant reference is
+     exactly what we need. We also did not provide any mappings
+     for built-in XML Schema types <code>string</code> and
+     <code>short</code> 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:</p>
+
+  <pre class="terminal">
+$ xsd cxx-parser --xml-parser expat --type-map people.map people.xsd
+  </pre>
+
+  <p>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.</p>
+
+
+  <pre class="c++">
+#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&amp; f)
+  {
+    first_ = f;
+  }
+
+  virtual void
+  last_name (const std::string&amp; 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&amp; p)
+  {
+    people_.push_back (p);
+  }
+
+  virtual ::people
+  post_people ()
+  {
+    ::people r;
+    r.swap (people_);
+    return r;
+  }
+
+private:
+  ::people people_;
+};
+  </pre>
+
+  <p>This code fragment should look familiar by now. Just note that
+     all the <code>post_*()</code> callbacks now have return types instead
+     of <code>void</code>. Here is the implementation of the test
+     driver for this example:</p>
+
+  <pre class="c++">
+#include &lt;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 &lt;&lt; "first:  " &lt;&lt; i->first () &lt;&lt; endl
+         &lt;&lt; "last:   " &lt;&lt; i->last () &lt;&lt; endl
+         &lt;&lt; "gender: " &lt;&lt; (i->gender () == male ? "male" : "female") &lt;&lt; endl
+         &lt;&lt; "age:    " &lt;&lt; i->age () &lt;&lt; endl
+         &lt;&lt; endl;
+  }
+}
+  </pre>
+
+  <p>The parser creation and assembly part is exactly the same as in
+     the previous chapter. The parsing part is a bit different:
+     <code>post_people()</code> now has a return value which is the
+     complete object model. We store it in the
+     <code>ppl</code> variable. The last bit of the code simply iterates
+     over the <code>people</code> vector and prints the information
+     for each person. We save the last two code fragments to
+     <code>driver.cxx</code> and proceed to compile and test
+     our new application:</p>
+
+
+  <pre class="terminal">
+$ 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
+  </pre>
+
+
+  <!-- Mapping Configuration -->
+
+
+  <h1><a name="5">5 Mapping Configuration</a></h1>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.
+  </p>
+
+  <h2><a name="5.1">5.1 C++ Standard</a></h2>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h2><a name="5.2">5.2 Character Type and Encoding</a></h2>
+
+  <p>The C++/Parser mapping has built-in support for two character types:
+    <code>char</code> and <code>wchar_t</code>. You can select the
+    character type with the <code>--char-type</code> command line
+    option. The default character type is <code>char</code>. The
+    string-based built-in XML Schema types are returned as either
+    <code>std::string</code> or <code>std::wstring</code> depending
+    on the character type selected.</p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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 <code>--char-encoding</code> command
+     line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <p>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.</p>
+
+  <h2><a name="5.3">5.3 Underlying XML Parser</a></h2>
+
+  <p>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 <code>--xml-parser</code> command line option. Valid values
+     for this option are <code>xerces</code> and <code>expat</code>.
+     The default XML parser is Xerces-C++.</p>
+
+  <p>The generated code is identical for both parsers except for the
+     <code>xml_schema::document</code> class in which some of the
+     <code>parse()</code> functions are parser-specific as described
+     in <a href="#7">Chapter 7, "Document Parser and Error Handling"</a>.</p>
+
+
+  <h2><a name="5.4">5.4 XML Schema Validation</a></h2>
+
+  <p>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
+     <a href="#A">Appendix A, "Supported XML Schema Constructs"</a>.</p>
+
+  <p>By default validation in the generated code is disabled if
+     the underlying XML parser is validating (Xerces-C++) and
+     enabled otherwise (Expat). See <a href="#5.3">Section 5.3,
+     "Underlying XML Parser"</a> for more information about
+     the underlying XML parser. You can override the default
+     behavior with the <code>--generate-validation</code>
+     and <code>--suppress-validation</code> command line options.</p>
+
+
+  <h2><a name="5.5">5.5 Support for Polymorphism</a></h2>
+
+  <p>By default the XSD compiler generates non-polymorphic code. If your
+     vocabulary uses XML Schema polymorphism in the form of <code>xsi:type</code>
+     and/or substitution groups, then you will need to compile your schemas
+     with the <code>--generate-polymorphic</code> option to produce
+     polymorphism-aware code as well as pass <code>true</code> as the last
+     argument to the <code>xml_schema::document</code>'s constructors.</p>
+
+  <p>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 <code>xsi:type</code> attribute value or an element
+     name from a substitution group. Consider the following schema as an
+     example:</p>
+
+  <pre class="xml">
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="person">
+    &lt;xs:sequence>
+      &lt;xs:element name="name" type="xs:string"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;!-- substitution group root -->
+  &lt;xs:element name="person" type="person"/>
+
+  &lt;xs:complexType name="superman">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="person">
+        &lt;xs:attribute name="can-fly" type="xs:boolean"/>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  &lt;xs:complexType name="batman">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="superman">
+        &lt;xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  &lt;xs:complexType name="supermen">
+    &lt;xs:sequence>
+      &lt;xs:element ref="person" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="supermen" type="supermen"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Conforming XML documents can use the <code>superman</code>
+     and <code>batman</code> types in place of the <code>person</code>
+     type either by specifying the type with the <code>xsi:type</code>
+     attributes or by using the elements from the substitution
+     group, for instance:</p>
+
+
+  <pre class="xml">
+&lt;supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  &lt;person>
+    &lt;name>John Doe&lt;/name>
+  &lt;/person>
+
+  &lt;superman can-fly="false">
+    &lt;name>James "007" Bond&lt;/name>
+  &lt;/superman>
+
+  &lt;superman can-fly="true" wing-span="10" xsi:type="batman">
+    &lt;name>Bruce Wayne&lt;/name>
+  &lt;/superman>
+
+&lt;/supermen>
+  </pre>
+
+  <p>To print the data stored in such XML documents we can implement
+     the parsers as follows:</p>
+
+  <pre class="c++">
+class person_pimpl: public virtual person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse person" &lt;&lt; endl;
+  }
+
+  virtual void
+  name (const std::string&amp; v)
+  {
+    cout &lt;&lt; "name: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    cout &lt;&lt; "finished parsing person" &lt;&lt; endl;
+  }
+};
+
+class superman_pimpl: public virtual superman_pskel,
+                      public person_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse superman" &lt;&lt; endl;
+  }
+
+  virtual void
+  can_fly (bool v)
+  {
+    cout &lt;&lt; "can-fly: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    cout &lt;&lt; "finished parsing superman" &lt;&lt; endl
+  }
+};
+
+class batman_pimpl: public virtual batman_pskel,
+                    public superman_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout &lt;&lt; "starting to parse batman" &lt;&lt; endl;
+  }
+
+  virtual void
+  wing_span (unsigned int v)
+  {
+    cout &lt;&lt; "wing-span: " &lt;&lt; v &lt;&lt; endl;
+  }
+
+  virtual void
+  post_superman ()
+  {
+    post_batman ();
+  }
+
+  virtual void
+  post_batman ()
+  {
+    cout &lt;&lt; "finished parsing batman" &lt;&lt; endl;
+  }
+};
+  </pre>
+
+  <p>Note that because the derived type parsers (<code>superman_pskel</code>
+     and <code>batman_pskel</code>) are called via the <code>person_pskel</code>
+     interface, we have to override the <code>post_person()</code>
+     virtual function in <code>superman_pimpl</code> to call
+     <code>post_superman()</code> and the <code>post_superman()</code>
+     virtual function in <code>batman_pimpl</code> to call
+     <code>post_batman()</code>.</p>
+
+  <p>The following code fragment shows how to connect the parsers together.
+     Notice that for the <code>person</code> element in the <code>supermen_p</code>
+     parser we specify a parser map instead of a specific parser and we pass
+     <code>true</code> as the last argument to the document parser constructor
+     to indicate that we are parsing potentially-polymorphic XML documents:</p>
+
+  <pre class="c++">
+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 ();
+}
+  </pre>
+
+  <p>When polymorphism-aware code is generated, each element's
+     <code>*_parser()</code> function is overloaded to also accept
+     an object of the <code>xml_schema::parser_map</code> type.
+     For example, the <code>supermen_pskel</code> class from the
+     above example looks like this:</p>
+
+  <pre class="c++">
+class supermen_pskel: public xml_schema::parser_complex_content
+{
+public:
+
+  ...
+
+  // Parser construction API.
+  //
+  void
+  parsers (person_pskel&amp;);
+
+  // Individual element parsers.
+  //
+  void
+  person_parser (person_pskel&amp;);
+
+  void
+  person_parser (const xml_schema::parser_map&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>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
+     <code>xsi:type</code> 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:</p>
+
+  <pre class="c++">
+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);
+
+  ...
+}
+  </pre>
+
+
+  <p>The <code>xml_schema::parser_map</code> interface and the
+     <code>xml_schema::parser_map_impl</code> default implementation
+     are presented below:</p>
+
+  <pre class="c++">
+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&amp;);
+
+    virtual parser_base*
+    find (const ro_string* type) const;
+
+  private:
+    parser_map_impl (const parser_map_impl&amp;);
+
+    parser_map_impl&amp;
+    operator= (const parser_map_impl&amp;);
+
+    ...
+  };
+}
+  </pre>
+
+  <p>The <code>type</code> argument in the <code>find()</code> 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
+     <code>"&lt;name>&nbsp;&lt;namespace>"</code> 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 <code>_dynamic_type()</code> function. The static
+     type can be obtained by calling the static <code>_static_type()</code>
+     function, for example <code>person_pskel::_static_type()</code>.
+     Both functions return a C string (<code>const char*</code> or
+     <code>const wchar_t*</code>, 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 <code>std::map</code>:</p>
+
+
+  <pre class="c++">
+#include &lt;map>
+#include &lt;string>
+
+class parser_map: public xml_schema::parser_map
+{
+public:
+ void
+ insert (xml_schema::parser_base&amp; p)
+ {
+   map_[p._dynamic_type ()] = &amp;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&lt;std::string, xml_schema::parser_base*> map;
+  map map_;
+};
+  </pre>
+
+  <p>Most of code presented in this section is taken from the
+     <code>polymorphism</code> example which can be found in the
+     <code>cxx/parser/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> package.
+     Handling of <code>xsi:type</code> and substitution groups when used on
+     root elements requires a number of special actions as shown in
+     the <code>polyroot</code> example.</p>
+
+
+  <!-- Built-in XML Schema Type Parsers -->
+
+
+  <h1><a name="6">6 Built-In XML Schema Type Parsers</a></h1>
+
+  <p>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 <code>std::string</code> or
+     <code>std::wstring</code> depending on the character type selected.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Parser implementation in the <code>xml_schema</code> namespace</th>
+      <th>Parser return type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">anyType and anySimpleType types</th>
+    </tr>
+    <tr>
+      <td><code>anyType</code></td>
+      <td><code>any_type_pimpl</code></td>
+      <td><code>void</code></td>
+    </tr>
+    <tr>
+      <td><code>anySimpleType</code></td>
+      <td><code>any_simple_type_pimpl</code></td>
+      <td><code>void</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte_pimpl</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte_pimpl</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_pimpl</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short_pimpl</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_pimpl</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int_pimpl</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long_pimpl</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer_pimpl</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer_pimpl</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer_pimpl</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean_pimpl</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_pimpl</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_pimpl</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal_pimpl</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string-based types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname_pimpl</code></td>
+      <td><code>xml_schema::qname</code><br/><a href="#6.1">Section 6.1,
+          "<code>QName</code> Parser"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">list types</th>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens_pimpl</code></td>
+      <td><code>xml_schema::string_sequence</code><br/><a href="#6.2">Section
+          6.2, "<code>NMTOKENS</code> and <code>IDREFS</code> Parsers"</a></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs_pimpl</code></td>
+      <td><code>xml_schema::string_sequence</code><br/><a href="#6.2">Section
+          6.2, "<code>NMTOKENS</code> and <code>IDREFS</code> Parsers"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri_pimpl</code></td>
+      <td><code>std::string</code> or <code>std::wstring</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary_pimpl</code></td>
+      <td><code>std::[unique|auto]_ptr&lt; xml_schema::buffer></code><br/>
+          <a href="#6.3">Section 6.3, "<code>base64Binary</code> and
+          <code>hexBinary</code> Parsers"</a></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary_pimpl</code></td>
+      <td><code>std::[unique|auto]_ptr&lt; xml_schema::buffer></code><br/>
+          <a href="#6.3">Section 6.3, "<code>base64Binary</code> and
+          <code>hexBinary</code> Parsers"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date_pimpl</code></td>
+      <td><code>xml_schema::date</code><br/><a href="#6.5">Section 6.5,
+          "<code>date</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time_pimpl</code></td>
+      <td><code>xml_schema::date_time</code><br/><a href="#6.6">Section 6.6,
+          "<code>dateTime</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration_pimpl</code></td>
+      <td><code>xml_schema::duration</code><br/><a href="#6.7">Section 6.7,
+          "<code>duration</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday_pimpl</code></td>
+      <td><code>xml_schema::gday</code><br/><a href="#6.8">Section 6.8,
+          "<code>gDay</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth_pimpl</code></td>
+      <td><code>xml_schema::gmonth</code><br/><a href="#6.9">Section 6.9,
+          "<code>gMonth</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day_pimpl</code></td>
+      <td><code>xml_schema::gmonth_day</code><br/><a href="#6.10">Section 6.10,
+          "<code>gMonthDay</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear_pimpl</code></td>
+      <td><code>xml_schema::gyear</code><br/><a href="#6.11">Section 6.11,
+          "<code>gYear</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month_pimpl</code></td>
+      <td><code>xml_schema::gyear_month</code><br/><a href="#6.12">Section
+          6.12, "<code>gYearMonth</code> Parser"</a></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time_pimpl</code></td>
+      <td><code>xml_schema::time</code><br/><a href="#6.13">Section 6.13,
+          "<code>time</code> Parser"</a></td>
+    </tr>
+
+  </table>
+
+  <h2><a name="6.1">6.1 <code>QName</code> Parser</a></h2>
+
+  <p>The return type of the <code>qname_pimpl</code> parser implementation
+     is <code>xml_schema::qname</code> which represents an XML qualified
+     name. Its interface is presented below.
+     Note that the <code>std::string</code> type in the interface becomes
+     <code>std::wstring</code> if the selected character type is
+     <code>wchar_t</code>.</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    explicit
+    qname (const std::string&amp; name);
+    qname (const std::string&amp; prefix, const std::string&amp; name);
+
+    const std::string&amp;
+    prefix () const;
+
+    void
+    prefix (const std::string&amp;);
+
+    const std::string&amp;
+    name () const;
+
+    void
+    name (const std::string&amp;);
+  };
+
+  bool
+  operator== (const qname&amp;, const qname&amp;);
+
+  bool
+  operator!= (const qname&amp;, const qname&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.2">6.2 <code>NMTOKENS</code> and <code>IDREFS</code> Parsers</a></h2>
+
+  <p>The return type of the <code>nmtokens_pimpl</code> and
+     <code>idrefs_pimpl</code> parser implementations is
+     <code>xml_schema::string_sequence</code> which represents a
+     sequence of strings. Its interface is presented below.
+     Note that the <code>std::string</code> type in the interface becomes
+     <code>std::wstring</code> if the selected character type is
+     <code>wchar_t</code>.</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class string_sequence: public std::vector&lt;std::string>
+  {
+  public:
+    string_sequence ();
+
+    explicit
+    string_sequence (std::vector&lt;std::string>::size_type n,
+                     const std::string&amp; x = std::string ());
+
+    template &lt;typename I>
+    string_sequence (const I&amp; begin, const I&amp; end);
+  };
+
+  bool
+  operator== (const string_sequence&amp;, const string_sequence&amp;);
+
+  bool
+  operator!= (const string_sequence&amp;, const string_sequence&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.3">6.3 <code>base64Binary</code> and <code>hexBinary</code> Parsers</a></h2>
+
+  <p>The return type of the <code>base64_binary_pimpl</code> and
+     <code>hex_binary_pimpl</code> parser implementations is either
+     <code>std::unique_ptr&lt;xml_schema::buffer></code> (C++11) or
+     <code>std::auto_ptr&lt;xml_schema::buffer></code> (C++98),
+     depending on the C++ standard selected (<code>--std</code> XSD
+     compiler option). The <code>xml_schema::buffer</code> type
+     represents a binary buffer and its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;);
+
+    buffer&amp;
+    operator= (const buffer&amp;);
+
+    void
+    swap (buffer&amp;);
+
+  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&amp;, const buffer&amp;);
+
+  bool
+  operator!= (const buffer&amp;, const buffer&amp;);
+}
+  </pre>
+
+  <p>If the <code>assume_ownership</code> argument to the constructor
+     is <code>true</code>, the instance assumes the ownership of the
+     memory block pointed to by the <code>data</code> argument and will
+     eventually release it by calling <code>operator delete()</code>. The
+     <code>capacity()</code> and <code>size()</code> modifier functions
+     return <code>true</code> if the underlying buffer has moved.
+  </p>
+
+  <p>The <code>bounds</code> exception is thrown if the constructor
+     arguments violate the <code>(size&nbsp;&lt;=&nbsp;capacity)</code>
+     constraint.</p>
+
+
+  <h2><a name="6.4">6.4 Time Zone Representation</a></h2>
+
+  <p>The <code>date</code>, <code>dateTime</code>, <code>gDay</code>,
+     <code>gMonth</code>, <code>gMonthDay</code>, <code>gYear</code>,
+     <code>gYearMonth</code>, and <code>time</code> XML Schema built-in
+     types all include an optional time zone component. The following
+     <code>xml_schema::time_zone</code> base class is used to represent
+     this information:</p>
+
+  <pre class="c++">
+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&amp;, const time_zone&amp;);
+
+  bool
+  operator!= (const time_zone&amp;, const time_zone&amp;);
+}
+  </pre>
+
+  <p>The <code>zone_present()</code> accessor function returns <code>true</code>
+     if the time zone is specified. The <code>zone_reset()</code> modifier
+     function resets the time zone object to the <em>not specified</em>
+     state. If the time zone offset is negative then both hours and
+     minutes components are represented as negative integers.</p>
+
+
+  <h2><a name="6.5">6.5 <code>date</code> Parser</a></h2>
+
+ <p>The return type of the <code>date_pimpl</code> parser implementation
+     is <code>xml_schema::date</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const date&amp;);
+
+  bool
+  operator!= (const date&amp;, const date&amp;);
+}
+  </pre>
+
+  <h2><a name="6.6">6.6 <code>dateTime</code> Parser</a></h2>
+
+  <p>The return type of the <code>date_time_pimpl</code> parser implementation
+     is <code>xml_schema::date_time</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const date_time&amp;);
+
+  bool
+  operator!= (const date_time&amp;, const date_time&amp;);
+}
+  </pre>
+
+  <h2><a name="6.7">6.7 <code>duration</code> Parser</a></h2>
+
+  <p>The return type of the <code>duration_pimpl</code> parser implementation
+     is <code>xml_schema::duration</code> which represents a potentially
+     negative duration in the form of years, months, days, hours, minutes,
+     and seconds. Its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;, const duration&amp;);
+
+  bool
+  operator!= (const duration&amp;, const duration&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.8">6.8 <code>gDay</code> Parser</a></h2>
+
+  <p>The return type of the <code>gday_pimpl</code> parser implementation
+     is <code>xml_schema::gday</code> which represents a day of the month with
+     an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gday&amp;);
+
+  bool
+  operator!= (const gday&amp;, const gday&amp;);
+}
+  </pre>
+
+  <h2><a name="6.9">6.9 <code>gMonth</code> Parser</a></h2>
+
+  <p>The return type of the <code>gmonth_pimpl</code> parser implementation
+     is <code>xml_schema::gmonth</code> which represents a month of the year
+     with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gmonth&amp;);
+
+  bool
+  operator!= (const gmonth&amp;, const gmonth&amp;);
+}
+  </pre>
+
+  <h2><a name="6.10">6.10 <code>gMonthDay</code> Parser</a></h2>
+
+  <p>The return type of the <code>gmonth_day_pimpl</code> parser implementation
+     is <code>xml_schema::gmonth_day</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gmonth_day&amp;);
+
+  bool
+  operator!= (const gmonth_day&amp;, const gmonth_day&amp;);
+}
+  </pre>
+
+  <h2><a name="6.11">6.11 <code>gYear</code> Parser</a></h2>
+
+  <p>The return type of the <code>gyear_pimpl</code> parser implementation
+     is <code>xml_schema::gyear</code> which represents a year with
+     an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gyear&amp;);
+
+  bool
+  operator!= (const gyear&amp;, const gyear&amp;);
+}
+  </pre>
+
+  <h2><a name="6.12">6.12 <code>gYearMonth</code> Parser</a></h2>
+
+  <p>The return type of the <code>gyear_month_pimpl</code> parser implementation
+     is <code>xml_schema::gyear_month</code> which represents a year and a month
+     with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const gyear_month&amp;);
+
+  bool
+  operator!= (const gyear_month&amp;, const gyear_month&amp;);
+}
+  </pre>
+
+
+  <h2><a name="6.13">6.13 <code>time</code> Parser</a></h2>
+
+ <p>The return type of the <code>time_pimpl</code> parser implementation
+     is <code>xml_schema::time</code> which represents hours, minutes,
+     and seconds with an optional time zone. Its interface is presented below.
+     For more information on the base <code>xml_schema::time_zone</code>
+     class refer to <a href="#6.4">Section 6.4, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;, const time&amp;);
+
+  bool
+  operator!= (const time&amp;, const time&amp;);
+}
+  </pre>
+
+
+  <!-- Error Handling -->
+
+
+  <h1><a name="7">7 Document Parser and Error Handling</a></h1>
+
+  <p>In this chapter we will discuss the <code>xml_schema::document</code>
+     type as well as the error handling mechanisms provided by the mapping
+     in more detail. As mentioned in <a href="#3.4">Section 3.4,
+     "Connecting the Parsers Together"</a>, the interface of
+     <code>xml_schema::document</code> depends on the underlying XML
+     parser selected (<a href="#5.3">Section 5.3, "Underlying XML
+     Parser"</a>). The following sections describe the
+     <code>document</code> type interface for Xerces-C++ and
+     Expat as underlying parsers.</p>
+
+  <h2><a name="7.1">7.1 Xerces-C++ Document Parser</a></h2>
+
+  <p>When Xerces-C++ is used as the underlying XML parser, the
+     <code>document</code> type has the following interface. Note that
+     if the character type is <code>wchar_t</code>, then the string type
+     in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+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&amp; namespace_,
+                     const std::string&amp; location);
+
+    // Add a location for a schema without a target namespace.
+    //
+    void
+    no_namespace_schema_location (const std::string&amp; location);
+  };
+
+  class document
+  {
+  public:
+    document (parser_base&amp; root,
+              const std::string&amp; root_element_name,
+	      bool polymorphic = false);
+
+    document (parser_base&amp; root,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; root_element_name,
+	      bool polymorphic = false);
+
+  public:
+    // Parse URI or a local file.
+    //
+    void
+    parse (const std::string&amp; uri,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse URI or a local file with a user-provided error_handler
+    // object.
+    //
+    void
+    parse (const std::string&amp; uri,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp; uri,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp; uri,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           flags = 0,
+           const properties&amp; = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+
+  public:
+    // Parse InputSource. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           error_handler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::ErrorHandler&amp;,
+           flags = 0,
+           const properties&amp; = 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&amp;,
+           xercesc::SAX2XMLReader&amp;,
+           flags = 0,
+           const properties&amp; = properties ());
+  };
+}
+  </pre>
+
+  <p>The <code>document</code> 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 <code>parser_base</code>
+     class is the base type for all parser skeletons. The second and
+     third arguments to the <code>document</code>'s constructors are
+     the root element's name and namespace. The last argument,
+     <code>polymorphic</code>, 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 <a href="#5.5">Section 5.5, "Support for Polymorphism"</a>.</p>
+
+  <p>The rest of the <code>document</code> interface consists of overloaded
+     <code>parse()</code> functions. The last two arguments in each of these
+     functions are <code>flags</code> and <code>properties</code>. The
+     <code>flags</code> argument allows you to modify the default behavior
+     of the parsing functions. The <code>properties</code> 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 <code>file:///absolute/path/to/your/schema</code>.</p>
+
+  <p>A number of overloaded <code>parse()</code> functions have the
+     <code>system_id</code> and <code>public_id</code> arguments. The
+     system id is a <em>system</em> identifier of the resources being
+     parsed (for example, URI or a full file path). The public id is a
+     <em>public</em> 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.</p>
+
+  <p>The error handling mechanisms employed by the <code>document</code>
+     parser are described in <a href="#7.3">Section 7.3, "Error
+     Handling"</a>.</p>
+
+  <h2><a name="7.2">7.2 Expat Document Parser</a></h2>
+
+  <p>When Expat is used as the underlying XML parser, the
+     <code>document</code> type has the following interface. Note that
+     if the character type is <code>wchar_t</code>, then the string type
+     in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class document
+  {
+  public:
+    document (parser_base&amp;,
+              const std::string&amp; root_element_name,
+              bool polymorphic = false);
+
+    document (parser_base&amp;,
+              const std::string&amp; root_element_namespace,
+              const std::string&amp; 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&amp; 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&amp; file, error_handler&amp;);
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&amp;);
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&amp;, error_handler&amp;);
+
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&amp;, const std::string&amp; system_id);
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           error_handler&amp;);
+
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id);
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&amp;,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;);
+
+  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&amp;);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           error_handler&amp;);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string&amp; system_id,
+           const std::string&amp; public_id,
+           error_handler&amp;);
+
+  public:
+    // Low-level Expat-specific parsing API.
+    //
+    void
+    parse_begin (XML_Parser);
+
+    void
+    parse_begin (XML_Parser, const std::string&amp; public_id);
+
+    void
+    parse_begin (XML_Parser, error_handler&amp;);
+
+    void
+    parse_begin (XML_Parser,
+                 const std::string&amp; public_id,
+                 error_handler&amp;);
+    void
+    parse_end ();
+  };
+}
+  </pre>
+
+  <p>The <code>document</code> 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 <code>parser_base</code>
+     class is the base type for all parser skeletons. The second and
+     third arguments to the <code>document</code>'s constructors are
+     the root element's name and namespace. The last argument,
+     <code>polymorphic</code>, 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 <a href="#5.5">Section 5.5, "Support for Polymorphism"</a>.</p>
+
+  <p>A number of overloaded <code>parse()</code> functions have the
+     <code>system_id</code> and <code>public_id</code> arguments. The
+     system id is a <em>system</em> identifier of the resources being
+     parsed (for example, URI or a full file path). The public id is a
+     <em>public</em> 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.</p>
+
+  <p>The <code>parse_begin()</code> and <code>parse_end()</code> functions
+     present a low-level, Expat-specific parsing API for maximum control.
+     A typical use-case would look like this (pseudo-code):</p>
+
+  <pre class="c++">
+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 ());
+  </pre>
+
+  <p>Note that if your vocabulary uses XML namespaces, the
+     <code>XML_ParserCreateNS()</code> functions should be used to create
+     the XML parser. Space (<code>XML_Char (' ')</code>) should be used
+     as a separator (the second argument to <code>XML_ParserCreateNS()</code>).
+  </p>
+
+  <p>The error handling mechanisms employed by the <code>document</code>
+     parser are described in <a href="#7.3">Section 7.3, "Error
+     Handling"</a>.</p>
+
+
+  <h2><a name="7.3">7.3 Error Handling</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>The System errors are mapped to the standard exceptions. The
+     out of memory condition is indicated by throwing an instance
+     of <code>std::bad_alloc</code>. The stream operation errors
+     are reported either by throwing an instance of
+     <code>std::ios_base::failure</code> if exceptions are enabled
+     or by setting the stream state.</p>
+
+  <p>Note that if you are parsing <code>std::istream</code> on
+     which exceptions are not enabled, then you will need to
+     check the stream state before calling the <code>post()</code>
+     callback, as shown in the following example:</p>
+
+  <pre class="c++">
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  std::ifstream ifs (argv[1]);
+
+  if (ifs.fail ())
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": unable to open" &lt;&lt; endl;
+    return 1;
+  }
+
+  root_p.pre ();
+  doc_p.parse (ifs);
+
+  if (ifs.fail ())
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": io failure" &lt;&lt; endl;
+    return 1;
+  }
+
+  result_type result (root_p.post_xxx ());
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions
+     as shown below:</p>
+
+  <pre class="c++">
+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&amp;)
+  {
+    cerr &lt;&lt; argv[1] &lt;&lt; ": unable to open or io failure" &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+
+  <p>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.</p>
+
+  <p>The XML errors can be reported either by throwing the
+     <code>xml_schema::parsing</code> exception or by a callback
+     to the <code>xml_schema::error_handler</code> object (and
+     <code>xercesc::ErrorHandler</code> object in case of Xerces-C++).</p>
+
+  <p>The <code>xml_schema::parsing</code> 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
+     <code>xml_schema::parsing</code> exception. Note that if the
+     character type is <code>wchar_t</code>, then the string type
+     and output stream type in the definition become
+     <code>std::wstring</code> and <code>std::wostream</code>,
+     respectively (see <a href="#5.2">Section 5.2, "Character Type
+     and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class exception: public std::exception
+  {
+  protected:
+    virtual void
+    print (std::ostream&amp;) const = 0;
+  };
+
+  inline std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp; os, const exception&amp; e)
+  {
+    e.print (os);
+    return os;
+  }
+
+
+  class severity
+  {
+  public:
+    enum value
+    {
+      warning,
+      error
+    };
+  };
+
+
+  class error
+  {
+  public:
+    error (xml_schema::severity,
+           const std::string&amp; id,
+           unsigned long line,
+           unsigned long column,
+           const std::string&amp; message);
+
+    xml_schema::severity
+    severity () const;
+
+    const std::string&amp;
+    id () const;
+
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    const std::string&amp;
+    message () const;
+  };
+
+  std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp;, const error&amp;);
+
+
+  class diagnostics: public std::vector&lt;error>
+  {
+  };
+
+  std::ostream&amp;
+  operator&lt;&lt; (std::ostream&amp;, const diagnostics&amp;);
+
+
+  class parsing: public exception
+  {
+  public:
+    parsing ();
+    parsing (const xml_schema::diagnostics&amp;);
+
+    const xml_schema::diagnostics&amp;
+    diagnostics () const;
+
+    virtual const char*
+    what () const throw ();
+
+  protected:
+    virtual void
+    print (std::ostream&amp;) const;
+  };
+}
+  </pre>
+
+  <p>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.</p>
+
+  <pre class="c++">
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+  }
+  catch (const xml_schema::parsing&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>With the <code>error_handler</code> approach the diagnostics
+     messages are delivered as parsing progresses. The following
+     listing presents the definition of the <code>error_handler</code>
+     interface. Note that if the character type is <code>wchar_t</code>,
+     then the string type in the interface becomes <code>std::wstring</code>
+     (see <a href="#5.2">Section 5.2, "Character Type and Encoding"</a>).</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class error_handler
+  {
+  public:
+    class severity
+    {
+    public:
+      enum value
+      {
+        warning,
+        error,
+        fatal
+      };
+    };
+
+    virtual bool
+    handle (const std::string&amp; id,
+            unsigned long line,
+            unsigned long column,
+            severity,
+            const std::string&amp; message) = 0;
+  };
+}
+  </pre>
+
+  <p>The return value of the <code>handle()</code> 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  <code>error_handler</code> object, an empty
+     <code>xml_schema::parsing</code> exception is thrown to indicate
+     the failure to the caller. You can alter this behavior by throwing
+     your own exception from the <code>handle()</code> function.</p>
+
+
+  <!-- Appendix A -->
+
+
+  <h1><a name="A">Appendix A &mdash; Supported XML Schema Constructs</a></h1>
+
+  <p>The C++/Parser mapping supports validation of the following W3C XML
+     Schema constructs in the generated code.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="features" border="1">
+    <tr><th>Construct</th><th>Notes</th></tr>
+    <tr><th colspan="2">Structure</th></tr>
+
+    <tr><td>element</td><td></td></tr>
+    <tr><td>attribute</td><td></td></tr>
+
+    <tr><td>any</td><td></td></tr>
+    <tr><td>anyAttribute</td><td></td></tr>
+
+    <tr><td>all</td><td></td></tr>
+    <tr><td>sequence</td><td></td></tr>
+    <tr><td>choice</td><td></td></tr>
+
+    <tr><td>complex type, empty content</td><td></td></tr>
+    <tr><td>complex type, mixed content</td><td></td></tr>
+    <tr><td>complex type, simple content extension</td><td></td></tr>
+    <tr><td>complex type, simple content restriction</td>
+        <td>Simple type facets are not validated.</td></tr>
+    <tr><td>complex type, complex content extension</td><td></td></tr>
+    <tr><td>complex type, complex content restriction</td><td></td></tr>
+
+    <tr><td>list</td><td></td></tr>
+
+    <tr><th colspan="2">Datatypes</th></tr>
+
+    <tr><td>byte</td><td></td></tr>
+    <tr><td>unsignedByte</td><td></td></tr>
+    <tr><td>short</td><td></td></tr>
+    <tr><td>unsignedShort</td><td></td></tr>
+    <tr><td>int</td><td></td></tr>
+    <tr><td>unsignedInt</td><td></td></tr>
+    <tr><td>long</td><td></td></tr>
+    <tr><td>unsignedLong</td><td></td></tr>
+    <tr><td>integer</td><td></td></tr>
+    <tr><td>nonPositiveInteger</td><td></td></tr>
+    <tr><td>nonNegativeInteger</td><td></td></tr>
+    <tr><td>positiveInteger</td><td></td></tr>
+    <tr><td>negativeInteger</td><td></td></tr>
+
+    <tr><td>boolean</td><td></td></tr>
+
+    <tr><td>float</td><td></td></tr>
+    <tr><td>double</td><td></td></tr>
+    <tr><td>decimal</td><td></td></tr>
+
+    <tr><td>string</td><td></td></tr>
+    <tr><td>normalizedString</td><td></td></tr>
+    <tr><td>token</td><td></td></tr>
+    <tr><td>Name</td><td></td></tr>
+    <tr><td>NMTOKEN</td><td></td></tr>
+    <tr><td>NCName</td><td></td></tr>
+    <tr><td>language</td><td></td></tr>
+    <tr><td>anyURI</td><td></td></tr>
+
+    <tr><td>ID</td><td>Identity constraint is not enforced.</td></tr>
+    <tr><td>IDREF</td><td>Identity constraint is not enforced.</td></tr>
+
+    <tr><td>NMTOKENS</td><td></td></tr>
+    <tr><td>IDREFS</td><td>Identity constraint is not enforced.</td></tr>
+
+    <tr><td>QName</td><td></td></tr>
+
+    <tr><td>base64Binary</td><td></td></tr>
+    <tr><td>hexBinary</td><td></td></tr>
+
+    <tr><td>date</td><td></td></tr>
+    <tr><td>dateTime</td><td></td></tr>
+    <tr><td>duration</td><td></td></tr>
+    <tr><td>gDay</td><td></td></tr>
+    <tr><td>gMonth</td><td></td></tr>
+    <tr><td>gMonthDay</td><td></td></tr>
+    <tr><td>gYear</td><td></td></tr>
+    <tr><td>gYearMonth</td><td></td></tr>
+    <tr><td>time</td><td></td></tr>
+  </table>
+
+
+  </div>
+</div>
+
+</body>
+</html>
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: "
+<div align=center>
+  <h1><big>C++/Tree Mapping</big></h1>
+  <h1><big>Getting Started Guide</big></h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+</div>
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href='https://www.codesynthesis.com/licenses/fdl-1.2.txt'>GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/index.xhtml'>XHTML</a>,
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-parser-guide.pdf'>PDF</a>, and
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-parser-guide.ps'>PostScript</a>.</p>";
+  }
+
+  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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Tree Mapping Getting Started Guide</title>
+
+  <meta name="copyright" content="&#169; 2005-2023 Code Synthesis"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,parsing,serialization,validation"/>
+  <meta name="description" content="C++/Tree Mapping Getting Started Guide"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+    line-height: 1.2em;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 140%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage .title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+  }
+
+  #titlepage #first-title {
+    padding: 1em 0 0.4em 0;
+  }
+
+  #titlepage #second-title {
+    padding: 0.4em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+  div.img {
+    text-align: center;
+    padding: 2em 0 2em 0;
+  }
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div class="title" id="first-title">C++/Tree Mapping</div>
+    <div class="title" id="second-title">Getting Started Guide</div>
+
+  <p>Copyright &#169; 2005-2023 Code Synthesis.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-tree-guide.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-tree-guide.ps">PostScript</a>.</p>
+
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+          <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a>
+        <table class="toc">
+          <tr><th>1.1</th><td><a href="#1.1">Mapping Overview</a></td></tr>
+          <tr><th>1.2</th><td><a href="#1.2">Benefits</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">Hello World Example</a>
+        <table class="toc">
+          <tr><th>2.1</th><td><a href="#2.1">Writing XML Document and Schema</a></td></tr>
+          <tr><th>2.2</th><td><a href="#2.2">Translating Schema to C++</a></td></tr>
+          <tr><th>2.3</th><td><a href="#2.3">Implementing Application Logic</a></td></tr>
+          <tr><th>2.4</th><td><a href="#2.4">Compiling and Running</a></td></tr>
+	  <tr><th>2.5</th><td><a href="#2.5">Adding Serialization</a></td></tr>
+	  <tr><th>2.6</th><td><a href="#2.6">Selecting Naming Convention</a></td></tr>
+	  <tr><th>2.7</th><td><a href="#2.7">Generating Documentation</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Overall Mapping Configuration</a>
+        <table class="toc">
+	  <tr><th>3.1</th><td><a href="#3.1">C++ Standard</a></td></tr>
+          <tr><th>3.2</th><td><a href="#3.2">Character Type and Encoding</a></td></tr>
+          <tr><th>3.3</th><td><a href="#3.3">Support for Polymorphism </a></td></tr>
+          <tr><th>3.4</th><td><a href="#3.4">Namespace Mapping</a></td></tr>
+          <tr><th>3.5</th><td><a href="#3.5">Thread Safety</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Working with Object Models</a>
+        <table class="toc">
+          <tr><th>4.1</th><td><a href="#4.1">Attribute and Element Cardinalities</a></td></tr>
+          <tr><th>4.2</th><td><a href="#4.2">Accessing the Object Model</a></td></tr>
+          <tr><th>4.3</th><td><a href="#4.3">Modifying the Object Model</a></td></tr>
+          <tr><th>4.4</th><td><a href="#4.4">Creating the Object Model from Scratch</a></td></tr>
+	  <tr><th>4.5</th><td><a href="#4.5">Mapping for the Built-in XML Schema Types</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Parsing</a>
+        <table class="toc">
+          <tr><th>5.1</th><td><a href="#5.1">XML Schema Validation and Searching</a></td></tr>
+          <tr><th>5.2</th><td><a href="#5.2">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>6</th><td><a href="#6">Serialization</a>
+        <table class="toc">
+          <tr><th>6.1</th><td><a href="#6.1">Namespace and Schema Information</a></td></tr>
+          <tr><th>6.2</th><td><a href="#6.2">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/">C++/Tree
+     Mapping User Manual</a>.</p>
+
+  <p>Prior experience with XML and C++ is required to understand this
+     document. Basic understanding of XML Schema is advantageous but
+     not expected or required.
+  </p>
+
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this guide, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/">C++/Tree
+        Mapping User Manual</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+        Mapping Customization Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree
+        Mapping Frequently Asked Questions (FAQ)</a></li>
+
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/tree/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is the place to ask technical questions about XSD and the C++/Parser mapping.
+        Furthermore, the <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+  </ul>
+
+  <!-- Introduction -->
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.
+  </p>
+
+  <h2><a name="1.1">1.1 Mapping Overview</a></h2>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="1.2">1.2 Benefits</a></h2>
+
+  <p>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:
+  </p>
+
+  <ul class="list">
+    <li>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.</li>
+
+    <li>String-based flow control defers error detection to runtime.
+        It also reduces code readability and maintainability.</li>
+
+    <li>Lack of type safety because the data is represented as text.</li>
+
+    <li>Resulting applications are hard to debug, change, and
+        maintain.</li>
+  </ul>
+
+  <p>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:</p>
+
+  <ul class="list">
+    <li><b>Ease of use.</b> 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.</li>
+
+    <li><b>Natural representation.</b> The object representation allows
+         you to access the XML data using your domain vocabulary instead
+         of generic elements, attributes, and text.</li>
+
+    <li><b>Concise code.</b> With the object representation the
+        application implementation is simpler and thus easier
+        to read and understand.</li>
+
+    <li><b>Safety.</b> 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.</li>
+
+    <li><b>Maintainability.</b> 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.</li>
+
+    <li><b>Compatibility.</b> 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.</li>
+
+    <li><b>Efficiency.</b> 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.</li>
+  </ul>
+
+
+  <!-- Hello World Parser -->
+
+
+  <h1><a name="2">2 Hello World Example</a></h1>
+
+  <p>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 <code>hello</code> example which can be found in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> package.</p>
+
+  <h2><a name="2.1">2.1 Writing XML Document and Schema</a></h2>
+
+  <p>First, we need to get an idea about the structure
+     of the XML documents we are going to process. Our
+     <code>hello.xml</code>, for example, could look like this:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello>
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>Then we can write a description of the above XML in the
+     XML Schema language and save it into <code>hello.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="greeting" type="xs:string"/>
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello_t"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Even if you are not familiar with XML Schema, it
+     should be easy to connect declarations in <code>hello.xsd</code>
+     to elements in <code>hello.xml</code>. The <code>hello_t</code> type
+     is defined as a sequence of the nested <code>greeting</code> and
+     <code>name</code> 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 <code>name</code>
+     element has its <code>maxOccurs</code> property set to
+     <code>unbounded</code> which means it can appear multiple times
+     in an XML document. Finally, the globally-defined <code>hello</code>
+     element prescribes the root element for our vocabulary. For an
+     easily-approachable introduction to XML Schema refer to
+     <a href="http://www.w3.org/TR/xmlschema-0/">XML Schema Part 0:
+     Primer</a>.</p>
+
+  <p>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 <code>hello.xml</code> to include the
+     information about the schema so that XML parsers can validate
+     our document:</p>
+
+      <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+      </pre>
+
+
+  <p>The next step is to compile the schema to generate the object
+     model and parsing functions.</p>
+
+  <h2><a name="2.2">2.2 Translating Schema to C++</a></h2>
+
+  <p>Now we are ready to translate our <code>hello.xsd</code> to C++.
+     To do this we invoke the XSD compiler from a terminal (UNIX) or
+     a command prompt (Windows):
+  </p>
+
+  <pre class="terminal">
+$ xsd cxx-tree hello.xsd
+  </pre>
+
+  <p>The XSD compiler produces two C++ files: <code>hello.hxx</code> and
+     <code>hello.cxx</code>. The following code fragment is taken from
+     <code>hello.hxx</code>; it should give you an idea about what gets
+     generated:
+  </p>
+
+  <pre class="c++">
+class hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::string greeting_type;
+
+  const greeting_type&amp;
+  greeting () const;
+
+  greeting_type&amp;
+  greeting ();
+
+  void
+  greeting (const greeting_type&amp; x);
+
+  // name
+  //
+  typedef xml_schema::string name_type;
+  typedef xsd::sequence&lt;name_type> name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&amp;
+  name () const;
+
+  name_sequence&amp;
+  name ();
+
+  void
+  name (const name_sequence&amp; s);
+
+  // Constructor.
+  //
+  hello_t (const greeting_type&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;hello_t>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>The <code>hello_t</code> C++ class corresponds to the
+     <code>hello_t</code> 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
+     <code>hello_t</code> class. Note that the type definitions
+     and member functions for the <code>greeting</code> and
+     <code>name</code> elements are different because of the
+     cardinality differences between these two elements
+     (<code>greeting</code> is a required single element and
+     <code>name</code> is a sequence of elements).</p>
+
+  <p>The <code>xml_schema::string</code> type used in the type
+     definitions is a C++ class provided by the XSD runtime
+     that corresponds to built-in XML Schema type
+     <code>string</code>. The <code>xml_schema::string</code>
+     is based on <code>std::string</code> and can be used as
+     such. Similarly, the <code>sequence</code> class template
+     that is used in the <code>name_sequence</code> type
+     definition is based on and has the same interface as
+     <code>std::vector</code>. The mapping between the built-in
+     XML Schema types and C++ types is described in more detail in
+     <a href="#4.5">Section 4.5, "Mapping for the Built-in XML Schema
+     Types"</a>. The <code>hello_t</code> class also includes a
+     constructor with an initializer for the required
+     <code>greeting</code> element as its argument.</p>
+
+  <p>The <code>hello</code> overloaded global functions correspond
+     to the <code>hello</code> 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 <code>--root-element-*</code> 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 <code>std::unique_ptr</code>
+     as shown above. For C++98 it is <code>std::auto_ptr</code>.
+     For example, if we modify our XSD compiler invocation to
+     select C++98:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --std c++98 hello.xsd
+  </pre>
+
+  <p>Then the parsing function signatures will become:</p>
+
+  <pre class="c++">
+std::auto_ptr&lt;hello_t>
+hello (const std::string&amp; uri);
+
+std::auto_ptr&lt;hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>For more information on parsing functions see <a href="#5">Chapter 5,
+     "Parsing"</a>.</p>
+
+  <h2><a name="2.3">2.3 Implementing Application Logic</a></h2>
+
+  <p>At this point we have all the parts we need to do something useful
+     with the information stored in our XML document:
+  </p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr&lt;hello_t> h (hello (argv[1]));
+
+    for (hello_t::name_const_iterator i (h->name ().begin ());
+         i != h->name ().end ();
+         ++i)
+    {
+      cerr &lt;&lt; h->greeting () &lt;&lt; ", " &lt;&lt; *i &lt;&lt; "!" &lt;&lt; endl;
+    }
+  }
+  catch (const xml_schema::exception&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>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 <code>xml_schema::exception</code>
+     exception in case something goes wrong. This exception
+     is the root of the exception hierarchy used by the
+     XSD-generated code.
+  </p>
+
+
+  <h2><a name="2.4">2.4 Compiling and Running</a></h2>
+
+  <p>After saving our application from the previous section in
+     <code>driver.cxx</code>, 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:
+  </p>
+
+  <pre class="terminal">
+$ 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!
+  </pre>
+
+  <p>Here <code>.../libxsd</code> represents the path to the
+     <a href="https://cppget.org/libxsd">libxsd</a> 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.</p>
+
+  <h2><a name="2.5">2.5 Adding Serialization</a></h2>
+
+  <p>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 <code>--generate-serialization</code> options:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --generate-serialization hello.xsd
+  </pre>
+
+  <p>If we now examine the generated <code>hello.hxx</code> file,
+     we will find a set of overloaded serialization functions,
+     including the following version:</p>
+
+  <pre class="c++">
+void
+hello (std::ostream&amp;,
+       const hello_t&amp;,
+       const xml_schema::namespace_infomap&amp; =
+         xml_schema::namespace_infomap ());
+
+  </pre>
+
+  <p>Just like with parsing functions, XSD generates serialization
+     functions for each global element unless instructed otherwise
+     with one of the <code>--root-element-*</code> options. For more
+     information on serialization functions see <a href="#6">Chapter 6,
+     "Serialization"</a>.</p>
+
+  <p>We first examine an application that modifies an existing
+     object model and serializes it back to XML:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr&lt;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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>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.</p>
+
+  <p>The first argument we pass to the serialization function is
+     <code>cout</code> 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 <code>std::ofstream</code> or <code>std::ostringstream</code>
+     and passing it instead of <code>cout</code>. 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 (<code>p1</code>,
+     <code>p2</code>, etc.) will be automatically assigned to XML namespaces
+     and no schema information will be added to the resulting document
+     (see <a href="#6">Chapter 6, "Serialization"</a> for details).
+     In our case, the prefix (map key) and namespace name are empty
+     because our vocabulary does not use XML namespaces.</p>
+
+  <p>If we now compile and run this application we will see the
+     output as shown in the following listing:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hi&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+  &lt;name>mars&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>We can also create and serialize an object model from scratch
+     as shown in the following example:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include &lt;fstream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello_t h ("Hi");
+
+    hello_t::name_sequence&amp; 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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>In this example we used the generated constructor to create
+     an instance of type <code>hello_t</code>. 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:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hi&lt;/greeting>
+
+  &lt;name>Jane&lt;/name>
+  &lt;name>John&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <h2><a name="2.6">2.6 Selecting Naming Convention</a></h2>
+
+  <p>By default XSD uses the so-called K&amp;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 <code>--type-naming</code> and
+     <code>--function-naming</code> options. You can also further
+     refine one of the predefined conventions or create a completely
+     custom naming scheme by using the  <code>--*-regex</code> options.</p>
+
+  <p>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&amp;R
+     convention for function names. Since K&amp;R is the default
+     convention for both type and function names, we only need to
+     change the type naming scheme:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --type-naming ucc hello.xsd
+  </pre>
+
+  <p>The <code>ucc</code> argument to the <code>--type-naming</code>
+     options stands for upper-camel-case. If we now examine the
+     generated <code>hello.hxx</code>, we will see the following
+     changes compared to the declarations shown in the previous
+     sections:</p>
+
+  <pre class="c++">
+class Hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&amp;
+  greeting () const;
+
+  GreetingType&amp;
+  greeting ();
+
+  void
+  greeting (const GreetingType&amp; x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence&lt;NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&amp;
+  name () const;
+
+  NameSequence&amp;
+  name ();
+
+  void
+  name (const NameSequence&amp; s);
+
+  // Constructor.
+  //
+  Hello_t (const GreetingType&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;Hello_t>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;Hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>Notice that the type names in the <code>xml_schema</code> namespace,
+     for example <code>xml_schema::String</code>, now also use the
+     upper-camel-case naming convention. The only thing that we may
+     be unhappy about in the above code is the <code>_t</code>
+     suffix in <code>Hello_t</code>. If we are not in a position
+     to change the schema, we can <em>touch-up</em> the <code>ucc</code>
+     convention with a custom translation rule using the
+     <code>--type-regex</code> option:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --type-naming ucc --type-regex '/ (.+)_t/\u$1/' hello.xsd
+  </pre>
+
+  <p>This results in the following changes to the generated code:</p>
+
+  <pre class="c++">
+class Hello
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&amp;
+  greeting () const;
+
+  GreetingType&amp;
+  greeting ();
+
+  void
+  greeting (const GreetingType&amp; x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence&lt;NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&amp;
+  name () const;
+
+  NameSequence&amp;
+  name ();
+
+  void
+  name (const NameSequence&amp; s);
+
+  // Constructor.
+  //
+  Hello (const GreetingType&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;Hello>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;Hello>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>For more detailed information on the <code>--type-naming</code>,
+     <code>--function-naming</code>, <code>--type-regex</code>, and
+     other <code>--*-regex</code> options refer to the NAMING
+     CONVENTION section in the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+  <h2><a name="2.7">2.7 Generating Documentation</a></h2>
+
+  <p>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 <a href="http://www.doxygen.org">Doxygen</a>
+     documentation system to extract this information and produce
+     documentation in various formats.
+  </p>
+
+  <p>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 <code>hello.xsd</code> with added documentation:</p>
+
+  <pre class="xml">
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello_t">
+
+    &lt;xs:annotation>
+      &lt;xs:documentation>
+        The hello_t type consists of a greeting phrase and a
+        collection of names to which this greeting applies.
+      &lt;/xs:documentation>
+    &lt;/xs:annotation>
+
+    &lt;xs:sequence>
+
+      &lt;xs:element name="greeting" type="xs:string">
+        &lt;xs:annotation>
+          &lt;xs:documentation>
+            The greeting element contains the greeting phrase
+            for this hello object.
+          &lt;/xs:documentation>
+        &lt;/xs:annotation>
+      &lt;/xs:element>
+
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded">
+        &lt;xs:annotation>
+          &lt;xs:documentation>
+            The name elements contains names to be greeted.
+          &lt;/xs:documentation>
+        &lt;/xs:annotation>
+      &lt;/xs:element>
+
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello_t">
+    &lt;xs:annotation>
+      &lt;xs:documentation>
+        The hello element is a root of the Hello XML vocabulary.
+        Every conforming document should start with this element.
+      &lt;/xs:documentation>
+    &lt;/xs:annotation>
+  &lt;/xs:element>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>The first step in obtaining the documentation is to recompile
+     our schema with the <code>--generate-doxygen</code> option:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd
+  </pre>
+
+  <p>Now the generated <code>hello.hxx</code> 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:</p>
+
+  <pre class="terminal">
+$ doxygen -g hello.doxygen
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="terminal">
+$ doxygen hello.doxygen
+  </pre>
+
+  <p>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 <code>hello_t</code> class which
+     is generated by the XSD compiler and the <code>xml_schema::string</code>
+     class which is defined in the XSD runtime library. The Doxygen
+     configuration file for the XSD runtime is provided with the XSD
+     distribution.</p>
+
+  <p>You can view the result of the steps described in this section
+     on the <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/hello/html/annotated.html">Hello
+     Example Documentation</a> page.</p>
+
+  <!-- Chapater 3 -->
+
+
+  <h1><a name="3">3 Overall Mapping Configuration</a></h1>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.
+  </p>
+
+  <h2><a name="3.1">3.1 C++ Standard</a></h2>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h2><a name="3.2">3.2 Character Type and Encoding</a></h2>
+
+  <p>The C++/Tree mapping has built-in support for two character types:
+    <code>char</code> and <code>wchar_t</code>. You can select the
+    character type with the <code>--char-type</code> command line
+    option. The default character type is <code>char</code>. 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.</p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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 <code>--char-encoding</code> command
+     line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <p>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.</p>
+
+  <h2><a name="3.3">3.3 Support for Polymorphism</a></h2>
+
+  <p>By default XSD generates non-polymorphic code. If your vocabulary
+     uses XML Schema polymorphism in the form of <code>xsi:type</code>
+     and/or substitution groups, then you will need to compile
+     your schemas with the <code>--generate-polymorphic</code> option
+     to produce polymorphism-aware code. For more information on
+     working with polymorphic object models, refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.11">Section 2.11,
+     "Mapping for <code>xsi:type</code> and Substitution Groups"</a> in
+     the C++/Tree Mapping User Manual.</p>
+
+  <h2><a name="3.4">3.4 Namespace Mapping</a></h2>
+
+  <p>XSD maps XML namespaces specified in the <code>targetNamespace</code>
+     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 <code>'/'</code> as the name
+     separator.</p>
+
+  <p>The default mapping of namespace URIs to C++ namespaces
+     can be altered using the <code>--namespace-map</code> and
+     <code>--namespace-regex</code> compiler options. For example,
+     to map namespace URI <code>https://www.codesynthesis.com/my</code> to
+     C++ namespace <code>cs::my</code>, we can use the following option:</p>
+
+  <pre class="terminal">
+--namespace-map https://www.codesynthesis.com/my=cs::my
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="terminal">
+--namespace-map =cs
+  </pre>
+
+  <h2><a name="3.5">3.5 Thread Safety</a></h2>
+
+  <p>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
+     <a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+     Mapping Customization Guide</a>.</p>
+
+  <p>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 <code>main()</code> when
+     there are no threads yet/anymore:</p>
+
+  <pre class="c++">
+#include &lt;xercesc/util/PlatformUtils.hpp>
+
+int
+main ()
+{
+  xercesc::XMLPlatformUtils::Initialize ();
+
+  {
+    // Start/terminate threads and parse/serialize here.
+  }
+
+  xercesc::XMLPlatformUtils::Terminate ();
+}
+  </pre>
+
+  <p>Because you initialize the Xerces-C++ runtime yourself you should
+     also pass the <code>xml_schema::flags::dont_initialize</code> flag
+     to parsing and serialization functions. See <a href="#5">Chapter 5,
+     "Parsing"</a> and <a href="#6">Chapter 6, "Serialization"</a> for
+     more information.</p>
+
+
+  <!-- Chapater 4 -->
+
+
+  <h1><a name="4">4 Working with Object Models</a></h1>
+
+  <p>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.</p>
+
+  <p>In this and subsequent chapters we will use the following schema
+     that describes a collection of person records. We save it in
+     <code>people.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:simpleType name="gender_t">
+    &lt;xs:restriction base="xs:string">
+      &lt;xs:enumeration value="male"/>
+      &lt;xs:enumeration value="female"/>
+    &lt;/xs:restriction>
+  &lt;/xs:simpleType>
+
+  &lt;xs:complexType name="person_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="first-name" type="xs:string"/>
+      &lt;xs:element name="middle-name" type="xs:string" minOccurs="0"/>
+      &lt;xs:element name="last-name" type="xs:string"/>
+      &lt;xs:element name="gender" type="gender_t"/>
+      &lt;xs:element name="age" type="xs:short"/>
+    &lt;/xs:sequence>
+    &lt;xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  &lt;/xs:complexType>
+
+  &lt;xs:complexType name="people_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="person" type="person_t" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="people" type="people_t"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>A sample XML instance to go along with this schema is saved
+     in <code>people.xml</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+  <p>Compiling <code>people.xsd</code> with the XSD compiler results
+     in three generated C++ classes: <code>gender_t</code>,
+     <code>person_t</code>, and <code>people_t</code>.
+     The <code>gender_t</code> class is modelled after the C++
+     <code>enum</code> type. Its definition is presented below:</p>
+
+  <pre class="c++">
+class gender_t: public xml_schema::string
+{
+public:
+  enum value
+  {
+    male,
+    female
+  };
+
+  gender_t (value);
+  gender_t (const xml_schema::string&amp;);
+
+  gender_t&amp;
+  operator= (value);
+
+  operator value () const;
+};
+  </pre>
+
+  <p>The following listing shows how we can use this type:</p>
+
+  <pre class="c++">
+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:
+  {
+    ...
+  }
+}
+  </pre>
+
+  <p>The other two classes will be examined in detail in the subsequent
+     sections.</p>
+
+  <h2><a name="4.1">4.1 Attribute and Element Cardinalities</a></h2>
+
+  <p>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:
+     <em>one</em>, <em>optional</em>, and <em>sequence</em>.</p>
+
+  <p>The <em>one</em> cardinality class covers all elements that should
+     occur exactly once as well as required attributes. In our
+     example, the <code>first-name</code>, <code>last-name</code>,
+     <code>gender</code>, and <code>age</code> elements as well as
+     the <code>id</code> 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
+     <code>gender</code> element in the <code>person_t</code> class:</p>
+
+  <pre class="c++">
+class person_t
+{
+  // gender
+  //
+  typedef gender_t gender_type;
+
+  const gender_type&amp;
+  gender () const;
+
+  gender_type&amp;
+  gender ();
+
+  void
+  gender (const gender_type&amp;);
+};
+  </pre>
+
+  <p>The <code>gender_type</code> 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.</p>
+
+  <p>The <em>optional</em> cardinality class covers all elements that
+     can occur zero or one time as well as optional attributes. In our
+     example, the <code>middle-name</code> 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 <code>person_t</code> class:</p>
+
+  <pre class="c++">
+class person_t
+{
+  // middle-name
+  //
+  typedef xml_schema::string middle_name_type;
+  typedef xsd::optional&lt;middle_name_type> middle_name_optional;
+
+  const middle_name_optional&amp;
+  middle_name () const;
+
+  middle_name_optional&amp;
+  middle_name ();
+
+  void
+  middle_name (const middle_name_type&amp;);
+
+  void
+  middle_name (const middle_name_optional&amp;);
+};
+  </pre>
+
+  <p>As with the <code>gender</code> element, <code>middle_name_type</code>
+     is an alias for the element's type. The <code>middle_name_optional</code>
+     type is a container for the element's optional value. It can be queried
+     for the presence of the value using the <code>present()</code> function.
+     The value itself can be retrieved using the <code>get()</code>
+     accessor and set using the <code>set()</code> modifier. The container
+     can be reverted to the value not present state with the call to the
+     <code>reset()</code> function. The following example shows how we
+     can use this container:</p>
+
+  <pre class="c++">
+person_t::middle_name_optional n ("John");
+
+if (n.present ())
+{
+  cout &lt;&lt; n.get () &lt;&lt; endl;
+}
+
+n.set ("Jane");
+n.reset ();
+  </pre>
+
+
+  <p>Unlike the <em>one</em> cardinality class, the accessor functions
+     for the <em>optional</em> 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.</p>
+
+  <p>Finally, the <em>sequence</em> cardinality class covers all elements
+     that can occur more than once. In our example, the
+     <code>person</code> element in the <code>people_t</code> 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 <code>people_t</code>
+     class:</p>
+
+  <pre class="c++">
+class people_t
+{
+  // person
+  //
+  typedef person_t person_type;
+  typedef xsd::sequence&lt;person_type> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&amp;
+  person () const;
+
+  person_sequence&amp;
+  person ();
+
+  void
+  person (const person_sequence&amp;);
+};
+  </pre>
+
+  <p>Identical to the other cardinality classes, <code>person_type</code>
+     is an alias for the element's type. The <code>person_sequence</code>
+     type is a sequence container for the element's values. It is based
+     on and has the same interface as <code>std::vector</code> and
+     therefore can be used in similar ways. The <code>person_iterator</code>
+     and <code>person_const_iterator</code> types are read-only
+     (constant) and read-write iterators for the <code>person_sequence</code>
+     container.</p>
+
+  <p>Similar to the <em>optional</em> cardinality class, the
+     accessor functions for the <em>sequence</em> class return
+     read-only (constant) and read-write references to the sequence
+     container. The modifier functions copies the entries from
+     the passed sequence.</p>
+
+  <p>C++/Tree is a "flattening" mapping in a sense that many levels of
+     nested compositors (<code>choice</code> and <code>sequence</code>),
+     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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8.4">Section
+     2.8.4, "Element Order"</a> in the C++/Tree Mapping User Manual.</p>
+
+  <p>For complex schemas with many levels of nested compositors
+     (<code>choice</code> and <code>sequence</code>) 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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="4.2">4.2 Accessing the Object Model</a></h2>
+
+  <p>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 <code>people.xml</code> file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr&lt;people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records.
+  //
+  people_t::person_sequence&amp; ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    person_t&amp; p (*i);
+
+    // Print names: first-name and last-name are required elements,
+    // middle-name is optional.
+    //
+    cout &lt;&lt; "name:   " &lt;&lt; p.first_name () &lt;&lt; " ";
+
+    if (p.middle_name ().present ())
+      cout &lt;&lt; p.middle_name ().get () &lt;&lt; " ";
+
+    cout &lt;&lt; p.last_name () &lt;&lt; endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout &lt;&lt; "gender: " &lt;&lt; p.gender () &lt;&lt; endl
+         &lt;&lt; "age:    " &lt;&lt; p.age () &lt;&lt; endl
+         &lt;&lt; "id:     " &lt;&lt; p.id () &lt;&lt; endl
+         &lt;&lt; endl;
+  }
+}
+  </pre>
+
+  <p>This code shows common patterns of accessing elements and attributes
+     with different cardinality classes. For the sequence element
+     (<code>person</code> in <code>people_t</code>) we first obtain a
+     reference to the container and then iterate over individual
+     records. The values of elements and attributes with the
+     <em>one</em> cardinality class (<code>first-name</code>,
+     <code>last-name</code>, <code>gender</code>, <code>age</code>,
+     and <code>id</code>) can be obtained directly by calling the
+     corresponding accessor functions. For the optional element
+     <code>middle-name</code> we first check if the value is present
+     and only then call <code>get()</code> to retrieve it.</p>
+
+  <p>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 (<code>ps</code> and <code>p</code> 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.</p>
+
+  <p>If we run the above application on our sample
+     <code>people.xml</code>, the output looks as follows:</p>
+
+  <pre class="terminal">
+name:   John Doe
+gender: male
+age:    32
+id:     1
+
+name:   Jane Mary Doe
+gender: female
+age:    28
+id:     2
+  </pre>
+
+
+  <h2><a name="4.3">4.3 Modifying the Object Model</a></h2>
+
+  <p>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
+     <code>people.xml</code> file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr&lt;people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people_t::person_sequence&amp; 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&amp; john (ps[0]);
+  person_t&amp; 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);
+}
+  </pre>
+
+  <p>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 <code>middle-name</code> element as well
+     as clear its value. Finally the example adds a copy of the
+     John Doe record to the <code>person</code> element sequence.</p>
+
+  <p>Note that in this case using references for the <code>ps</code>,
+     <code>john</code>, and <code>jane</code> 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.</p>
+
+  <p>If we run the above application on our sample <code>people.xml</code>,
+     the output looks as follows:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>33&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>29&lt;/age>
+  &lt;/person>
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>33&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+
+  <h2><a name="4.4">4.4 Creating the Object Model from Scratch</a></h2>
+
+  <p>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 <code>people.xml</code>
+     file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people_t ppl;
+  people_t::person_sequence&amp; 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&amp; 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);
+}
+  </pre>
+
+  <p>The only new part in the above application is the calls
+     to the <code>people_t</code> and <code>person_t</code>
+     constructors. As a general rule, for each C++ class
+     XSD generates a constructor with initializers
+     for each element and attribute belonging to the <em>one</em>
+     cardinality class. For our vocabulary, the following
+     constructors are generated:</p>
+
+  <pre class="c++">
+class person_t
+{
+  person_t (const first_name_type&amp;,
+            const last_name_type&amp;,
+            const gender_type&amp;,
+            const age_type&amp;,
+            const id_type&amp;);
+};
+
+class people_t
+{
+  people_t ();
+};
+  </pre>
+
+  <p>Note also that we set the <code>middle-name</code> element
+     on the Jane Doe record by obtaining a reference to that record
+     in the object model and setting the <code>middle-name</code>
+     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:</p>
+
+  <pre class="c++">
+// 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);
+  </pre>
+
+  <p>We can also go one step further to reduce copying and improve
+     the performance of our application by using the non-copying
+    <code>push_back()</code> function which assumes ownership
+     of the passed objects:</p>
+
+  <pre class="c++">
+// Add the Jane Doe record. C++11 version
+//
+unique_ptr&lt;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&lt;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
+  </pre>
+
+  <p>For more information on the non-copying modifier functions refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8">Section
+     2.8, "Mapping for Local Elements and Attributes"</a> in the C++/Tree Mapping
+     User Manual. The above application produces the following output:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+  <h2><a name="4.5">4.5 Mapping for the Built-in XML Schema Types</a></h2>
+
+  <p>Our person record vocabulary uses several built-in XML Schema
+     types: <code>string</code>, <code>short</code>, and
+     <code>unsignedInt</code>. 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 <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.5">Section
+     2.5, "Mapping for Built-in Data Types"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>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 <code>xml_schema</code> (this mapping can be altered
+     with the <code>--namespace-map</code> option). The following table
+     summarizes the mapping of XML Schema built-in types to C++ types:</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Alias in the <code>xml_schema</code> namespace</th>
+      <th>C++ type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string</code></td>
+      <td>type derived from <code>string</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token</code></td>
+      <td>type&nbsp;derived&nbsp;from&nbsp;<code>normalized_string</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens</code></td>
+      <td>type derived from <code>sequence&lt;nmtoken></code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname</code></td>
+      <td><code>xml_schema::qname</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs</code></td>
+      <td>type derived from <code>sequence&lt;idref></code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary</code></td>
+      <td><code>xml_schema::base64_binary</code></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary</code></td>
+      <td><code>xml_schema::hex_binary</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date</code></td>
+      <td><code>xml_schema::date</code></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time</code></td>
+      <td><code>xml_schema::date_time</code></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration</code></td>
+      <td><code>xml_schema::duration</code></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday</code></td>
+      <td><code>xml_schema::gday</code></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth</code></td>
+      <td><code>xml_schema::gmonth</code></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day</code></td>
+      <td><code>xml_schema::gmonth_day</code></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear</code></td>
+      <td><code>xml_schema::gyear</code></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month</code></td>
+      <td><code>xml_schema::gyear_month</code></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time</code></td>
+      <td><code>xml_schema::time</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">entity types</th>
+    </tr>
+    <tr>
+      <td><code>ENTITY</code></td>
+      <td><code>entity</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>ENTITIES</code></td>
+      <td><code>entities</code></td>
+      <td>type derived from <code>sequence&lt;entity></code></td>
+    </tr>
+  </table>
+
+  <p>As you can see from the table above a number of built-in
+     XML Schema types are mapped to fundamental C++ types such
+     as <code>int</code> or <code>bool</code>. All string-based
+     XML Schema types are mapped to C++ types that are derived
+     from either <code>std::string</code> or
+     <code>std::wstring</code>, depending on the character
+     type selected. For access and modification purposes these
+     types can be treated as <code>std::string</code>. A number
+     of built-in types, such as <code>qname</code>, 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.5">Section
+     2.5, "Mapping for Built-in Data Types"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+
+  <!-- Chapater 5 -->
+
+
+  <h1><a name="5">5 Parsing</a></h1>
+
+  <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.</p>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.9">Section
+     2.9, "Mapping for Global Elements"</a> in the C++/Tree Mapping User
+     Manual.</p>
+
+
+  <p>In this section we will discuss the most commonly used versions of
+     the parsing functions. For a comprehensive description of parsing
+     refer to <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3">Chapter
+     3, "Parsing"</a> in the C++/Tree Mapping User Manual. For the <code>people</code>
+     global element from our person record vocabulary, we will concentrate
+     on the following three parsing functions:</p>
+
+  <pre class="c++">
+std::[unique|auto]_ptr&lt;people_t>
+people (const std::string&amp; uri,
+	xml_schema::flags f = 0,
+	const xml_schema::properties&amp; p = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;people_t>
+people (std::istream&amp; is,
+        xml_schema::flags f = 0,
+        const xml_schema::properties&amp; p = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;people_t>
+people (std::istream&amp; is,
+        const std::string&amp; resource_id,
+        xml_schema::flags f = 0,
+        const xml_schema::properties&amp; p = ::xml_schema::properties ());
+  </pre>
+
+  <p>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.</p>
+
+  <p>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 <a href="#5.1">Section 5.1, "XML Schema
+     Validation and Searching"</a> below. All three functions return
+     the object model as either <code>std::unique_ptr</code> (C++11) or
+     <code>std::auto_ptr</code> (C++98), depending on the C++ standard
+     selected (<code>--std</code> XSD compiler option). The following
+     example shows how we can use the above parsing functions:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+// Parse a local file or URI.
+//
+unique_ptr&lt;people_t> p1 (people ("people.xml"));
+unique_ptr&lt;people_t> p2 (people ("http://example.com/people.xml"));
+
+// Parse a local file via ifstream.
+//
+std::ifstream ifs ("people.xml");
+unique_ptr&lt;people_t> p3 (people (ifs, "people.xml"));
+
+// Parse an XML string.
+//
+std::string str ("..."); // XML in a string.
+std::istringstream iss (str);
+unique_ptr&lt;people_t> p4 (people (iss));
+  </pre>
+
+
+  <h2><a name="5.1">5.1 XML Schema Validation and Searching</a></h2>
+
+  <p>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 <code>xml_schema::flags::dont_validate</code>
+     flag to the parsing functions, for example:</p>
+
+  <pre class="c++">
+unique_ptr&lt;people_t> p (
+  people ("people.xml", xml_schema::flags::dont_validate));
+  </pre>
+
+  <p>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).</p>
+
+  <p>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 <code>schemaLocation</code> or
+     <code>noNamespaceSchemaLocation</code> attributes, for example:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>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 <code>http://</code>, <code>file://</code>, 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.</p>
+
+  <p>Another method of providing the schema location information
+     is via the <code>xml_schema::properties</code> argument, as
+     shown in the following example:</p>
+
+  <pre class="c++">
+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&lt;people_t> p (people ("people.xml", 0, props));
+  </pre>
+
+  <p>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 <code>file://</code> URI. The following
+     example shows how to use schemas that reside in the current
+     working directory:</p>
+
+  <pre class="c++">
+#include &lt;unistd.h> // getcwd
+#include &lt;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&lt;people_t> p (people ("people.xml", 0, props));
+  </pre>
+
+  <p>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 <code>caching</code> example in the
+     <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> 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 <code>embedded</code> example in the <code>cxx/tree/</code>
+     directory in the <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <p>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 <code>noNamespaceSchemaLocation</code>
+     attribute in <code>people.xml</code> from the previous chapter,
+     then we will get the following diagnostics if we try to parse
+     this file with validation enabled:</p>
+
+  <pre class="terminal">
+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'
+  </pre>
+
+  <h2><a name="5.2">5.2 Error Handling</a></h2>
+
+  <p>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 <code>xml_schema::exception</code>
+     which in turn derives from <code>std::exception</code>. The easiest
+     way to uniformly handle all possible C++/Tree exceptions and print
+     detailed information about the error is to catch and print
+     <code>xml_schema::exception</code>, as shown in the following
+     example:</p>
+
+  <pre class="c++">
+try
+{
+  unique_ptr&lt;people_t> p (people ("people.xml"));
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>Each individual C++/Tree exception also allows you to obtain
+     error details programmatically. For example, the
+     <code>xml_schema::parsing</code> 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3.3">Section
+     3.3, "Error Handling"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>Note that if you are parsing <code>std::istream</code> 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:</p>
+
+  <pre class="c++">
+std::ifstream ifs ("people.xml");
+
+if (ifs.fail ())
+{
+  cerr &lt;&lt; "people.xml: unable to open" &lt;&lt; endl;
+  return 1;
+}
+
+unique_ptr&lt;people_t> p (people (ifs, "people.xml"));
+
+if (ifs.fail ())
+{
+  cerr &lt;&lt; "people.xml: read error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions as
+     shown below:</p>
+
+  <pre class="c++">
+try
+{
+  std::ifstream ifs;
+  ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+  ifs.open ("people.xml");
+
+  unique_ptr&lt;people_t> p (people (ifs, "people.xml"));
+}
+catch (const std::ifstream::failure&amp;)
+{
+  cerr &lt;&lt; "people.xml: unable to open or read error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+
+  <!-- Chapater 6 -->
+
+
+  <h1><a name="6">6 Serialization</a></h1>
+
+  <p>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.</p>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.9">Section
+     2.9, "Mapping for Global Elements"</a> in the C++/Tree Mapping User
+     Manual.</p>
+
+
+  <p>In this section we will discuss the most commonly
+     used version of serialization functions. For a comprehensive description
+     of serialization refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4">Chapter
+     4, "Serialization"</a> in the C++/Tree Mapping User Manual. For the
+     <code>people</code> global element from our person record vocabulary,
+     we will concentrate on the following serialization function:</p>
+
+  <pre class="c++">
+void
+people (std::ostream&amp; os,
+        const people_t&amp; x,
+        const xml_schema::namespace_infomap&amp; map =
+          xml_schema::namespace_infomap (),
+        const std::string&amp; encoding = "UTF-8",
+        xml_schema::flags f = 0);
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="c++">
+people_t&amp; 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 ());
+  </pre>
+
+
+  <h2><a name="6.1">6.1 Namespace and Schema Information</a></h2>
+
+  <p>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 <code>name</code> variable of the
+     map value. You can also assign an optional schema location for
+     this namespace in the <code>schema</code> 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:</p>
+
+  <pre class="c++">
+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";
+  </pre>
+
+  <p>Results in the following XML document:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>The empty namespace indicates that the vocabulary has no target
+     namespace. For example, the following map results in only the
+     <code>noNamespaceSchemaLocation</code> attribute being added:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].name = "";
+map[""].schema = "example.xsd";
+  </pre>
+
+  <h2><a name="6.2">6.2 Error Handling</a></h2>
+
+  <p>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
+     <code>xml_schema::exception</code>:</p>
+
+ <pre class="c++">
+try
+{
+  people_t&amp; p = ...
+
+  xml_schema::namespace_infomap map;
+  map[""].schema = "people.xsd";
+
+  people (std::cout, p, map));
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>The most commonly encountered serialization exception is
+     <code>xml_schema::serialization</code>. 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4.4">Section
+     4.4, "Error Handling"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>Note that if you are serializing to <code>std::ostream</code> 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:</p>
+
+  <pre class="c++">
+std::ofstream ofs ("people.xml");
+
+if (ofs.fail ())
+{
+  cerr &lt;&lt; "people.xml: unable to open" &lt;&lt; endl;
+  return 1;
+}
+
+people (ofs, p, map));
+
+if (ofs.fail ())
+{
+  cerr &lt;&lt; "people.xml: write error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions as
+     shown below:</p>
+
+  <pre class="c++">
+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&amp;)
+{
+  cerr &lt;&lt; "people.xml: unable to open or write error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  </div>
+</div>
+
+</body>
+</html>
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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Tree Mapping Getting Started Guide</title>
+
+  <meta name="copyright" content="&#169; @copyright@"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,parsing,serialization,validation"/>
+  <meta name="description" content="C++/Tree Mapping Getting Started Guide"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+    line-height: 1.2em;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 140%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage .title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+  }
+
+  #titlepage #first-title {
+    padding: 1em 0 0.4em 0;
+  }
+
+  #titlepage #second-title {
+    padding: 0.4em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+  div.img {
+    text-align: center;
+    padding: 2em 0 2em 0;
+  }
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div class="title" id="first-title">C++/Tree Mapping</div>
+    <div class="title" id="second-title">Getting Started Guide</div>
+
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-tree-guide.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-tree-guide.ps">PostScript</a>.</p>
+
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+          <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a>
+        <table class="toc">
+          <tr><th>1.1</th><td><a href="#1.1">Mapping Overview</a></td></tr>
+          <tr><th>1.2</th><td><a href="#1.2">Benefits</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">Hello World Example</a>
+        <table class="toc">
+          <tr><th>2.1</th><td><a href="#2.1">Writing XML Document and Schema</a></td></tr>
+          <tr><th>2.2</th><td><a href="#2.2">Translating Schema to C++</a></td></tr>
+          <tr><th>2.3</th><td><a href="#2.3">Implementing Application Logic</a></td></tr>
+          <tr><th>2.4</th><td><a href="#2.4">Compiling and Running</a></td></tr>
+	  <tr><th>2.5</th><td><a href="#2.5">Adding Serialization</a></td></tr>
+	  <tr><th>2.6</th><td><a href="#2.6">Selecting Naming Convention</a></td></tr>
+	  <tr><th>2.7</th><td><a href="#2.7">Generating Documentation</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Overall Mapping Configuration</a>
+        <table class="toc">
+	  <tr><th>3.1</th><td><a href="#3.1">C++ Standard</a></td></tr>
+          <tr><th>3.2</th><td><a href="#3.2">Character Type and Encoding</a></td></tr>
+          <tr><th>3.3</th><td><a href="#3.3">Support for Polymorphism </a></td></tr>
+          <tr><th>3.4</th><td><a href="#3.4">Namespace Mapping</a></td></tr>
+          <tr><th>3.5</th><td><a href="#3.5">Thread Safety</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Working with Object Models</a>
+        <table class="toc">
+          <tr><th>4.1</th><td><a href="#4.1">Attribute and Element Cardinalities</a></td></tr>
+          <tr><th>4.2</th><td><a href="#4.2">Accessing the Object Model</a></td></tr>
+          <tr><th>4.3</th><td><a href="#4.3">Modifying the Object Model</a></td></tr>
+          <tr><th>4.4</th><td><a href="#4.4">Creating the Object Model from Scratch</a></td></tr>
+	  <tr><th>4.5</th><td><a href="#4.5">Mapping for the Built-in XML Schema Types</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Parsing</a>
+        <table class="toc">
+          <tr><th>5.1</th><td><a href="#5.1">XML Schema Validation and Searching</a></td></tr>
+          <tr><th>5.2</th><td><a href="#5.2">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>6</th><td><a href="#6">Serialization</a>
+        <table class="toc">
+          <tr><th>6.1</th><td><a href="#6.1">Namespace and Schema Information</a></td></tr>
+          <tr><th>6.2</th><td><a href="#6.2">Error Handling</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/">C++/Tree
+     Mapping User Manual</a>.</p>
+
+  <p>Prior experience with XML and C++ is required to understand this
+     document. Basic understanding of XML Schema is advantageous but
+     not expected or required.
+  </p>
+
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this guide, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/">C++/Tree
+        Mapping User Manual</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+        Mapping Customization Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree
+        Mapping Frequently Asked Questions (FAQ)</a></li>
+
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/tree/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is the place to ask technical questions about XSD and the C++/Parser mapping.
+        Furthermore, the <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+  </ul>
+
+  <!-- Introduction -->
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.
+  </p>
+
+  <h2><a name="1.1">1.1 Mapping Overview</a></h2>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="1.2">1.2 Benefits</a></h2>
+
+  <p>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:
+  </p>
+
+  <ul class="list">
+    <li>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.</li>
+
+    <li>String-based flow control defers error detection to runtime.
+        It also reduces code readability and maintainability.</li>
+
+    <li>Lack of type safety because the data is represented as text.</li>
+
+    <li>Resulting applications are hard to debug, change, and
+        maintain.</li>
+  </ul>
+
+  <p>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:</p>
+
+  <ul class="list">
+    <li><b>Ease of use.</b> 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.</li>
+
+    <li><b>Natural representation.</b> The object representation allows
+         you to access the XML data using your domain vocabulary instead
+         of generic elements, attributes, and text.</li>
+
+    <li><b>Concise code.</b> With the object representation the
+        application implementation is simpler and thus easier
+        to read and understand.</li>
+
+    <li><b>Safety.</b> 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.</li>
+
+    <li><b>Maintainability.</b> 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.</li>
+
+    <li><b>Compatibility.</b> 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.</li>
+
+    <li><b>Efficiency.</b> 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.</li>
+  </ul>
+
+
+  <!-- Hello World Parser -->
+
+
+  <h1><a name="2">2 Hello World Example</a></h1>
+
+  <p>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 <code>hello</code> example which can be found in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> package.</p>
+
+  <h2><a name="2.1">2.1 Writing XML Document and Schema</a></h2>
+
+  <p>First, we need to get an idea about the structure
+     of the XML documents we are going to process. Our
+     <code>hello.xml</code>, for example, could look like this:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello>
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>Then we can write a description of the above XML in the
+     XML Schema language and save it into <code>hello.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="greeting" type="xs:string"/>
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello_t"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>Even if you are not familiar with XML Schema, it
+     should be easy to connect declarations in <code>hello.xsd</code>
+     to elements in <code>hello.xml</code>. The <code>hello_t</code> type
+     is defined as a sequence of the nested <code>greeting</code> and
+     <code>name</code> 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 <code>name</code>
+     element has its <code>maxOccurs</code> property set to
+     <code>unbounded</code> which means it can appear multiple times
+     in an XML document. Finally, the globally-defined <code>hello</code>
+     element prescribes the root element for our vocabulary. For an
+     easily-approachable introduction to XML Schema refer to
+     <a href="http://www.w3.org/TR/xmlschema-0/">XML Schema Part 0:
+     Primer</a>.</p>
+
+  <p>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 <code>hello.xml</code> to include the
+     information about the schema so that XML parsers can validate
+     our document:</p>
+
+      <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hello&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+
+&lt;/hello>
+      </pre>
+
+
+  <p>The next step is to compile the schema to generate the object
+     model and parsing functions.</p>
+
+  <h2><a name="2.2">2.2 Translating Schema to C++</a></h2>
+
+  <p>Now we are ready to translate our <code>hello.xsd</code> to C++.
+     To do this we invoke the XSD compiler from a terminal (UNIX) or
+     a command prompt (Windows):
+  </p>
+
+  <pre class="terminal">
+$ xsd cxx-tree hello.xsd
+  </pre>
+
+  <p>The XSD compiler produces two C++ files: <code>hello.hxx</code> and
+     <code>hello.cxx</code>. The following code fragment is taken from
+     <code>hello.hxx</code>; it should give you an idea about what gets
+     generated:
+  </p>
+
+  <pre class="c++">
+class hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::string greeting_type;
+
+  const greeting_type&amp;
+  greeting () const;
+
+  greeting_type&amp;
+  greeting ();
+
+  void
+  greeting (const greeting_type&amp; x);
+
+  // name
+  //
+  typedef xml_schema::string name_type;
+  typedef xsd::sequence&lt;name_type> name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&amp;
+  name () const;
+
+  name_sequence&amp;
+  name ();
+
+  void
+  name (const name_sequence&amp; s);
+
+  // Constructor.
+  //
+  hello_t (const greeting_type&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;hello_t>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>The <code>hello_t</code> C++ class corresponds to the
+     <code>hello_t</code> 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
+     <code>hello_t</code> class. Note that the type definitions
+     and member functions for the <code>greeting</code> and
+     <code>name</code> elements are different because of the
+     cardinality differences between these two elements
+     (<code>greeting</code> is a required single element and
+     <code>name</code> is a sequence of elements).</p>
+
+  <p>The <code>xml_schema::string</code> type used in the type
+     definitions is a C++ class provided by the XSD runtime
+     that corresponds to built-in XML Schema type
+     <code>string</code>. The <code>xml_schema::string</code>
+     is based on <code>std::string</code> and can be used as
+     such. Similarly, the <code>sequence</code> class template
+     that is used in the <code>name_sequence</code> type
+     definition is based on and has the same interface as
+     <code>std::vector</code>. The mapping between the built-in
+     XML Schema types and C++ types is described in more detail in
+     <a href="#4.5">Section 4.5, "Mapping for the Built-in XML Schema
+     Types"</a>. The <code>hello_t</code> class also includes a
+     constructor with an initializer for the required
+     <code>greeting</code> element as its argument.</p>
+
+  <p>The <code>hello</code> overloaded global functions correspond
+     to the <code>hello</code> 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 <code>--root-element-*</code> 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 <code>std::unique_ptr</code>
+     as shown above. For C++98 it is <code>std::auto_ptr</code>.
+     For example, if we modify our XSD compiler invocation to
+     select C++98:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --std c++98 hello.xsd
+  </pre>
+
+  <p>Then the parsing function signatures will become:</p>
+
+  <pre class="c++">
+std::auto_ptr&lt;hello_t>
+hello (const std::string&amp; uri);
+
+std::auto_ptr&lt;hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>For more information on parsing functions see <a href="#5">Chapter 5,
+     "Parsing"</a>.</p>
+
+  <h2><a name="2.3">2.3 Implementing Application Logic</a></h2>
+
+  <p>At this point we have all the parts we need to do something useful
+     with the information stored in our XML document:
+  </p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr&lt;hello_t> h (hello (argv[1]));
+
+    for (hello_t::name_const_iterator i (h->name ().begin ());
+         i != h->name ().end ();
+         ++i)
+    {
+      cerr &lt;&lt; h->greeting () &lt;&lt; ", " &lt;&lt; *i &lt;&lt; "!" &lt;&lt; endl;
+    }
+  }
+  catch (const xml_schema::exception&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>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 <code>xml_schema::exception</code>
+     exception in case something goes wrong. This exception
+     is the root of the exception hierarchy used by the
+     XSD-generated code.
+  </p>
+
+
+  <h2><a name="2.4">2.4 Compiling and Running</a></h2>
+
+  <p>After saving our application from the previous section in
+     <code>driver.cxx</code>, 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:
+  </p>
+
+  <pre class="terminal">
+$ 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!
+  </pre>
+
+  <p>Here <code>.../libxsd</code> represents the path to the
+     <a href="https://cppget.org/libxsd">libxsd</a> 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.</p>
+
+  <h2><a name="2.5">2.5 Adding Serialization</a></h2>
+
+  <p>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 <code>--generate-serialization</code> options:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --generate-serialization hello.xsd
+  </pre>
+
+  <p>If we now examine the generated <code>hello.hxx</code> file,
+     we will find a set of overloaded serialization functions,
+     including the following version:</p>
+
+  <pre class="c++">
+void
+hello (std::ostream&amp;,
+       const hello_t&amp;,
+       const xml_schema::namespace_infomap&amp; =
+         xml_schema::namespace_infomap ());
+
+  </pre>
+
+  <p>Just like with parsing functions, XSD generates serialization
+     functions for each global element unless instructed otherwise
+     with one of the <code>--root-element-*</code> options. For more
+     information on serialization functions see <a href="#6">Chapter 6,
+     "Serialization"</a>.</p>
+
+  <p>We first examine an application that modifies an existing
+     object model and serializes it back to XML:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr&lt;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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>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.</p>
+
+  <p>The first argument we pass to the serialization function is
+     <code>cout</code> 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 <code>std::ofstream</code> or <code>std::ostringstream</code>
+     and passing it instead of <code>cout</code>. 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 (<code>p1</code>,
+     <code>p2</code>, etc.) will be automatically assigned to XML namespaces
+     and no schema information will be added to the resulting document
+     (see <a href="#6">Chapter 6, "Serialization"</a> for details).
+     In our case, the prefix (map key) and namespace name are empty
+     because our vocabulary does not use XML namespaces.</p>
+
+  <p>If we now compile and run this application we will see the
+     output as shown in the following listing:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hi&lt;/greeting>
+
+  &lt;name>sun&lt;/name>
+  &lt;name>moon&lt;/name>
+  &lt;name>world&lt;/name>
+  &lt;name>mars&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <p>We can also create and serialize an object model from scratch
+     as shown in the following example:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include &lt;fstream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello_t h ("Hi");
+
+    hello_t::name_sequence&amp; 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&amp; e)
+  {
+    cerr &lt;&lt; e &lt;&lt; endl;
+    return 1;
+  }
+}
+  </pre>
+
+  <p>In this example we used the generated constructor to create
+     an instance of type <code>hello_t</code>. 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:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  &lt;greeting>Hi&lt;/greeting>
+
+  &lt;name>Jane&lt;/name>
+  &lt;name>John&lt;/name>
+
+&lt;/hello>
+  </pre>
+
+  <h2><a name="2.6">2.6 Selecting Naming Convention</a></h2>
+
+  <p>By default XSD uses the so-called K&amp;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 <code>--type-naming</code> and
+     <code>--function-naming</code> options. You can also further
+     refine one of the predefined conventions or create a completely
+     custom naming scheme by using the  <code>--*-regex</code> options.</p>
+
+  <p>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&amp;R
+     convention for function names. Since K&amp;R is the default
+     convention for both type and function names, we only need to
+     change the type naming scheme:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --type-naming ucc hello.xsd
+  </pre>
+
+  <p>The <code>ucc</code> argument to the <code>--type-naming</code>
+     options stands for upper-camel-case. If we now examine the
+     generated <code>hello.hxx</code>, we will see the following
+     changes compared to the declarations shown in the previous
+     sections:</p>
+
+  <pre class="c++">
+class Hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&amp;
+  greeting () const;
+
+  GreetingType&amp;
+  greeting ();
+
+  void
+  greeting (const GreetingType&amp; x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence&lt;NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&amp;
+  name () const;
+
+  NameSequence&amp;
+  name ();
+
+  void
+  name (const NameSequence&amp; s);
+
+  // Constructor.
+  //
+  Hello_t (const GreetingType&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;Hello_t>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;Hello_t>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>Notice that the type names in the <code>xml_schema</code> namespace,
+     for example <code>xml_schema::String</code>, now also use the
+     upper-camel-case naming convention. The only thing that we may
+     be unhappy about in the above code is the <code>_t</code>
+     suffix in <code>Hello_t</code>. If we are not in a position
+     to change the schema, we can <em>touch-up</em> the <code>ucc</code>
+     convention with a custom translation rule using the
+     <code>--type-regex</code> option:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --type-naming ucc --type-regex '/ (.+)_t/\u$1/' hello.xsd
+  </pre>
+
+  <p>This results in the following changes to the generated code:</p>
+
+  <pre class="c++">
+class Hello
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&amp;
+  greeting () const;
+
+  GreetingType&amp;
+  greeting ();
+
+  void
+  greeting (const GreetingType&amp; x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence&lt;NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&amp;
+  name () const;
+
+  NameSequence&amp;
+  name ();
+
+  void
+  name (const NameSequence&amp; s);
+
+  // Constructor.
+  //
+  Hello (const GreetingType&amp;);
+
+  ...
+
+};
+
+std::unique_ptr&lt;Hello>
+hello (const std::string&amp; uri);
+
+std::unique_ptr&lt;Hello>
+hello (std::istream&amp;);
+  </pre>
+
+  <p>For more detailed information on the <code>--type-naming</code>,
+     <code>--function-naming</code>, <code>--type-regex</code>, and
+     other <code>--*-regex</code> options refer to the NAMING
+     CONVENTION section in the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+  <h2><a name="2.7">2.7 Generating Documentation</a></h2>
+
+  <p>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 <a href="http://www.doxygen.org">Doxygen</a>
+     documentation system to extract this information and produce
+     documentation in various formats.
+  </p>
+
+  <p>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 <code>hello.xsd</code> with added documentation:</p>
+
+  <pre class="xml">
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="hello_t">
+
+    &lt;xs:annotation>
+      &lt;xs:documentation>
+        The hello_t type consists of a greeting phrase and a
+        collection of names to which this greeting applies.
+      &lt;/xs:documentation>
+    &lt;/xs:annotation>
+
+    &lt;xs:sequence>
+
+      &lt;xs:element name="greeting" type="xs:string">
+        &lt;xs:annotation>
+          &lt;xs:documentation>
+            The greeting element contains the greeting phrase
+            for this hello object.
+          &lt;/xs:documentation>
+        &lt;/xs:annotation>
+      &lt;/xs:element>
+
+      &lt;xs:element name="name" type="xs:string" maxOccurs="unbounded">
+        &lt;xs:annotation>
+          &lt;xs:documentation>
+            The name elements contains names to be greeted.
+          &lt;/xs:documentation>
+        &lt;/xs:annotation>
+      &lt;/xs:element>
+
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="hello" type="hello_t">
+    &lt;xs:annotation>
+      &lt;xs:documentation>
+        The hello element is a root of the Hello XML vocabulary.
+        Every conforming document should start with this element.
+      &lt;/xs:documentation>
+    &lt;/xs:annotation>
+  &lt;/xs:element>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>The first step in obtaining the documentation is to recompile
+     our schema with the <code>--generate-doxygen</code> option:</p>
+
+  <pre class="terminal">
+$ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd
+  </pre>
+
+  <p>Now the generated <code>hello.hxx</code> 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:</p>
+
+  <pre class="terminal">
+$ doxygen -g hello.doxygen
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="terminal">
+$ doxygen hello.doxygen
+  </pre>
+
+  <p>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 <code>hello_t</code> class which
+     is generated by the XSD compiler and the <code>xml_schema::string</code>
+     class which is defined in the XSD runtime library. The Doxygen
+     configuration file for the XSD runtime is provided with the XSD
+     distribution.</p>
+
+  <p>You can view the result of the steps described in this section
+     on the <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/hello/html/annotated.html">Hello
+     Example Documentation</a> page.</p>
+
+  <!-- Chapater 3 -->
+
+
+  <h1><a name="3">3 Overall Mapping Configuration</a></h1>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.
+  </p>
+
+  <h2><a name="3.1">3.1 C++ Standard</a></h2>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h2><a name="3.2">3.2 Character Type and Encoding</a></h2>
+
+  <p>The C++/Tree mapping has built-in support for two character types:
+    <code>char</code> and <code>wchar_t</code>. You can select the
+    character type with the <code>--char-type</code> command line
+    option. The default character type is <code>char</code>. 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.</p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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 <code>--char-encoding</code> command
+     line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <p>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.</p>
+
+  <h2><a name="3.3">3.3 Support for Polymorphism</a></h2>
+
+  <p>By default XSD generates non-polymorphic code. If your vocabulary
+     uses XML Schema polymorphism in the form of <code>xsi:type</code>
+     and/or substitution groups, then you will need to compile
+     your schemas with the <code>--generate-polymorphic</code> option
+     to produce polymorphism-aware code. For more information on
+     working with polymorphic object models, refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.11">Section 2.11,
+     "Mapping for <code>xsi:type</code> and Substitution Groups"</a> in
+     the C++/Tree Mapping User Manual.</p>
+
+  <h2><a name="3.4">3.4 Namespace Mapping</a></h2>
+
+  <p>XSD maps XML namespaces specified in the <code>targetNamespace</code>
+     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 <code>'/'</code> as the name
+     separator.</p>
+
+  <p>The default mapping of namespace URIs to C++ namespaces
+     can be altered using the <code>--namespace-map</code> and
+     <code>--namespace-regex</code> compiler options. For example,
+     to map namespace URI <code>https://www.codesynthesis.com/my</code> to
+     C++ namespace <code>cs::my</code>, we can use the following option:</p>
+
+  <pre class="terminal">
+--namespace-map https://www.codesynthesis.com/my=cs::my
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="terminal">
+--namespace-map =cs
+  </pre>
+
+  <h2><a name="3.5">3.5 Thread Safety</a></h2>
+
+  <p>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
+     <a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+     Mapping Customization Guide</a>.</p>
+
+  <p>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 <code>main()</code> when
+     there are no threads yet/anymore:</p>
+
+  <pre class="c++">
+#include &lt;xercesc/util/PlatformUtils.hpp>
+
+int
+main ()
+{
+  xercesc::XMLPlatformUtils::Initialize ();
+
+  {
+    // Start/terminate threads and parse/serialize here.
+  }
+
+  xercesc::XMLPlatformUtils::Terminate ();
+}
+  </pre>
+
+  <p>Because you initialize the Xerces-C++ runtime yourself you should
+     also pass the <code>xml_schema::flags::dont_initialize</code> flag
+     to parsing and serialization functions. See <a href="#5">Chapter 5,
+     "Parsing"</a> and <a href="#6">Chapter 6, "Serialization"</a> for
+     more information.</p>
+
+
+  <!-- Chapater 4 -->
+
+
+  <h1><a name="4">4 Working with Object Models</a></h1>
+
+  <p>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.</p>
+
+  <p>In this and subsequent chapters we will use the following schema
+     that describes a collection of person records. We save it in
+     <code>people.xsd</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:simpleType name="gender_t">
+    &lt;xs:restriction base="xs:string">
+      &lt;xs:enumeration value="male"/>
+      &lt;xs:enumeration value="female"/>
+    &lt;/xs:restriction>
+  &lt;/xs:simpleType>
+
+  &lt;xs:complexType name="person_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="first-name" type="xs:string"/>
+      &lt;xs:element name="middle-name" type="xs:string" minOccurs="0"/>
+      &lt;xs:element name="last-name" type="xs:string"/>
+      &lt;xs:element name="gender" type="gender_t"/>
+      &lt;xs:element name="age" type="xs:short"/>
+    &lt;/xs:sequence>
+    &lt;xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  &lt;/xs:complexType>
+
+  &lt;xs:complexType name="people_t">
+    &lt;xs:sequence>
+      &lt;xs:element name="person" type="person_t" maxOccurs="unbounded"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="people" type="people_t"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>A sample XML instance to go along with this schema is saved
+     in <code>people.xml</code>:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+  <p>Compiling <code>people.xsd</code> with the XSD compiler results
+     in three generated C++ classes: <code>gender_t</code>,
+     <code>person_t</code>, and <code>people_t</code>.
+     The <code>gender_t</code> class is modelled after the C++
+     <code>enum</code> type. Its definition is presented below:</p>
+
+  <pre class="c++">
+class gender_t: public xml_schema::string
+{
+public:
+  enum value
+  {
+    male,
+    female
+  };
+
+  gender_t (value);
+  gender_t (const xml_schema::string&amp;);
+
+  gender_t&amp;
+  operator= (value);
+
+  operator value () const;
+};
+  </pre>
+
+  <p>The following listing shows how we can use this type:</p>
+
+  <pre class="c++">
+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:
+  {
+    ...
+  }
+}
+  </pre>
+
+  <p>The other two classes will be examined in detail in the subsequent
+     sections.</p>
+
+  <h2><a name="4.1">4.1 Attribute and Element Cardinalities</a></h2>
+
+  <p>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:
+     <em>one</em>, <em>optional</em>, and <em>sequence</em>.</p>
+
+  <p>The <em>one</em> cardinality class covers all elements that should
+     occur exactly once as well as required attributes. In our
+     example, the <code>first-name</code>, <code>last-name</code>,
+     <code>gender</code>, and <code>age</code> elements as well as
+     the <code>id</code> 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
+     <code>gender</code> element in the <code>person_t</code> class:</p>
+
+  <pre class="c++">
+class person_t
+{
+  // gender
+  //
+  typedef gender_t gender_type;
+
+  const gender_type&amp;
+  gender () const;
+
+  gender_type&amp;
+  gender ();
+
+  void
+  gender (const gender_type&amp;);
+};
+  </pre>
+
+  <p>The <code>gender_type</code> 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.</p>
+
+  <p>The <em>optional</em> cardinality class covers all elements that
+     can occur zero or one time as well as optional attributes. In our
+     example, the <code>middle-name</code> 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 <code>person_t</code> class:</p>
+
+  <pre class="c++">
+class person_t
+{
+  // middle-name
+  //
+  typedef xml_schema::string middle_name_type;
+  typedef xsd::optional&lt;middle_name_type> middle_name_optional;
+
+  const middle_name_optional&amp;
+  middle_name () const;
+
+  middle_name_optional&amp;
+  middle_name ();
+
+  void
+  middle_name (const middle_name_type&amp;);
+
+  void
+  middle_name (const middle_name_optional&amp;);
+};
+  </pre>
+
+  <p>As with the <code>gender</code> element, <code>middle_name_type</code>
+     is an alias for the element's type. The <code>middle_name_optional</code>
+     type is a container for the element's optional value. It can be queried
+     for the presence of the value using the <code>present()</code> function.
+     The value itself can be retrieved using the <code>get()</code>
+     accessor and set using the <code>set()</code> modifier. The container
+     can be reverted to the value not present state with the call to the
+     <code>reset()</code> function. The following example shows how we
+     can use this container:</p>
+
+  <pre class="c++">
+person_t::middle_name_optional n ("John");
+
+if (n.present ())
+{
+  cout &lt;&lt; n.get () &lt;&lt; endl;
+}
+
+n.set ("Jane");
+n.reset ();
+  </pre>
+
+
+  <p>Unlike the <em>one</em> cardinality class, the accessor functions
+     for the <em>optional</em> 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.</p>
+
+  <p>Finally, the <em>sequence</em> cardinality class covers all elements
+     that can occur more than once. In our example, the
+     <code>person</code> element in the <code>people_t</code> 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 <code>people_t</code>
+     class:</p>
+
+  <pre class="c++">
+class people_t
+{
+  // person
+  //
+  typedef person_t person_type;
+  typedef xsd::sequence&lt;person_type> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&amp;
+  person () const;
+
+  person_sequence&amp;
+  person ();
+
+  void
+  person (const person_sequence&amp;);
+};
+  </pre>
+
+  <p>Identical to the other cardinality classes, <code>person_type</code>
+     is an alias for the element's type. The <code>person_sequence</code>
+     type is a sequence container for the element's values. It is based
+     on and has the same interface as <code>std::vector</code> and
+     therefore can be used in similar ways. The <code>person_iterator</code>
+     and <code>person_const_iterator</code> types are read-only
+     (constant) and read-write iterators for the <code>person_sequence</code>
+     container.</p>
+
+  <p>Similar to the <em>optional</em> cardinality class, the
+     accessor functions for the <em>sequence</em> class return
+     read-only (constant) and read-write references to the sequence
+     container. The modifier functions copies the entries from
+     the passed sequence.</p>
+
+  <p>C++/Tree is a "flattening" mapping in a sense that many levels of
+     nested compositors (<code>choice</code> and <code>sequence</code>),
+     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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8.4">Section
+     2.8.4, "Element Order"</a> in the C++/Tree Mapping User Manual.</p>
+
+  <p>For complex schemas with many levels of nested compositors
+     (<code>choice</code> and <code>sequence</code>) 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.</p>
+
+  <p>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.</p>
+
+  <h2><a name="4.2">4.2 Accessing the Object Model</a></h2>
+
+  <p>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 <code>people.xml</code> file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr&lt;people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records.
+  //
+  people_t::person_sequence&amp; ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    person_t&amp; p (*i);
+
+    // Print names: first-name and last-name are required elements,
+    // middle-name is optional.
+    //
+    cout &lt;&lt; "name:   " &lt;&lt; p.first_name () &lt;&lt; " ";
+
+    if (p.middle_name ().present ())
+      cout &lt;&lt; p.middle_name ().get () &lt;&lt; " ";
+
+    cout &lt;&lt; p.last_name () &lt;&lt; endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout &lt;&lt; "gender: " &lt;&lt; p.gender () &lt;&lt; endl
+         &lt;&lt; "age:    " &lt;&lt; p.age () &lt;&lt; endl
+         &lt;&lt; "id:     " &lt;&lt; p.id () &lt;&lt; endl
+         &lt;&lt; endl;
+  }
+}
+  </pre>
+
+  <p>This code shows common patterns of accessing elements and attributes
+     with different cardinality classes. For the sequence element
+     (<code>person</code> in <code>people_t</code>) we first obtain a
+     reference to the container and then iterate over individual
+     records. The values of elements and attributes with the
+     <em>one</em> cardinality class (<code>first-name</code>,
+     <code>last-name</code>, <code>gender</code>, <code>age</code>,
+     and <code>id</code>) can be obtained directly by calling the
+     corresponding accessor functions. For the optional element
+     <code>middle-name</code> we first check if the value is present
+     and only then call <code>get()</code> to retrieve it.</p>
+
+  <p>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 (<code>ps</code> and <code>p</code> 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.</p>
+
+  <p>If we run the above application on our sample
+     <code>people.xml</code>, the output looks as follows:</p>
+
+  <pre class="terminal">
+name:   John Doe
+gender: male
+age:    32
+id:     1
+
+name:   Jane Mary Doe
+gender: female
+age:    28
+id:     2
+  </pre>
+
+
+  <h2><a name="4.3">4.3 Modifying the Object Model</a></h2>
+
+  <p>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
+     <code>people.xml</code> file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr&lt;people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people_t::person_sequence&amp; 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&amp; john (ps[0]);
+  person_t&amp; 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);
+}
+  </pre>
+
+  <p>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 <code>middle-name</code> element as well
+     as clear its value. Finally the example adds a copy of the
+     John Doe record to the <code>person</code> element sequence.</p>
+
+  <p>Note that in this case using references for the <code>ps</code>,
+     <code>john</code>, and <code>jane</code> 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.</p>
+
+  <p>If we run the above application on our sample <code>people.xml</code>,
+     the output looks as follows:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0"?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>33&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>29&lt;/age>
+  &lt;/person>
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>33&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+
+  <h2><a name="4.4">4.4 Creating the Object Model from Scratch</a></h2>
+
+  <p>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 <code>people.xml</code>
+     file:</p>
+
+  <pre class="c++">
+#include &lt;iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people_t ppl;
+  people_t::person_sequence&amp; 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&amp; 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);
+}
+  </pre>
+
+  <p>The only new part in the above application is the calls
+     to the <code>people_t</code> and <code>person_t</code>
+     constructors. As a general rule, for each C++ class
+     XSD generates a constructor with initializers
+     for each element and attribute belonging to the <em>one</em>
+     cardinality class. For our vocabulary, the following
+     constructors are generated:</p>
+
+  <pre class="c++">
+class person_t
+{
+  person_t (const first_name_type&amp;,
+            const last_name_type&amp;,
+            const gender_type&amp;,
+            const age_type&amp;,
+            const id_type&amp;);
+};
+
+class people_t
+{
+  people_t ();
+};
+  </pre>
+
+  <p>Note also that we set the <code>middle-name</code> element
+     on the Jane Doe record by obtaining a reference to that record
+     in the object model and setting the <code>middle-name</code>
+     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:</p>
+
+  <pre class="c++">
+// 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);
+  </pre>
+
+  <p>We can also go one step further to reduce copying and improve
+     the performance of our application by using the non-copying
+    <code>push_back()</code> function which assumes ownership
+     of the passed objects:</p>
+
+  <pre class="c++">
+// Add the Jane Doe record. C++11 version
+//
+unique_ptr&lt;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&lt;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
+  </pre>
+
+  <p>For more information on the non-copying modifier functions refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8">Section
+     2.8, "Mapping for Local Elements and Attributes"</a> in the C++/Tree Mapping
+     User Manual. The above application produces the following output:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  &lt;person id="1">
+    &lt;first-name>John&lt;/first-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>male&lt;/gender>
+    &lt;age>32&lt;/age>
+  &lt;/person>
+
+  &lt;person id="2">
+    &lt;first-name>Jane&lt;/first-name>
+    &lt;middle-name>Mary&lt;/middle-name>
+    &lt;last-name>Doe&lt;/last-name>
+    &lt;gender>female&lt;/gender>
+    &lt;age>28&lt;/age>
+  &lt;/person>
+
+&lt;/people>
+  </pre>
+
+  <h2><a name="4.5">4.5 Mapping for the Built-in XML Schema Types</a></h2>
+
+  <p>Our person record vocabulary uses several built-in XML Schema
+     types: <code>string</code>, <code>short</code>, and
+     <code>unsignedInt</code>. 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 <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.5">Section
+     2.5, "Mapping for Built-in Data Types"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>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 <code>xml_schema</code> (this mapping can be altered
+     with the <code>--namespace-map</code> option). The following table
+     summarizes the mapping of XML Schema built-in types to C++ types:</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Alias in the <code>xml_schema</code> namespace</th>
+      <th>C++ type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string</code></td>
+      <td>type derived from <code>string</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token</code></td>
+      <td>type&nbsp;derived&nbsp;from&nbsp;<code>normalized_string</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens</code></td>
+      <td>type derived from <code>sequence&lt;nmtoken></code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname</code></td>
+      <td><code>xml_schema::qname</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs</code></td>
+      <td>type derived from <code>sequence&lt;idref></code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary</code></td>
+      <td><code>xml_schema::base64_binary</code></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary</code></td>
+      <td><code>xml_schema::hex_binary</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date</code></td>
+      <td><code>xml_schema::date</code></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time</code></td>
+      <td><code>xml_schema::date_time</code></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration</code></td>
+      <td><code>xml_schema::duration</code></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday</code></td>
+      <td><code>xml_schema::gday</code></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth</code></td>
+      <td><code>xml_schema::gmonth</code></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day</code></td>
+      <td><code>xml_schema::gmonth_day</code></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear</code></td>
+      <td><code>xml_schema::gyear</code></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month</code></td>
+      <td><code>xml_schema::gyear_month</code></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time</code></td>
+      <td><code>xml_schema::time</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">entity types</th>
+    </tr>
+    <tr>
+      <td><code>ENTITY</code></td>
+      <td><code>entity</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>ENTITIES</code></td>
+      <td><code>entities</code></td>
+      <td>type derived from <code>sequence&lt;entity></code></td>
+    </tr>
+  </table>
+
+  <p>As you can see from the table above a number of built-in
+     XML Schema types are mapped to fundamental C++ types such
+     as <code>int</code> or <code>bool</code>. All string-based
+     XML Schema types are mapped to C++ types that are derived
+     from either <code>std::string</code> or
+     <code>std::wstring</code>, depending on the character
+     type selected. For access and modification purposes these
+     types can be treated as <code>std::string</code>. A number
+     of built-in types, such as <code>qname</code>, 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.5">Section
+     2.5, "Mapping for Built-in Data Types"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+
+  <!-- Chapater 5 -->
+
+
+  <h1><a name="5">5 Parsing</a></h1>
+
+  <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.</p>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.9">Section
+     2.9, "Mapping for Global Elements"</a> in the C++/Tree Mapping User
+     Manual.</p>
+
+
+  <p>In this section we will discuss the most commonly used versions of
+     the parsing functions. For a comprehensive description of parsing
+     refer to <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3">Chapter
+     3, "Parsing"</a> in the C++/Tree Mapping User Manual. For the <code>people</code>
+     global element from our person record vocabulary, we will concentrate
+     on the following three parsing functions:</p>
+
+  <pre class="c++">
+std::[unique|auto]_ptr&lt;people_t>
+people (const std::string&amp; uri,
+	xml_schema::flags f = 0,
+	const xml_schema::properties&amp; p = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;people_t>
+people (std::istream&amp; is,
+        xml_schema::flags f = 0,
+        const xml_schema::properties&amp; p = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;people_t>
+people (std::istream&amp; is,
+        const std::string&amp; resource_id,
+        xml_schema::flags f = 0,
+        const xml_schema::properties&amp; p = ::xml_schema::properties ());
+  </pre>
+
+  <p>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.</p>
+
+  <p>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 <a href="#5.1">Section 5.1, "XML Schema
+     Validation and Searching"</a> below. All three functions return
+     the object model as either <code>std::unique_ptr</code> (C++11) or
+     <code>std::auto_ptr</code> (C++98), depending on the C++ standard
+     selected (<code>--std</code> XSD compiler option). The following
+     example shows how we can use the above parsing functions:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+// Parse a local file or URI.
+//
+unique_ptr&lt;people_t> p1 (people ("people.xml"));
+unique_ptr&lt;people_t> p2 (people ("http://example.com/people.xml"));
+
+// Parse a local file via ifstream.
+//
+std::ifstream ifs ("people.xml");
+unique_ptr&lt;people_t> p3 (people (ifs, "people.xml"));
+
+// Parse an XML string.
+//
+std::string str ("..."); // XML in a string.
+std::istringstream iss (str);
+unique_ptr&lt;people_t> p4 (people (iss));
+  </pre>
+
+
+  <h2><a name="5.1">5.1 XML Schema Validation and Searching</a></h2>
+
+  <p>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 <code>xml_schema::flags::dont_validate</code>
+     flag to the parsing functions, for example:</p>
+
+  <pre class="c++">
+unique_ptr&lt;people_t> p (
+  people ("people.xml", xml_schema::flags::dont_validate));
+  </pre>
+
+  <p>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).</p>
+
+  <p>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 <code>schemaLocation</code> or
+     <code>noNamespaceSchemaLocation</code> attributes, for example:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>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 <code>http://</code>, <code>file://</code>, 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.</p>
+
+  <p>Another method of providing the schema location information
+     is via the <code>xml_schema::properties</code> argument, as
+     shown in the following example:</p>
+
+  <pre class="c++">
+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&lt;people_t> p (people ("people.xml", 0, props));
+  </pre>
+
+  <p>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 <code>file://</code> URI. The following
+     example shows how to use schemas that reside in the current
+     working directory:</p>
+
+  <pre class="c++">
+#include &lt;unistd.h> // getcwd
+#include &lt;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&lt;people_t> p (people ("people.xml", 0, props));
+  </pre>
+
+  <p>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 <code>caching</code> example in the
+     <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a> 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 <code>embedded</code> example in the <code>cxx/tree/</code>
+     directory in the <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <p>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 <code>noNamespaceSchemaLocation</code>
+     attribute in <code>people.xml</code> from the previous chapter,
+     then we will get the following diagnostics if we try to parse
+     this file with validation enabled:</p>
+
+  <pre class="terminal">
+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'
+  </pre>
+
+  <h2><a name="5.2">5.2 Error Handling</a></h2>
+
+  <p>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 <code>xml_schema::exception</code>
+     which in turn derives from <code>std::exception</code>. The easiest
+     way to uniformly handle all possible C++/Tree exceptions and print
+     detailed information about the error is to catch and print
+     <code>xml_schema::exception</code>, as shown in the following
+     example:</p>
+
+  <pre class="c++">
+try
+{
+  unique_ptr&lt;people_t> p (people ("people.xml"));
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>Each individual C++/Tree exception also allows you to obtain
+     error details programmatically. For example, the
+     <code>xml_schema::parsing</code> 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3.3">Section
+     3.3, "Error Handling"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>Note that if you are parsing <code>std::istream</code> 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:</p>
+
+  <pre class="c++">
+std::ifstream ifs ("people.xml");
+
+if (ifs.fail ())
+{
+  cerr &lt;&lt; "people.xml: unable to open" &lt;&lt; endl;
+  return 1;
+}
+
+unique_ptr&lt;people_t> p (people (ifs, "people.xml"));
+
+if (ifs.fail ())
+{
+  cerr &lt;&lt; "people.xml: read error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions as
+     shown below:</p>
+
+  <pre class="c++">
+try
+{
+  std::ifstream ifs;
+  ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+  ifs.open ("people.xml");
+
+  unique_ptr&lt;people_t> p (people (ifs, "people.xml"));
+}
+catch (const std::ifstream::failure&amp;)
+{
+  cerr &lt;&lt; "people.xml: unable to open or read error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+
+  <!-- Chapater 6 -->
+
+
+  <h1><a name="6">6 Serialization</a></h1>
+
+  <p>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.</p>
+
+  <p>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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.9">Section
+     2.9, "Mapping for Global Elements"</a> in the C++/Tree Mapping User
+     Manual.</p>
+
+
+  <p>In this section we will discuss the most commonly
+     used version of serialization functions. For a comprehensive description
+     of serialization refer to
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4">Chapter
+     4, "Serialization"</a> in the C++/Tree Mapping User Manual. For the
+     <code>people</code> global element from our person record vocabulary,
+     we will concentrate on the following serialization function:</p>
+
+  <pre class="c++">
+void
+people (std::ostream&amp; os,
+        const people_t&amp; x,
+        const xml_schema::namespace_infomap&amp; map =
+          xml_schema::namespace_infomap (),
+        const std::string&amp; encoding = "UTF-8",
+        xml_schema::flags f = 0);
+  </pre>
+
+  <p>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:</p>
+
+  <pre class="c++">
+people_t&amp; 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 ());
+  </pre>
+
+
+  <h2><a name="6.1">6.1 Namespace and Schema Information</a></h2>
+
+  <p>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 <code>name</code> variable of the
+     map value. You can also assign an optional schema location for
+     this namespace in the <code>schema</code> 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:</p>
+
+  <pre class="c++">
+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";
+  </pre>
+
+  <p>Results in the following XML document:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>The empty namespace indicates that the vocabulary has no target
+     namespace. For example, the following map results in only the
+     <code>noNamespaceSchemaLocation</code> attribute being added:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].name = "";
+map[""].schema = "example.xsd";
+  </pre>
+
+  <h2><a name="6.2">6.2 Error Handling</a></h2>
+
+  <p>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
+     <code>xml_schema::exception</code>:</p>
+
+ <pre class="c++">
+try
+{
+  people_t&amp; p = ...
+
+  xml_schema::namespace_infomap map;
+  map[""].schema = "people.xsd";
+
+  people (std::cout, p, map));
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>The most commonly encountered serialization exception is
+     <code>xml_schema::serialization</code>. 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4.4">Section
+     4.4, "Error Handling"</a> in the C++/Tree Mapping
+     User Manual.</p>
+
+  <p>Note that if you are serializing to <code>std::ostream</code> 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:</p>
+
+  <pre class="c++">
+std::ofstream ofs ("people.xml");
+
+if (ofs.fail ())
+{
+  cerr &lt;&lt; "people.xml: unable to open" &lt;&lt; endl;
+  return 1;
+}
+
+people (ofs, p, map));
+
+if (ofs.fail ())
+{
+  cerr &lt;&lt; "people.xml: write error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  <p>The above example can be rewritten to use exceptions as
+     shown below:</p>
+
+  <pre class="c++">
+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&amp;)
+{
+  cerr &lt;&lt; "people.xml: unable to open or write error" &lt;&lt; endl;
+  return 1;
+}
+  </pre>
+
+  </div>
+</div>
+
+</body>
+</html>
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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Tree Mapping User Manual</title>
+
+  <meta name="copyright" content="&#169; 2005-2023 Code Synthesis"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,tree,serialization,guide,manual,examples"/>
+  <meta name="description" content="C++/Tree Mapping User Manual"/>
+  <meta name="revision" content="4.1.0"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 130%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage #title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+    padding: 1em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+
+  /* default-fixed */
+  #default-fixed {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #default-fixed th, #default-fixed td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #default-fixed th {
+    background : #cde8f6;
+  }
+
+  #default-fixed td {
+    text-align: center;
+  }
+
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div id="title">C++/Tree Mapping User Manual</div>
+
+  <p>Copyright &#169; 2005-2023 Code Synthesis.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps">PostScript</a>.</p>
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+	  <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a></td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">C++/Tree Mapping</a>
+        <table class="toc">
+          <tr>
+            <th>2.1</th><td><a href="#2.1">Preliminary Information</a>
+              <table class="toc">
+		<tr><th>2.1.1</th><td><a href="#2.1.1">C++ Standard</a></td></tr>
+                <tr><th>2.1.2</th><td><a href="#2.1.2">Identifiers</a></td></tr>
+                <tr><th>2.1.3</th><td><a href="#2.1.3">Character Type and Encoding</a></td></tr>
+                <tr><th>2.1.4</th><td><a href="#2.1.4">XML Schema Namespace</a></td></tr>
+		<tr><th>2.1.5</th><td><a href="#2.1.5">Anonymous Types</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.2</th><td><a href="#2.2">Error Handling</a>
+              <table class="toc">
+                <tr><th>2.2.1</th><td><a href="#2.2.1"><code>xml_schema::duplicate_id</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.3</th><td><a href="#2.3">Mapping for <code>import</code> and <code>include</code></a>
+              <table class="toc">
+                <tr><th>2.3.1</th><td><a href="#2.3.1">Import</a></td></tr>
+		<tr><th>2.3.2</th><td><a href="#2.3.2">Inclusion with Target Namespace</a></td></tr>
+		<tr><th>2.3.3</th><td><a href="#2.3.3">Inclusion without Target Namespace</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.4</th><td><a href="#2.4">Mapping for Namespaces</a></td>
+          </tr>
+          <tr>
+            <th>2.5</th><td><a href="#2.5">Mapping for Built-in Data Types</a>
+              <table class="toc">
+                <tr><th>2.5.1</th><td><a href="#2.5.1">Inheritance from Built-in Data Types</a></td></tr>
+                <tr><th>2.5.2</th><td><a href="#2.5.2">Mapping for <code>anyType</code></a></td></tr>
+                <tr><th>2.5.3</th><td><a href="#2.5.3">Mapping for <code>anySimpleType</code></a></td></tr>
+                <tr><th>2.5.4</th><td><a href="#2.5.4">Mapping for <code>QName</code></a></td></tr>
+                <tr><th>2.5.5</th><td><a href="#2.5.5">Mapping for <code>IDREF</code></a></td></tr>
+		<tr><th>2.5.6</th><td><a href="#2.5.6">Mapping for <code>base64Binary</code> and <code>hexBinary</code></a></td></tr>
+		<tr><th>2.5.7</th><td><a href="#2.5.7">Time Zone Representation</a></td></tr>
+		<tr><th>2.5.8</th><td><a href="#2.5.8">Mapping for <code>date</code></a></td></tr>
+		<tr><th>2.5.9</th><td><a href="#2.5.9">Mapping for <code>dateTime</code></a></td></tr>
+		<tr><th>2.5.10</th><td><a href="#2.5.10">Mapping for <code>duration</code></a></td></tr>
+		<tr><th>2.5.11</th><td><a href="#2.5.11">Mapping for <code>gDay</code></a></td></tr>
+		<tr><th>2.5.12</th><td><a href="#2.5.12">Mapping for <code>gMonth</code></a></td></tr>
+		<tr><th>2.5.13</th><td><a href="#2.5.13">Mapping for <code>gMonthDay</code></a></td></tr>
+		<tr><th>2.5.14</th><td><a href="#2.5.14">Mapping for <code>gYear</code></a></td></tr>
+		<tr><th>2.5.15</th><td><a href="#2.5.15">Mapping for <code>gYearMonth</code></a></td></tr>
+		<tr><th>2.5.16</th><td><a href="#2.5.16">Mapping for <code>time</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.6</th><td><a href="#2.6">Mapping for Simple Types</a>
+              <table class="toc">
+                <tr><th>2.6.1</th><td><a href="#2.6.1">Mapping for Derivation by Restriction</a></td></tr>
+                <tr><th>2.6.2</th><td><a href="#2.6.2">Mapping for Enumerations</a></td></tr>
+                <tr><th>2.6.3</th><td><a href="#2.6.3">Mapping for Derivation by List</a></td></tr>
+                <tr><th>2.6.4</th><td><a href="#2.6.4">Mapping for Derivation by Union</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.7</th><td><a href="#2.7">Mapping for Complex Types</a>
+              <table class="toc">
+	        <tr><th>2.7.1</th><td><a href="#2.7.1">Mapping for Derivation by Extension</a></td></tr>
+                <tr><th>2.7.2</th><td><a href="#2.7.2">Mapping for Derivation by Restriction</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.8</th><td><a href="#2.8">Mapping for Local Elements and Attributes</a>
+              <table class="toc">
+	        <tr><th>2.8.1</th><td><a href="#2.8.1">Mapping for Members with the One Cardinality Class</a></td></tr>
+	        <tr><th>2.8.2</th><td><a href="#2.8.2">Mapping for Members with the Optional Cardinality Class</a></td></tr>
+	        <tr><th>2.8.3</th><td><a href="#2.8.3">Mapping for Members with the Sequence Cardinality Class</a></td></tr>
+		<tr><th>2.8.4</th><td><a href="#2.8.4">Element Order</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.9</th><td><a href="#2.9">Mapping for Global Elements</a>
+              <table class="toc">
+	        <tr><th>2.9.1</th><td><a href="#2.9.1">Element Types</a></td></tr>
+	        <tr><th>2.9.2</th><td><a href="#2.9.2">Element Map</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.10</th><td><a href="#2.10">Mapping for Global Attributes</a></td>
+          </tr>
+          <tr>
+            <th>2.11</th><td><a href="#2.11">Mapping for <code>xsi:type</code> and Substitution Groups</a></td>
+          </tr>
+          <tr>
+            <th>2.12</th><td><a href="#2.12">Mapping for <code>any</code> and <code>anyAttribute</code></a>
+              <table class="toc">
+	        <tr><th>2.12.1</th><td><a href="#2.12.1">Mapping for <code>any</code> with the One Cardinality Class</a></td></tr>
+	        <tr><th>2.12.2</th><td><a href="#2.12.2">Mapping for <code>any</code> with the Optional Cardinality Class</a></td></tr>
+	        <tr><th>2.12.3</th><td><a href="#2.12.3">Mapping for <code>any</code> with the Sequence Cardinality Class</a></td></tr>
+		<tr><th>2.12.4</th><td><a href="#2.12.4">Element Wildcard Order</a></td></tr>
+		<tr><th>2.12.5</th><td><a href="#2.12.5">Mapping for <code>anyAttribute</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+	  <tr>
+            <th>2.13</th><td><a href="#2.13">Mapping for Mixed Content Models</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Parsing</a>
+        <table class="toc">
+          <tr>
+            <th>3.1</th><td><a href="#3.1">Initializing the Xerces-C++ Runtime</a></td>
+          </tr>
+          <tr>
+            <th>3.2</th><td><a href="#3.2">Flags and Properties</a></td>
+          </tr>
+          <tr>
+            <th>3.3</th><td><a href="#3.3">Error Handling</a>
+              <table class="toc">
+	        <tr><th>3.3.1</th><td><a href="#3.3.1"><code>xml_schema::parsing</code></a></td></tr>
+	        <tr><th>3.3.2</th><td><a href="#3.3.2"><code>xml_schema::expected_element</code></a></td></tr>
+	        <tr><th>3.3.3</th><td><a href="#3.3.3"><code>xml_schema::unexpected_element</code></a></td></tr>
+	        <tr><th>3.3.4</th><td><a href="#3.3.4"><code>xml_schema::expected_attribute</code></a></td></tr>
+	        <tr><th>3.3.5</th><td><a href="#3.3.5"><code>xml_schema::unexpected_enumerator</code></a></td></tr>
+		<tr><th>3.3.6</th><td><a href="#3.3.6"><code>xml_schema::expected_text_content</code></a></td></tr>
+	        <tr><th>3.3.7</th><td><a href="#3.3.7"><code>xml_schema::no_type_info</code></a></td></tr>
+	        <tr><th>3.3.8</th><td><a href="#3.3.8"><code>xml_schema::not_derived</code></a></td></tr>
+		<tr><th>3.3.9</th><td><a href="#3.3.9"><code>xml_schema::not_prefix_mapping</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>3.4</th><td><a href="#3.4">Reading from a Local File or URI</a></td>
+          </tr>
+          <tr>
+            <th>3.5</th><td><a href="#3.5">Reading from <code>std::istream</code></a></td>
+          </tr>
+          <tr>
+            <th>3.6</th><td><a href="#3.6">Reading from <code>xercesc::InputSource</code></a></td>
+          </tr>
+          <tr>
+            <th>3.7</th><td><a href="#3.7">Reading from DOM</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Serialization</a>
+        <table class="toc">
+          <tr>
+            <th>4.1</th><td><a href="#4.1">Initializing the Xerces-C++ Runtime</a></td>
+          </tr>
+          <tr>
+            <th>4.2</th><td><a href="#4.2">Namespace Infomap and Character Encoding</a></td>
+          </tr>
+          <tr>
+            <th>4.3</th><td><a href="#4.3">Flags</a></td>
+          </tr>
+          <tr>
+            <th>4.4</th><td><a href="#4.4">Error Handling</a>
+              <table class="toc">
+	        <tr><th>4.4.1</th><td><a href="#4.4.1"><code>xml_schema::serialization</code></a></td></tr>
+		<tr><th>4.4.2</th><td><a href="#4.4.2"><code>xml_schema::unexpected_element</code></a></td></tr>
+		<tr><th>4.4.3</th><td><a href="#4.4.3"><code>xml_schema::no_type_info</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>4.5</th><td><a href="#4.5">Serializing to <code>std::ostream</code></a></td>
+          </tr>
+          <tr>
+            <th>4.6</th><td><a href="#4.6">Serializing to <code>xercesc::XMLFormatTarget</code></a></td>
+          </tr>
+          <tr>
+            <th>4.7</th><td><a href="#4.7">Serializing to DOM</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Additional Functionality</a>
+        <table class="toc">
+          <tr>
+            <th>5.1</th><td><a href="#5.1">DOM Association</a></td>
+          </tr>
+          <tr>
+            <th>5.2</th><td><a href="#5.2">Binary Serialization</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th></th><td><a href="#A">Appendix A &mdash; Default and Fixed Values</a></td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>This document describes the mapping of W3C XML Schema
+     to the C++ programming language as implemented by
+     <a href="https://www.codesynthesis.com/products/xsd">CodeSynthesis
+     XSD</a> - 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.
+  </p>
+
+  <p>Revision 4.1.0<br/> <!-- Remember to change revision in other places -->
+     This revision of the manual describes the C++/Tree
+     mapping as implemented by CodeSynthesis XSD version 4.1.0.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps">PostScript</a>.</p>
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this manual, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/">C++/Tree
+        Mapping Getting Started Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+        Mapping Customization Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree
+        Mapping Frequently Asked Questions (FAQ)</a></li>
+
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/tree/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is a place to ask questions. Furthermore the
+        <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+  </ul>
+
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.</p>
+
+  <p>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.
+  </p>
+
+  <p>The C++/Tree mapping consists of C++ types that represent the
+     given vocabulary (<a href="#2">Chapter 2, "C++/Tree Mapping"</a>),
+     a set of parsing functions that convert XML documents to
+     a tree-like in-memory data structure (<a href="#3">Chapter 3,
+     "Parsing"</a>), and a set of serialization functions that convert
+     the object model back to XML (<a href="#4">Chapter 4,
+     "Serialization"</a>). Furthermore, the mapping provides a number
+     of additional features, such as DOM association and binary
+     serialization, that can be useful in some applications
+     (<a href="#5">Chapter 5, "Additional Functionality"</a>).
+  </p>
+
+
+  <!-- Chapter 2 -->
+
+
+  <h1><a name="2">2 C++/Tree Mapping</a></h1>
+
+  <h2><a name="2.1">2.1 Preliminary Information</a></h2>
+
+  <h3><a name="2.1.1">2.1.1 C++ Standard</a></h3>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h3><a name="2.1.2">2.1.2 Identifiers</a></h3>
+
+  <p>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 "_".
+  </p>
+
+  <p>For example, XML Schema name <code>try</code> will be mapped to
+     C++ identifier <code>try_</code>. Similarly, XML Schema name
+     <code>strange.na-me</code> will be mapped to C++ identifier
+     <code>strange_na_me</code>.
+  </p>
+
+  <p>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 <a href="#2.9">Section
+     2.9, "Mapping for Global Elements"</a>) 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.</p>
+
+  <p>For example, if we had a global type <code>catalog</code>
+     and a global element with the same name then the type would be
+     mapped to a C++ class with name <code>catalog</code> while the
+     parsing functions corresponding to the global element would have
+     their names escaped as <code>catalog_</code>.
+  </p>
+
+  <p>By default the mapping uses the so-called K&amp;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 <code>--type-naming</code> and
+     <code>--function-naming</code> options. You can also further
+     refine one of the predefined conventions or create a completely
+     custom naming scheme by using the  <code>--*-regex</code> options.
+     For more detailed information on these options refer to the NAMING
+     CONVENTION section in the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+  <h3><a name="2.1.3">2.1.3 Character Type and Encoding</a></h3>
+
+  <p>The code that implements the mapping, depending on the
+     <code>--char-type</code>  option, is generated using either
+     <code>char</code> or <code>wchar_t</code> as the character
+     type. In this document code samples use symbol <code>C</code>
+     to refer to the character type you have selected when translating
+     your schemas, for example <code>std::basic_string&lt;C></code>.
+  </p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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
+     <code>--char-encoding</code> command line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <h3><a name="2.1.4">2.1.4 XML Schema Namespace</a></h3>
+
+  <p>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 (<code>http://www.w3.org/2001/XMLSchema</code>).
+     By default, this namespace is mapped to C++ namespace
+     <code>xml_schema</code>. It is automatically accessible
+     from a C++ compilation unit that includes a header file generated
+     from an XML Schema definition.
+  </p>
+
+  <p>Note that, if desired, the default mapping of this namespace can be
+     changed as described in <a href="#2.4">Section 2.4, "Mapping for
+     Namespaces"</a>.
+  </p>
+
+
+  <h3><a name="2.1.5">2.1.5 Anonymous Types</a></h3>
+
+  <p>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 <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>
+     and <a href="#2.7">Section 2.7, "Mapping for Complex Types"</a>).
+     For example, in the following schema fragment:
+  </p>
+
+  <pre class="xml">
+&lt;element name="object">
+  &lt;complexType>
+    ...
+  &lt;/complexType>
+&lt;/element>
+  </pre>
+
+  <p>The anonymous type defined inside element <code>object</code> will
+     be given name <code>object</code>. The compiler has a number of
+     options that control the process of anonymous type naming. For more
+     information refer to the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+
+  <h2><a name="2.2">2.2 Error Handling</a></h2>
+
+  <p>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 <code>xml_schema::exception</code> which
+     itself is derived from <code>std::exception</code>:
+  </p>
+
+  <pre class="c++">
+struct exception: virtual std::exception
+{
+  friend
+  std::basic_ostream&lt;C>&amp;
+  operator&lt;&lt; (std::basic_ostream&lt;C>&amp; os, const exception&amp; e)
+  {
+    e.print (os);
+    return os;
+  }
+
+protected:
+  virtual void
+  print (std::basic_ostream&lt;C>&amp;) const = 0;
+};
+  </pre>
+
+  <p>The exception hierarchy supports "virtual" <code>operator&lt;&lt;</code>
+     which allows you to obtain diagnostics corresponding to the thrown
+     exception using the base exception interface. For example:</p>
+
+  <pre class="c++">
+try
+{
+  ...
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>The following sub-sections describe exceptions thrown by the
+     types that constitute the object model.
+     <a href="#3.3">Section 3.3, "Error Handling"</a> of
+     <a href="#3">Chapter 3, "Parsing"</a> describes exceptions
+     and error handling mechanisms specific to the parsing functions.
+     <a href="#4.4">Section 4.4, "Error Handling"</a> of
+     <a href="#4">Chapter 4, "Serialization"</a> describes exceptions
+     and error handling mechanisms specific to the serialization functions.
+  </p>
+
+
+  <h3><a name="2.2.1">2.2.1 <code>xml_schema::duplicate_id</code></a></h3>
+
+  <pre class="c++">
+struct duplicate_id: virtual exception
+{
+  duplicate_id (const std::basic_string&lt;C>&amp; id);
+
+  const std::basic_string&lt;C>&amp;
+  id () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::duplicate_id</code> is thrown when
+     a conflicting instance of <code>xml_schema::id</code> (see
+     <a href="#2.5">Section 2.5, "Mapping for Built-in Data Types"</a>)
+     is added to a tree. The offending ID value can be obtained using
+     the <code>id</code> function.
+  </p>
+
+  <h2><a name="2.3">2.3 Mapping for <code>import</code> and <code>include</code></a></h2>
+
+  <h3><a name="2.3.1">2.3.1 Import</a></h3>
+
+  <p>The XML Schema <code>import</code> element is mapped to the C++
+     Preprocessor <code>#include</code> directive. The value of
+     the <code>schemaLocation</code> attribute is used to derive
+     the name of the header file that appears in the <code>#include</code>
+     directive. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;import namespace="https://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+#include "test.hxx"
+  </pre>
+
+  <p>Note that you will need to compile imported schemas separately
+     in order to produce corresponding header files.</p>
+
+  <h3><a name="2.3.2">2.3.2 Inclusion with Target Namespace</a></h3>
+
+  <p>The XML Schema <code>include</code> 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 <code>import</code> element,
+     see <a href="#2.3.1">Section 2.3.1, "Import"</a>.
+  </p>
+
+  <h3><a name="2.3.3">2.3.3 Inclusion without Target Namespace</a></h3>
+
+  <p>For the XML Schema <code>include</code> 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:
+  </p>
+
+  <pre class="xml">
+&lt;-- common.xsd -->
+&lt;schema>
+  &lt;complexType name="type">
+  ...
+  &lt;/complexType>
+&lt;/schema>
+
+&lt;-- test.xsd -->
+&lt;schema targetNamespace="https://www.codesynthesis.com/test">
+  &lt;include schemaLocation="common.xsd"/>
+&lt;/schema>
+  </pre>
+
+  <p>The fragment of interest from the generated header file for
+     <code>text.xsd</code> would look like this:</p>
+
+  <pre class="c++">
+// test.hxx
+namespace test
+{
+  class type
+  {
+    ...
+  };
+}
+  </pre>
+
+  <h2><a name="2.4">2.4 Mapping for Namespaces</a></h2>
+
+  <p>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 '<code>/</code>'
+     as the name separator. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;schema targetNamespace="https://www.codesynthesis.com/system/test">
+  ...
+&lt;/schema>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+namespace system
+{
+  namespace test
+  {
+    ...
+  }
+}
+  </pre>
+
+  <p>The default mapping of namespace URIs to C++ namespace names can be
+     altered using the <code>--namespace-map</code> and
+     <code>--namespace-regex</code> options. See  the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.
+  </p>
+
+  <h2><a name="2.5">2.5 Mapping for Built-in Data Types</a></h2>
+
+  <p>The mapping of XML Schema built-in data types to C++ types is
+     summarized in the table below.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Alias in the <code>xml_schema</code> namespace</th>
+      <th>C++ type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">anyType and anySimpleType types</th>
+    </tr>
+    <tr>
+      <td><code>anyType</code></td>
+      <td><code>type</code></td>
+      <td><a href="#2.5.2">Section 2.5.2, "Mapping for <code>anyType</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>anySimpleType</code></td>
+      <td><code>simple_type</code></td>
+      <td><a href="#2.5.3">Section 2.5.3, "Mapping for <code>anySimpleType</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string</code></td>
+      <td>type derived from <code>string</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token</code></td>
+      <td>type&nbsp;derived&nbsp;from&nbsp;<code>normalized_string</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens</code></td>
+      <td>type derived from <code>sequence&lt;nmtoken></code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname</code></td>
+      <td><a href="#2.5.4">Section 2.5.4, "Mapping for <code>QName</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref</code></td>
+      <td><a href="#2.5.5">Section 2.5.5, "Mapping for <code>IDREF</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs</code></td>
+      <td>type derived from <code>sequence&lt;idref></code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary</code></td>
+      <td rowspan="2"><a href="#2.5.6">Section 2.5.6, "Mapping for
+         <code>base64Binary</code> and <code>hexBinary</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date</code></td>
+      <td><a href="#2.5.8">Section 2.5.8, "Mapping for
+          <code>date</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time</code></td>
+      <td><a href="#2.5.9">Section 2.5.9, "Mapping for
+          <code>dateTime</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration</code></td>
+      <td><a href="#2.5.10">Section 2.5.10, "Mapping for
+          <code>duration</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday</code></td>
+      <td><a href="#2.5.11">Section 2.5.11, "Mapping for
+          <code>gDay</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth</code></td>
+      <td><a href="#2.5.12">Section 2.5.12, "Mapping for
+          <code>gMonth</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day</code></td>
+      <td><a href="#2.5.13">Section 2.5.13, "Mapping for
+          <code>gMonthDay</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear</code></td>
+      <td><a href="#2.5.14">Section 2.5.14, "Mapping for
+          <code>gYear</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month</code></td>
+      <td><a href="#2.5.15">Section 2.5.15, "Mapping for
+          <code>gYearMonth</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time</code></td>
+      <td><a href="#2.5.16">Section 2.5.16, "Mapping for
+          <code>time</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">entity types</th>
+    </tr>
+    <tr>
+      <td><code>ENTITY</code></td>
+      <td><code>entity</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>ENTITIES</code></td>
+      <td><code>entities</code></td>
+      <td>type derived from <code>sequence&lt;entity></code></td>
+    </tr>
+  </table>
+
+  <p>All XML Schema built-in types are mapped to C++ classes that are
+     derived from the <code>xml_schema::simple_type</code> class except
+     where the mapping is to a fundamental C++ type.</p>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. One notable extension
+     to the standard interface that is available only for
+     sequences of non-fundamental C++ types is the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     member functions which instead of the constant reference
+     to the element type accept automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, 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.
+  </p>
+
+  <h3><a name="2.5.1">2.5.1 Inheritance from Built-in Data Types</a></h3>
+
+  <p>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:</p>
+
+  <pre class="xml">
+&lt;simpleType name="my_int">
+  &lt;restriction base="int"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class my_int: public fundamental_base&lt;int>
+{
+  ...
+};
+  </pre>
+
+  <p>The <code>fundamental_base</code> 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:</p>
+
+  <pre class="c++">
+template &lt;typename X>
+class fundamental_base: public simple_type
+{
+public:
+  fundamental_base ();
+  fundamental_base (X)
+  fundamental_base (const fundamental_base&amp;)
+
+public:
+  fundamental_base&amp;
+  operator= (const X&amp;);
+
+public:
+  operator const X &amp; () const;
+  operator X&amp; ();
+
+  template &lt;typename Y>
+  operator Y () const;
+
+  template &lt;typename Y>
+  operator Y ();
+};
+  </pre>
+
+  <h3><a name="2.5.2">2.5.2 Mapping for <code>anyType</code></a></h3>
+
+  <p>The XML Schema <code>anyType</code> built-in data type is mapped to the
+     <code>xml_schema::type</code> C++ class:</p>
+
+  <pre class="c++">
+class type
+{
+public:
+  virtual
+  ~type ();
+
+  type ();
+  type (const type&amp;);
+
+  type&amp;
+  operator= (const type&amp;);
+
+  virtual type*
+  _clone () const;
+
+  // anyType DOM content.
+  //
+public:
+  typedef element_optional dom_content_optional;
+
+  const dom_content_optional&amp;
+  dom_content () const;
+
+  dom_content_optional&amp;
+  dom_content ();
+
+  void
+  dom_content (const xercesc::DOMElement&amp;);
+
+  void
+  dom_content (xercesc::DOMElement*);
+
+  void
+  dom_content (const dom_content_optional&amp;);
+
+  const xercesc::DOMDocument&amp;
+  dom_content_document () const;
+
+  xercesc::DOMDocument&amp;
+  dom_content_document ();
+
+  bool
+  null_content () const;
+
+  // DOM association.
+  //
+public:
+  const xercesc::DOMNode*
+  _node () const;
+
+  xercesc::DOMNode*
+  _node ();
+};
+  </pre>
+
+  <p>When <code>xml_schema::type</code> is used to create an instance
+     (as opposed to being a base of a derived type), it represents
+     the XML Schema <code>anyType</code> type. <code>anyType</code>
+     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 (<a href="#2.12">Section
+     2.12, "Mapping for <code>any</code> and
+     <code>anyAttribute</code>"</a>).</p>
+
+  <p>To enable automatic extraction of <code>anyType</code> content
+     during parsing, the <code>--generate-any-type</code> 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 <a href="#3.1">Section 3.1, "Initializing the
+     Xerces-C++ Runtime"</a>.</p>
+
+  <p>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 <a href="#2.12.2">Section 2.12.2, "Mapping for <code>any</code>
+     with the Optional Cardinality Class"</a> for details on their
+     semantics.</p>
+
+  <p>The <code>dom_content_document()</code> function returns the
+     DOM document used to store the raw XML content corresponding
+     to the <code>anyType</code> instance. It is equivalent to the
+     <code>dom_document()</code> function generated for types
+     with wildcards.</p>
+
+  <p>The <code>null_content()</code> 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
+     <code>anyType</code> or empty string for <code>anySimpleType</code>
+     (see the following section for details on <code>anySimpleType</code>).</p>
+
+  <p>For more information on DOM association refer to
+     <a href="#5.1">Section 5.1, "DOM Association"</a>.</p>
+
+  <h3><a name="2.5.3">2.5.3 Mapping for <code>anySimpleType</code></a></h3>
+
+  <p>The XML Schema <code>anySimpleType</code> built-in data type is mapped
+     to the <code>xml_schema::simple_type</code> C++ class:</p>
+
+  <pre class="c++">
+class simple_type: public type
+{
+public:
+  simple_type ();
+  simple_type (const C*);
+  simple_type (const std::basic_string&lt;C>&amp;);
+
+  simple_type (const simple_type&amp;);
+
+  simple_type&amp;
+  operator= (const simple_type&amp;);
+
+  virtual simple_type*
+  _clone () const;
+
+  // anySimpleType text content.
+  //
+public:
+  const std::basic_string&lt;C>&amp;
+  text_content () const;
+
+  std::basic_string&lt;C>&amp;
+  text_content ();
+
+  void
+  text_content (const std::basic_string&lt;C>&amp;);
+};
+  </pre>
+
+  <p>When <code>xml_schema::simple_type</code> is used to create an instance
+     (as opposed to being a base of a derived type), it represents
+     the XML Schema <code>anySimpleType</code> type. <code>anySimpleType</code>
+     allows any simple content. In the C++/Tree mapping this content can
+     be represented as a string and accessed or modified with the
+     <code>text_content()</code> functions shown above.</p>
+
+  <h3><a name="2.5.4">2.5.4 Mapping for <code>QName</code></a></h3>
+
+  <p>The XML Schema <code>QName</code> built-in data type is mapped to the
+     <code>xml_schema::qname</code> C++ class:</p>
+
+  <pre class="c++">
+class qname: public simple_type
+{
+public:
+  qname (const ncname&amp;);
+  qname (const uri&amp;, const ncname&amp;);
+  qname (const qname&amp;);
+
+public:
+  qname&amp;
+  operator= (const qname&amp;);
+
+public:
+  virtual qname*
+  _clone () const;
+
+public:
+  bool
+  qualified () const;
+
+  const uri&amp;
+  namespace_ () const;
+
+  const ncname&amp;
+  name () const;
+};
+  </pre>
+
+  <p>The <code>qualified</code> accessor function can be used to determine
+     if the name is qualified.</p>
+
+  <h3><a name="2.5.5">2.5.5 Mapping for <code>IDREF</code></a></h3>
+
+  <p>The XML Schema <code>IDREF</code> built-in data type is mapped to the
+     <code>xml_schema::idref</code> C++ class. This class implements the
+     smart pointer C++ idiom:</p>
+
+  <pre class="c++">
+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&lt;C>&amp;);
+  idref (const std::basic_string&lt;C>&amp;,
+         std::size_t pos,
+         std::size_t n = npos);
+
+public:
+  idref (const idref&amp;);
+
+public:
+  virtual idref*
+  _clone () const;
+
+public:
+  idref&amp;
+  operator= (C c);
+
+  idref&amp;
+  operator= (const C* s);
+
+  idref&amp;
+  operator= (const std::basic_string&lt;C>&amp;)
+
+  idref&amp;
+  operator= (const idref&amp;);
+
+public:
+  const type*
+  operator-> () const;
+
+  type*
+  operator-> ();
+
+  const type&amp;
+  operator* () const;
+
+  type&amp;
+  operator* ();
+
+  const type*
+  get () const;
+
+  type*
+  get ();
+
+  // Conversion to bool.
+  //
+public:
+  typedef void (idref::*bool_convertible)();
+  operator bool_convertible () const;
+};
+  </pre>
+
+  <p>The object, <code>idref</code> instance refers to, is the immediate
+     container of the matching <code>id</code> instance. For example,
+     with the following instance document and schema:
+  </p>
+
+
+  <pre class="xml">
+&lt;!-- test.xml -->
+&lt;root>
+  &lt;object id="obj-1" text="hello"/>
+  &lt;reference>obj-1&lt;/reference>
+&lt;/root>
+
+&lt;!-- test.xsd -->
+&lt;schema>
+  &lt;complexType name="object_type">
+    &lt;attribute name="id" type="ID"/>
+    &lt;attribute name="text" type="string"/>
+  &lt;/complexType>
+
+  &lt;complexType name="root_type">
+    &lt;sequence>
+      &lt;element name="object" type="object_type"/>
+      &lt;element name="reference" type="IDREF"/>
+    &lt;/sequence>
+  &lt;/complexType>
+
+  &lt;element name="root" type="root_type"/>
+&lt;/schema>
+  </pre>
+
+  <p>The <code>ref</code> instance in the code below will refer to
+     an object of type <code>object_type</code>:</p>
+
+  <pre class="c++">
+root_type&amp; root = ...;
+xml_schema::idref&amp; ref (root.reference ());
+object_type&amp; obj (dynamic_cast&lt;object_type&amp;> (*ref));
+cout &lt;&lt; obj.text () &lt;&lt; endl;
+  </pre>
+
+  <p>The smart pointer interface of the <code>idref</code> class always
+     returns a pointer or reference to <code>xml_schema::type</code>.
+     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
+     <code>xml_schema::type</code>). As a special extension to the XML
+     Schema language, the mapping supports static typing of <code>idref</code>
+     references by employing the <code>refType</code> extension attribute.
+     The following example illustrates this mechanism:
+  </p>
+
+  <pre class="xml">
+&lt;!-- test.xsd -->
+&lt;schema
+  xmlns:xse="https://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      &lt;element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+&lt;/schema>
+  </pre>
+
+  <p>With this modification we do not need to do manual casting anymore:
+  </p>
+
+  <pre class="c++">
+root_type&amp; root = ...;
+root_type::reference_type&amp; ref (root.reference ());
+object_type&amp; obj (*ref);
+cout &lt;&lt; ref->text () &lt;&lt; endl;
+  </pre>
+
+
+  <h3><a name="2.5.6">2.5.6 Mapping for <code>base64Binary</code> and
+      <code>hexBinary</code></a></h3>
+
+  <p>The XML Schema <code>base64Binary</code> and <code>hexBinary</code>
+     built-in data types are mapped to the
+     <code>xml_schema::base64_binary</code> and
+     <code>xml_schema::hex_binary</code> C++ classes, respectively. The
+     <code>base64_binary</code> and <code>hex_binary</code> classes
+     support a simple buffer abstraction by inheriting from the
+     <code>xml_schema::buffer</code> class:
+  </p>
+
+  <pre class="c++">
+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&amp;);
+
+  buffer&amp;
+  operator= (const buffer&amp;);
+
+  void
+  swap (buffer&amp;);
+
+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 ();
+};
+  </pre>
+
+  <p>The last overloaded constructor reuses an existing data buffer instead
+     of making a copy. If the <code>assume_ownership</code> argument is
+     <code>true</code>, the instance assumes ownership of the
+     memory block pointed to by the <code>data</code> argument and will
+     eventually release it by calling <code>operator delete</code>. The
+     <code>capacity</code> and <code>size</code> modifier functions return
+     <code>true</code> if the underlying buffer has moved.
+  </p>
+
+  <p>The <code>bounds</code> exception is thrown if the constructor
+     arguments violate the <code>(size&nbsp;&lt;=&nbsp;capacity)</code>
+     constraint.</p>
+
+  <p>The <code>base64_binary</code> and <code>hex_binary</code> classes
+     support the <code>buffer</code> interface and perform automatic
+     decoding/encoding from/to the Base64 and Hex formats, respectively:
+  </p>
+
+  <pre class="c++">
+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&amp;);
+
+  base64_binary&amp;
+  operator= (const base64_binary&amp;);
+
+  virtual base64_binary*
+  _clone () const;
+
+public:
+  std::basic_string&lt;C>
+  encode () const;
+};
+  </pre>
+
+  <pre class="c++">
+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&amp;);
+
+  hex_binary&amp;
+  operator= (const hex_binary&amp;);
+
+  virtual hex_binary*
+  _clone () const;
+
+public:
+  std::basic_string&lt;C>
+  encode () const;
+};
+  </pre>
+
+
+  <h2><a name="2.5.7">2.5.7 Time Zone Representation</a></h2>
+
+  <p>The <code>date</code>, <code>dateTime</code>, <code>gDay</code>,
+     <code>gMonth</code>, <code>gMonthDay</code>, <code>gYear</code>,
+     <code>gYearMonth</code>, and <code>time</code> XML Schema built-in
+     types all include an optional time zone component. The following
+     <code>xml_schema::time_zone</code> base class is used to represent
+     this information:</p>
+
+  <pre class="c++">
+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&amp;, const time_zone&amp;);
+
+bool
+operator!= (const time_zone&amp;, const time_zone&amp;);
+  </pre>
+
+  <p>The <code>zone_present()</code> accessor function returns <code>true</code>
+     if the time zone is specified. The <code>zone_reset()</code> modifier
+     function resets the time zone object to the <em>not specified</em>
+     state. If the time zone offset is negative then both hours and
+     minutes components are represented as negative integers.</p>
+
+
+  <h2><a name="2.5.8">2.5.8 Mapping for <code>date</code></a></h2>
+
+ <p>The XML Schema <code>date</code> built-in data type is mapped to the
+    <code>xml_schema::date</code> 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 <code>xml_schema::time_zone</code>
+    class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+    Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  date&amp;
+  operator= (const date&amp;);
+
+  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&amp;, const date&amp;);
+
+bool
+operator!= (const date&amp;, const date&amp;);
+  </pre>
+
+  <h2><a name="2.5.9">2.5.9 Mapping for <code>dateTime</code></a></h2>
+
+ <p>The XML Schema <code>dateTime</code> built-in data type is mapped to the
+    <code>xml_schema::date_time</code> 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
+    <code>xml_schema::time_zone</code> class refer to <a href="#2.5.7">Section
+    2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  date_time&amp;
+  operator= (const date_time&amp;);
+
+  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&amp;, const date_time&amp;);
+
+bool
+operator!= (const date_time&amp;, const date_time&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.10">2.5.10 Mapping for <code>duration</code></a></h2>
+
+  <p>The XML Schema <code>duration</code> built-in data type is mapped to the
+    <code>xml_schema::duration</code> C++ class which represents a potentially
+     negative duration in the form of years, months, days, hours, minutes,
+     and seconds. Its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  duration&amp;
+  operator= (const duration&amp;);
+
+  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&amp;, const duration&amp;);
+
+bool
+operator!= (const duration&amp;, const duration&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.11">2.5.11 Mapping for <code>gDay</code></a></h2>
+
+  <p>The XML Schema <code>gDay</code> built-in data type is mapped to the
+    <code>xml_schema::gday</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gday&amp;
+  operator= (const gday&amp;);
+
+  virtual gday*
+  _clone () const;
+
+public:
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gday&amp;, const gday&amp;);
+
+bool
+operator!= (const gday&amp;, const gday&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.12">2.5.12 Mapping for <code>gMonth</code></a></h2>
+
+  <p>The XML Schema <code>gMonth</code> built-in data type is mapped to the
+    <code>xml_schema::gmonth</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gmonth&amp;
+  operator= (const gmonth&amp;);
+
+  virtual gmonth*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gmonth&amp;, const gmonth&amp;);
+
+bool
+operator!= (const gmonth&amp;, const gmonth&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.13">2.5.13 Mapping for <code>gMonthDay</code></a></h2>
+
+  <p>The XML Schema <code>gMonthDay</code> built-in data type is mapped to the
+    <code>xml_schema::gmonth_day</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gmonth_day&amp;
+  operator= (const gmonth_day&amp;);
+
+  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&amp;, const gmonth_day&amp;);
+
+bool
+operator!= (const gmonth_day&amp;, const gmonth_day&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.14">2.5.14 Mapping for <code>gYear</code></a></h2>
+
+  <p>The XML Schema <code>gYear</code> built-in data type is mapped to the
+    <code>xml_schema::gyear</code> C++ class which represents a year with
+     an optional time zone. Its interface is presented below. For more
+     information on the base <code>xml_schema::time_zone</code> class refer
+     to <a href="#2.5.7">Section 2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gyear&amp;
+  operator= (const gyear&amp;);
+
+  virtual gyear*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+};
+
+bool
+operator== (const gyear&amp;, const gyear&amp;);
+
+bool
+operator!= (const gyear&amp;, const gyear&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.15">2.5.15 Mapping for <code>gYearMonth</code></a></h2>
+
+  <p>The XML Schema <code>gYearMonth</code> built-in data type is mapped to
+     the <code>xml_schema::gyear_month</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gyear_month&amp;
+  operator= (const gyear_month&amp;);
+
+  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&amp;, const gyear_month&amp;);
+
+bool
+operator!= (const gyear_month&amp;, const gyear_month&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.16">2.5.16 Mapping for <code>time</code></a></h2>
+
+  <p>The XML Schema <code>time</code> built-in data type is mapped to
+     the <code>xml_schema::time</code> C++ class which represents hours,
+     minutes, and seconds with an optional time zone. Its interface is
+     presented below. For more information on the base
+     <code>xml_schema::time_zone</code> class refer to
+     <a href="#2.5.7">Section 2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  time&amp;
+  operator= (const time&amp;);
+
+  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&amp;, const time&amp;);
+
+bool
+operator!= (const time&amp;, const time&amp;);
+  </pre>
+
+
+  <!-- Mapping for Simple Types -->
+
+  <h2><a name="2.6">2.6 Mapping for Simple Types</a></h2>
+
+  <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 constructor,
+     a public copy assignment operator, and a public virtual
+     <code>_clone</code> function. The <code>_clone</code> function is
+     declared <code>const</code>, does not take any arguments, and returns
+     a pointer to a complete copy of the instance allocated in the free
+     store. The <code>_clone</code> function shall be used to make copies
+     when static type and dynamic type of the instance may differ (see
+     <a href="#2.11">Section 2.11, "Mapping for <code>xsi:type</code>
+     and Substitution Groups"</a>). For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="object">
+  ...
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: ...
+{
+public:
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  </pre>
+
+  <p>The base class specification and the rest of the class definition
+     depend on the type of derivation used to define the simple type. </p>
+
+
+  <h3><a name="2.6.1">2.6.1 Mapping for Derivation by Restriction</a></h3>
+
+  <p>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 <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>, the
+     resulting C++ class defines a public constructor with the base type
+     as its single argument. For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="object">
+  &lt;restriction base="base">
+    ...
+  &lt;/restriction>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public base
+{
+public:
+  object (const base&amp;);
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+};
+  </pre>
+
+
+  <h3><a name="2.6.2">2.6.2 Mapping for Enumerations</a></h3>
+
+<p>XML Schema restriction by enumeration is mapped to a C++ class
+   with semantics similar to C++ <code>enum</code>. Each XML Schema
+   enumeration element is mapped to a C++ enumerator with the
+   name derived from the <code>value</code> attribute and defined
+   in the class scope. In addition to the members
+   described in <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>,
+   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.</p>
+
+<p>Furthermore, for string-based enumeration types, the resulting C++
+   class defines a public constructor with a single argument of type
+   <code>const C*</code> and a public constructor with a single
+   argument of type <code>const std::basic_string&lt;C>&amp;</code>.
+   For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="color">
+  &lt;restriction base="string">
+    &lt;enumeration value="red"/>
+    &lt;enumeration value="green"/>
+    &lt;enumeration value="blue"/>
+  &lt;/restriction>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string&lt;C>&amp;);
+  color (const xml_schema::string&amp;);
+  color (const color&amp;);
+
+public:
+  color&amp;
+  operator= (value);
+
+  color&amp;
+  operator= (const color&amp;);
+
+public:
+  virtual color*
+  _clone () const;
+
+public:
+  operator value () const;
+};
+  </pre>
+
+  <h3><a name="2.6.3">2.6.3 Mapping for Derivation by List</a></h3>
+
+  <p>XML Schema derivation by list is mapped to C++ public
+     inheritance from <code>xml_schema::simple_type</code>
+     (<a href="#2.5.3">Section 2.5.3, "Mapping for
+     <code>anySimpleType</code>"</a>) and a suitable sequence type.
+     The list item type becomes the element type of the sequence.
+     In addition to the members described in <a href="#2.6">Section 2.6,
+     "Mapping for Simple Types"</a>, the resulting C++ class defines
+     a public default constructor, a public constructor
+     with the first argument of type <code>size_type</code> 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:
+  </p>
+
+  <pre class="xml">
+&lt;simpleType name="int_list">
+  &lt;list itemType="int"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class int_list: public simple_type,
+                public sequence&lt;int>
+{
+public:
+  int_list ();
+  int_list (size_type n, int x);
+
+  template &lt;typename I>
+  int_list (const I&amp; begin, const I&amp; end);
+  int_list (const int_list&amp;);
+
+public:
+  int_list&amp;
+  operator= (const int_list&amp;);
+
+public:
+  virtual int_list*
+  _clone () const;
+};
+  </pre>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. One notable extension
+     to the standard interface that is available only for
+     sequences of non-fundamental C++ types is the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     member functions which instead of the constant reference
+     to the element type accept automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, 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.
+  </p>
+
+  <h3><a name="2.6.4">2.6.4 Mapping for Derivation by Union</a></h3>
+
+  <p>XML Schema derivation by union is mapped to C++ public
+     inheritance from <code>xml_schema::simple_type</code>
+     (<a href="#2.5.3">Section 2.5.3, "Mapping for
+     <code>anySimpleType</code>"</a>) and <code>std::basic_string&lt;C></code>.
+     In addition to the members described in <a href="#2.6">Section 2.6,
+     "Mapping for Simple Types"</a>, the resulting C++ class defines a
+     public constructor with a single argument of type <code>const C*</code>
+     and a public constructor with a single argument of type
+     <code>const std::basic_string&lt;C>&amp;</code>. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;simpleType name="int_string_union">
+  &lt;xsd:union memberTypes="xsd:int xsd:string"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class int_string_union: public simple_type,
+                        public std::basic_string&lt;C>
+{
+public:
+  int_string_union (const C*);
+  int_string_union (const std::basic_string&lt;C>&amp;);
+  int_string_union (const int_string_union&amp;);
+
+public:
+  int_string_union&amp;
+  operator= (const int_string_union&amp;);
+
+public:
+  virtual int_string_union*
+  _clone () const;
+};
+  </pre>
+
+  <h2><a name="2.7">2.7 Mapping for Complex Types</a></h2>
+
+  <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 constructor,
+     a public copy assignment operator, and a public virtual
+     <code>_clone</code> function. The <code>_clone</code> function is
+     declared <code>const</code>, does not take any arguments, and returns
+     a pointer to a complete copy of the instance allocated in the free
+     store. The <code>_clone</code> function shall be used to make copies
+     when static type and dynamic type of the instance may differ (see
+     <a href="#2.11">Section 2.11, "Mapping for <code>xsi:type</code>
+     and Substitution Groups"</a>).</p>
+
+  <p>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 <a href="#2.8">Section 2.8, "Mapping
+     for Local Elements and Attributes"</a>). 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 <code>std::unique_ptr</code> (C++11) or <code>std::auto_ptr</code>
+     (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 <code>std::[unique|auto]_ptr</code>
+     arguments are reset to <code>0</code>. For instance:</p>
+
+  <pre class="xml">
+&lt;complexType name="complex">
+  &lt;sequence>
+    &lt;element name="a" type="int"/>
+    &lt;element name="b" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="s-one" type="boolean"/>
+    &lt;element name="c-one" type="complex"/>
+    &lt;element name="optional" type="int" minOccurs="0"/>
+    &lt;element name="sequence" type="string" maxOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class complex: public xml_schema::type
+{
+public:
+  object (const int&amp; a, const xml_schema::string&amp; b);
+  object (const complex&amp;);
+
+public:
+  object&amp;
+  operator= (const complex&amp;);
+
+public:
+  virtual complex*
+  _clone () const;
+
+  ...
+
+};
+
+class object: public xml_schema::type
+{
+public:
+  object (const bool&amp; s_one, const complex&amp; c_one);
+  object (const bool&amp; s_one, std::[unique|auto]_ptr&lt;complex> c_one);
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  </pre>
+
+  <p>Notice that the generated <code>complex</code> class does not
+     have the second (<code>std::[unique|auto]_ptr</code>) version of the
+     constructor since all its required members are of simple types.</p>
+
+  <p>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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;simpleContent>
+    &lt;extension base="date">
+      &lt;attribute name="lang" type="language" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::string
+{
+public:
+  object (const xml_schema::language&amp; lang);
+
+  object (const xml_schema::date&amp; base,
+          const xml_schema::language&amp; lang);
+
+  ...
+
+};
+  </pre>
+
+  <p>Furthermore, for string-based XML Schema complex types, the resulting C++
+     class also defines two  public constructors with the first arguments
+     of type <code>const C*</code> and <code>std::basic_string&lt;C>&amp;</code>,
+     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:</p>
+
+  <pre class="xml">
+&lt;simpleType name="color">
+  &lt;restriction base="string">
+    &lt;enumeration value="red"/>
+    &lt;enumeration value="green"/>
+    &lt;enumeration value="blue"/>
+  &lt;/restriction>
+&lt;/simpleType>
+
+&lt;complexType name="object">
+  &lt;simpleContent>
+    &lt;extension base="color">
+      &lt;attribute name="lang" type="language" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string&lt;C>&amp;);
+
+  ...
+
+};
+
+class object: color
+{
+public:
+  object (const color&amp; base,
+          const xml_schema::language&amp; lang);
+
+  object (const color::value&amp; base,
+          const xml_schema::language&amp; lang);
+
+  object (const C* base,
+          const xml_schema::language&amp; lang);
+
+  object (const std::basic_string&lt;C>&amp; base,
+          const xml_schema::language&amp; lang);
+
+  ...
+
+};
+  </pre>
+
+  <p>Additional constructors can be requested with the
+     <code>--generate-default-ctor</code> and
+     <code>--generate-from-base-ctor</code> options. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for details.</p>
+
+  <p>If an XML Schema complex type is not explicitly derived from any type,
+     the resulting C++ class is derived from <code>xml_schema::type</code>.
+     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.
+  </p>
+
+  <p>The mapping for elements and attributes that are defined in a complex
+     type is described in <a href="#2.8">Section 2.8, "Mapping for Local
+     Elements and Attributes"</a>.
+  </p>
+
+  <h3><a name="2.7.1">2.7.1 Mapping for Derivation by Extension</a></h3>
+
+  <p>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.
+  </p>
+
+  <h3><a name="2.7.2">2.7.2 Mapping for Derivation by Restriction</a></h3>
+
+  <p>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.
+  </p>
+
+  <!-- 2.8 Mapping for Local Elements and Attributes -->
+
+  <h2><a name="2.8">2.8 Mapping for Local Elements and Attributes</a></h2>
+
+   <p>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.
+   </p>
+
+   <p>Local XML Schema element and attribute definitions have the same
+      C++ mapping. Therefore, in this section, local elements and
+      attributes are collectively called members.
+   </p>
+
+   <p>While there are many different member cardinality combinations
+      (determined by the <code>use</code> attribute for attributes and
+       the <code>minOccurs</code> and <code>maxOccurs</code> attributes
+       for elements), the mapping divides all possible cardinality
+       combinations into three cardinality classes:
+   </p>
+
+   <dl>
+     <dt><i>one</i></dt>
+     <dd>attributes: <code>use == "required"</code></dd>
+     <dd>attributes: <code>use == "optional"</code> and has default or fixed value</dd>
+     <dd>elements: <code>minOccurs == "1"</code> and <code>maxOccurs == "1"</code></dd>
+
+     <dt><i>optional</i></dt>
+     <dd>attributes: <code>use == "optional"</code> and doesn't have default or fixed value</dd>
+     <dd>elements: <code>minOccurs == "0"</code> and <code>maxOccurs == "1"</code></dd>
+
+     <dt><i>sequence</i></dt>
+     <dd>elements: <code>maxOccurs > "1"</code></dd>
+   </dl>
+
+   <p>An optional attribute with a default or fixed value acquires this value
+      if the attribute hasn't been specified in an instance document (see
+      <a href="#A">Appendix A, "Default and Fixed Values"</a>). This
+      mapping places such optional attributes to the One cardinality
+      class.</p>
+
+   <p>A member is mapped to a set of public type definitions
+      (<code>typedef</code>s) 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:
+   </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string member_type;
+
+  const member_type&amp;
+  member () const;
+
+  ...
+
+};
+  </pre>
+
+   <p>In addition, if a member has a default or fixed value, a static
+      accessor function is generated that returns this value. For
+      example:</p>
+
+<pre class="xml">
+&lt;complexType name="object">
+  &lt;attribute name="data" type="string" default="test"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string data_type;
+
+  const data_type&amp;
+  data () const;
+
+  static const data_type&amp;
+  data_default_value ();
+
+  ...
+
+};
+  </pre>
+
+   <p>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.
+   </p>
+
+
+  <h3><a name="2.8.1">2.8.1 Mapping for Members with the One Cardinality Class</a></h3>
+
+   <p>For the One cardinality class, the type definitions consist of
+      an alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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 (<code>std::unique_ptr</code> or
+      <code>std::auto_ptr</code>, 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+
+  // Accessors.
+  //
+  const member_type&amp;
+  member () const;
+
+  member_type&amp;
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&amp;);
+
+  void
+  member (std::[unique|auto]_ptr&lt;member_type>);
+  ...
+
+};
+  </pre>
+
+   <p>In addition, if requested by specifying the <code>--generate-detach</code>
+      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:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  ...
+
+  std::[unique|auto]_ptr&lt;member_type>
+  detach_member ();
+  ...
+
+};
+  </pre>
+
+   <p>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.</p>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  string s (o.member ());                // get
+  object::member_type&amp; sr (o.member ()); // get
+
+  o.member ("hello");           // set, deep copy
+  o.member () = "hello";        // set, deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr&lt;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&lt;string> p (new string ("hello"));
+  o.member (p);                 // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (p);                 // re-attach
+}
+  </pre>
+
+
+<h3><a name="2.8.2">2.8.2 Mapping for Members with the Optional Cardinality Class</a></h3>
+
+   <p>For the Optional cardinality class, the type definitions consist of
+      an alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name and an alias for
+      the container type with the name created by appending the
+      <code>_optional</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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 (<code>std::unique_ptr</code> or
+      <code>std::auto_ptr</code>, 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:
+   </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string" minOccurs="0"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef optional&lt;member_type> member_optional;
+
+  // Accessors.
+  //
+  const member_optional&amp;
+  member () const;
+
+  member_optional&amp;
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&amp;);
+
+  void
+  member (std::[unique|auto]_ptr&lt;member_type>);
+
+  void
+  member (const member_optional&amp;);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The <code>optional</code> class template is defined in an
+     implementation-specific namespace and has the following
+     interface. The <code>[unique|auto]_ptr</code>-based constructor
+     and modifier function are only available if the template
+     argument is not a fundamental C++ type.
+  </p>
+
+  <pre class="c++">
+template &lt;typename X>
+class optional
+{
+public:
+  optional ();
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional (const X&amp;);
+
+  // Assumes ownership.
+  //
+  explicit
+  optional (std::[unique|auto]_ptr&lt;X>);
+
+  optional (const optional&amp;);
+
+public:
+  optional&amp;
+  operator= (const X&amp;);
+
+  optional&amp;
+  operator= (const optional&amp;);
+
+  // Pointer-like interface.
+  //
+public:
+  const X*
+  operator-> () const;
+
+  X*
+  operator-> ();
+
+  const X&amp;
+  operator* () const;
+
+  X&amp;
+  operator* ();
+
+  typedef void (optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const X&amp;
+  get () const;
+
+  X&amp;
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const X&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  set (std::[unique|auto]_ptr&lt;X>);
+
+  // Detach and return the contained value.
+  //
+  std::[unique|auto]_ptr&lt;X>
+  detach ();
+
+  void
+  reset ();
+};
+
+template &lt;typename X>
+bool
+operator== (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator!= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator&lt; (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator> (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator&lt;= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator>= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  if (o.member ().present ())       // test
+  {
+    string&amp; 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&amp; 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&lt;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&lt;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
+}
+  </pre>
+
+
+  <h3><a name="2.8.3">2.8.3 Mapping for Members with the Sequence Cardinality Class</a></h3>
+
+   <p>For the Sequence cardinality class, the type definitions consist of an
+      alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name, an alias of
+      the container type with the name created by appending the
+      <code>_sequence</code> suffix to the member's name, an alias of
+      the iterator type with the name created by appending the
+      <code>_iterator</code> suffix to the member's name, and an alias
+      of the constant iterator type with the name created by appending the
+      <code>_const_iterator</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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:
+   </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string" minOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef sequence&lt;member_type> member_sequence;
+  typedef member_sequence::iterator member_iterator;
+  typedef member_sequence::const_iterator member_const_iterator;
+
+  // Accessors.
+  //
+  const member_sequence&amp;
+  member () const;
+
+  member_sequence&amp;
+  member ();
+
+  // Modifier.
+  //
+  void
+  member (const member_sequence&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. Two notable extensions
+     to the standard interface that are available only for
+     sequences of non-fundamental C++ types are the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     as well as the <code>detach_back</code> and <code>detach</code>
+     member functions. The additional <code>push_back</code> and
+     <code>insert</code> functions accept an automatic pointer
+     (<code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     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 <code>detach_back</code> and
+     <code>detach</code> 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:</p>
+
+  <pre class="c++">
+template &lt;typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back (std::[unique|auto]_ptr&lt;X>)
+
+  iterator
+  insert (iterator position, std::[unique|auto]_ptr&lt;X>)
+
+  std::[unique|auto]_ptr&lt;X>
+  detach_back (bool pop = true);
+
+  iterator
+  detach (iterator position,
+          std::[unique|auto]_ptr&lt;X>&amp; result,
+          bool erase = true)
+
+  ...
+}
+  </pre>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  object::member_sequence&amp; s (o.member ());
+
+  // Iteration.
+  //
+  for (object::member_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    string&amp; value (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back ("hello");  // deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr&lt;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&lt;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
+}
+  </pre>
+
+  <h3><a name="2.8.4">2.8.4 Element Order</a></h3>
+
+  <p>C++/Tree is a "flattening" mapping in a sense that many levels of
+     nested compositors (<code>choice</code> and <code>sequence</code>),
+     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:</p>
+
+  <pre class="xml">
+&lt;complexType name="withdraw">
+  &lt;sequence>
+    &lt;element name="account" type="unsignedInt"/>
+    &lt;element name="amount" type="unsignedInt"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="deposit">
+  &lt;sequence>
+    &lt;element name="account" type="unsignedInt"/>
+    &lt;element name="amount" type="unsignedInt"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="batch">
+  &lt;choice minOccurs="0" maxOccurs="unbounded">
+    &lt;element name="withdraw" type="withdraw"/>
+    &lt;element name="deposit" type="deposit"/>
+  &lt;/choice>
+&lt;/complexType>
+  </pre>
+
+  <p>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.</p>
+
+  <p>For the <code>batch</code> 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.</p>
+
+  <p>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.</p>
+
+  <p>There are several command line options that control which
+     schema types are treated as ordered. To make an individual
+     type ordered, we use the <code>--ordered-type</code> option,
+     for example:</p>
+
+  <pre class="term">
+--ordered-type batch
+  </pre>
+
+  <p>To automatically treat all the types that are derived from an ordered
+     type also ordered, we use the <code>--ordered-type-derived</code>
+     option. This is primarily useful if you would like to iterate
+     over the complete hierarchy's content using the content order
+     sequence (discussed below).</p>
+
+  <p>Ordered types are also useful for handling mixed content. To
+     automatically mark all the types with mixed content as ordered
+     we use the <code>--ordered-type-mixed</code> option. For more
+     information on handling mixed content see <a href="#2.13">Section
+     2.13, "Mapping for Mixed Content Models"</a>.</p>
+
+  <p>Finally, we can mark all the types in the schema we are
+     compiling with the <code>--ordered-type-all</code> 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information on
+     these options.</p>
+
+  <p>Once a type is marked ordered, C++/Tree alters its mapping
+     in several ways. Firstly, for each local element, element
+     wildcard (<a href="#2.12.4">Section 2.12.4, "Element Wildcard
+     Order"</a>), and mixed content text (<a href="#2.13">Section
+     2.13, "Mapping for Mixed Content Models"</a>) 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 <code>batch</code> class changes
+     once we make it ordered:</p>
+
+  <pre class="c++">
+class batch: public xml_schema::type
+{
+public:
+  // withdraw
+  //
+  typedef withdraw withdraw_type;
+  typedef sequence&lt;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&amp;
+  withdraw () const;
+
+  withdraw_sequence&amp;
+  withdraw ();
+
+  void
+  withdraw (const withdraw_sequence&amp;);
+
+  // deposit
+  //
+  typedef deposit deposit_type;
+  typedef sequence&lt;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&amp;
+  deposit () const;
+
+  deposit_sequence&amp;
+  deposit ();
+
+  void
+  deposit (const deposit_sequence&amp;);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector&lt;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&amp;
+  content_order () const;
+
+  content_order_sequence&amp;
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>Notice the <code>withdraw_id</code> and <code>deposit_id</code>
+     content ids as well as the extra <code>content_order</code>
+     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 <code>content_order</code>
+     sequence while during serialization this sequence is used to
+     determine the order in which content is serialized. The
+     <code>content_order</code> sequence is also copied during
+     copy construction and assigned during copy assignment. It is also
+     taken into account during comparison.</p>
+
+  <p>The entry type of the <code>content_order</code> sequence is the
+     <code>xml_schema::content_order</code> type that has the following
+     interface:</p>
+
+  <pre class="c++">
+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&amp;, const content_order&amp;);
+
+  bool
+  operator!= (const content_order&amp;, const content_order&amp;);
+
+  bool
+  operator&lt; (const content_order&amp;, const content_order&amp;);
+}
+  </pre>
+
+  <p>The <code>content_order</code> 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, <code>withdraw_id</code> or <code>deposit_id</code>
+     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 <code>withdraw_id</code>,
+     then the index will point into the <code>withdraw</code> element
+     sequence.</p>
+
+  <p>With all this information we can now examine how to iterate over
+     transaction in the batch in content order:</p>
+
+  <pre class="c++">
+batch&amp; 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&amp; t (b.withdraw ()[i->index]);
+      cerr &lt;&lt; t.account () &lt;&lt; " withdraw " &lt;&lt; t.amount () &lt;&lt; endl;
+      break;
+    }
+  case batch::deposit_id:
+    {
+      const deposit&amp; t (b.deposit ()[i->index]);
+      cerr &lt;&lt; t.account () &lt;&lt; " deposit " &lt;&lt; t.amount () &lt;&lt; endl;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+  </pre>
+
+  <p>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.</p>
+
+  <p>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:</p>
+
+  <pre class="c++">
+using xml_schema::content_order;
+
+batch::deposit_sequence&amp; d (b.deposit ());
+batch::withdraw_sequence&amp; w (b.withdraw ());
+batch::content_order_sequence&amp; co (b.content_order ());
+
+d.push_back (deposit (123456789, 100000));
+co.push_back (content_order (batch::deposit_id, d.size () - 1));
+  </pre>
+
+  <p>In the above example we first added the content (deposit
+     transaction) and then updated the content order information
+     by adding an entry with <code>deposit_id</code> content
+     id and the index of the just added deposit transaction.</p>
+
+  <p>Removing the last transaction can be easy if we know which
+     transaction (deposit or withdrawal) is last:</p>
+
+  <pre class="c++">
+d.pop_back ();
+co.pop_back ();
+  </pre>
+
+  <p>If, however, we do not know which transaction is last, then
+     things get a bit more complicated:</p>
+
+  <pre class="c++">
+switch (co.back ().id)
+{
+case batch::withdraw_id:
+  {
+    d.pop_back ();
+    break;
+  }
+case batch::deposit_id:
+  {
+    w.pop_back ();
+    break;
+  }
+}
+
+co.pop_back ();
+  </pre>
+
+  <p>The following example shows how to add a transaction at the
+     beginning of the batch:</p>
+
+  <pre class="c++">
+w.push_back (withdraw (123456789, 100000));
+co.insert (co.begin (),
+           content_order (batch::withdraw_id, w.size () - 1));
+  </pre>
+
+  <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 withdrawal:</p>
+
+  <pre class="c++">
+w[0].amount (10000);
+  </pre>
+
+  <p>For the complete working code shown in this section refer to the
+     <code>order/element</code> example in the
+     <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <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 hierarchy. In this case
+     the content order sequence for the derived type contains
+     ordering information for both base and derived content.</p>
+
+  <p>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, <code>std::vector</code>, 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
+     <code>std::vector</code> but also search by the content
+     id as well as the content id and index pair.</p>
+
+  <p>While C++/Tree does not provide this functionality by
+     default, it allows us to specify a custom container
+     type for content order with the <code>--order-container</code>
+     command line option. The only requirement from the
+     generated code side for such a container is to provide
+     the <code>vector</code>-like <code>push_back()</code>,
+     <code>size()</code>, and const iteration interfaces.</p>
+
+  <p>As an example, here is how we can use the Boost Multi-Index
+     container for content order. First we create the
+     <code>content-order-container.hxx</code> header with the
+     following definition:</p>
+
+  <pre class="c++">
+#ifndef CONTENT_ORDER_CONTAINER
+#define CONTENT_ORDER_CONTAINER
+
+#include &lt;cstddef> // std::size_t
+
+#include &lt;boost/multi_index_container.hpp>
+#include &lt;boost/multi_index/member.hpp>
+#include &lt;boost/multi_index/identity.hpp>
+#include &lt;boost/multi_index/ordered_index.hpp>
+#include &lt;boost/multi_index/random_access_index.hpp>
+
+struct by_id {};
+struct by_id_index {};
+
+template &lt;typename T>
+using content_order_container =
+  boost::multi_index::multi_index_container&lt;
+    T,
+    boost::multi_index::indexed_by&lt;
+      boost::multi_index::random_access&lt;>,
+      boost::multi_index::ordered_unique&lt;
+        boost::multi_index::tag&lt;by_id_index>,
+        boost::multi_index::identity&lt;T>
+      >,
+      boost::multi_index::ordered_non_unique&lt;
+        boost::multi_index::tag&lt;by_id>,
+        boost::multi_index::member&lt;T, std::size_t, &amp;T::id>
+      >
+    >
+  >;
+
+#endif
+  </pre>
+
+  <p>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):</p>
+
+  <pre class="term">
+--hxx-prologue '#include "content-order-container.hxx"'
+--order-container content_order_container
+  </pre>
+
+  <p>With these changes we can now use the multi-index functionality,
+     for example, to search for a specific content id:</p>
+
+  <pre class="c++">
+typedef batch::content_order_sequence::index&lt;by_id>::type id_set;
+typedef id_set::iterator id_iterator;
+
+const id_set&amp; ids (b.content_order ().get&lt;by_id> ());
+
+std::pair&lt;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&amp; t (b.deposit ()[i->index]);
+  cerr &lt;&lt; t.account () &lt;&lt; " deposit " &lt;&lt; t.amount () &lt;&lt; endl;
+}
+  </pre>
+
+  <h2><a name="2.9">2.9 Mapping for Global Elements</a></h2>
+
+  <p>An XML Schema element definition is called global if it appears
+     directly under the <code>schema</code> 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
+     <a href="#2.9.1">Section 2.9.1, "Element Types"</a> 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 <a href="#2.9.2">Section 2.9.2, "Element Map"</a>
+     for details.
+  </p>
+
+  <p>The parsing functions read XML instance documents and return
+     corresponding object models as an automatic pointer
+     (<code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     depending on the C++ standard selected). Their signatures
+     have the following pattern (<code>type</code> denotes
+     element's type and <code>name</code> denotes element's
+     name):
+  </p>
+
+  <pre class="c++">
+std::[unique|auto]_ptr&lt;type>
+name (....);
+  </pre>
+
+  <p>The process of parsing, including the exact signatures of the parsing
+     functions, is the subject of <a href="#3">Chapter 3, "Parsing"</a>.
+  </p>
+
+  <p>The serialization functions write object models back to XML instance
+     documents. Their signatures have the following pattern:
+  </p>
+
+  <pre class="c++">
+void
+name (&lt;stream type>&amp;, const type&amp;, ....);
+  </pre>
+
+  <p>The process of serialization, including the exact signatures of the
+     serialization functions, is the subject of <a href="#4">Chapter 4,
+     "Serialization"</a>.
+  </p>
+
+
+  <h3><a name="2.9.1">2.9.1 Element Types</a></h3>
+
+  <p>The generation of element types is requested with the
+     <code>--generate-element-type</code> 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
+     <code>xml_schema::element_type</code> 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 <code>"value"</code>. 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="type">
+  &lt;sequence>
+    ...
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="type"/>
+  </pre>
+
+<p>is mapped to:</p>
+
+  <pre class="c++">
+class type
+{
+  ...
+};
+
+class root: public xml_schema::element_type
+{
+public:
+  // Element value.
+  //
+  typedef type value_type;
+
+  const value_type&amp;
+  value () const;
+
+  value_type&amp;
+  value ();
+
+  void
+  value (const value_type&amp;);
+
+  void
+  value (std::[unique|auto]_ptr&lt;value_type>);
+
+  // Constructors.
+  //
+  root (const value_type&amp;);
+
+  root (std::[unique|auto]_ptr&lt;value_type>);
+
+  root (const xercesc::DOMElement&amp;, xml_schema::flags = 0);
+
+  root (const root&amp;, xml_schema::flags = 0);
+
+  virtual root*
+  _clone (xml_schema::flags = 0) const;
+
+  // Element name and namespace.
+  //
+  static const std::string&amp;
+  name ();
+
+  static const std::string&amp;
+  namespace_ ();
+
+  virtual const std::string&amp;
+  _name () const;
+
+  virtual const std::string&amp;
+  _namespace () const;
+
+  // Element value as xml_schema::type.
+  //
+  virtual const xml_schema::type*
+  _value () const;
+
+  virtual xml_schema::type*
+  _value ();
+};
+
+void
+operator&lt;&lt; (xercesc::DOMElement&amp;, const root&amp;);
+  </pre>
+
+  <p>The <code>xml_schema::element_type</code> class is a common
+     base type for all element types and is defined as follows:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class element_type
+  {
+  public:
+    virtual
+    ~element_type ();
+
+    virtual element_type*
+    _clone (flags f = 0) const = 0;
+
+    virtual const std::basic_string&lt;C>&amp;
+    _name () const = 0;
+
+    virtual const std::basic_string&lt;C>&amp;
+    _namespace () const = 0;
+
+    virtual xml_schema::type*
+    _value () = 0;
+
+    virtual const xml_schema::type*
+    _value () const = 0;
+  };
+}
+  </pre>
+
+  <p>The <code>_value()</code> 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 <code>xml_schema::type</code>.
+  </p>
+
+  <p>Unlike parsing and serialization functions, element types
+     are only capable of parsing and serializing from/to a
+     <code>DOMElement</code> 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.</p>
+
+
+  <h3><a name="2.9.2">2.9.2 Element Map</a></h3>
+
+  <p>When element types are generated for root elements it is also
+     possible to request the generation of an element map with the
+     <code>--generate-element-map</code> option. The element map
+     allows uniform parsing and serialization of multiple root
+     elements via the common <code>xml_schema::element_type</code>
+     base type. The <code>xml_schema::element_map</code> class is
+     defined as follows:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class element_map
+  {
+  public:
+    static std::[unique|auto]_ptr&lt;xml_schema::element_type>
+    parse (const xercesc::DOMElement&amp;, flags = 0);
+
+    static void
+    serialize (xercesc::DOMElement&amp;, const element_type&amp;);
+  };
+}
+  </pre>
+
+  <p>The <code>parse()</code> function creates the corresponding
+     element type object based on the element name and namespace
+     and returns it as an automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, depending on the C++ standard
+     selected) to <code>xml_schema::element_type</code>.
+     The <code>serialize()</code> function serializes the passed element
+     object to <code>DOMElement</code>. Note that in case of
+     <code>serialize()</code>, the <code>DOMElement</code> object
+     should have the correct name and namespace. If no element type is
+     available for an element, both functions throw the
+     <code>xml_schema::no_element_info</code> exception:</p>
+
+  <pre class="c++">
+struct no_element_info: virtual exception
+{
+  no_element_info (const std::basic_string&lt;C>&amp; element_name,
+                   const std::basic_string&lt;C>&amp; element_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  element_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  element_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The application can discover the actual type of the element
+     object returned by <code>parse()</code> either using
+     <code>dynamic_cast</code> or by comparing element names and
+     namespaces. The following code fragments illustrate how the
+     element map can be used:</p>
+
+  <pre class="c++">
+// Parsing.
+//
+DOMElement&amp; e = ... // Parse XML to DOM.
+
+unique_ptr&lt;xml_schema::element_type> r (
+  xml_schema::element_map::parse (e));
+
+if (root1 r1 = dynamic_cast&lt;root1*> (r.get ()))
+{
+  ...
+}
+else if (r->_name == root2::name () &amp;&amp;
+         r->_namespace () == root2::namespace_ ())
+{
+  root2&amp; r2 (static_cast&lt;root2&amp;> (*r));
+
+  ...
+}
+  </pre>
+
+  <pre class="c++">
+// Serialization.
+//
+xml_schema::element_type&amp; r = ...
+
+string name (r._name ());
+string ns (r._namespace ());
+
+DOMDocument&amp; doc = ... // Create a new DOMDocument with name and ns.
+DOMElement&amp; e (*doc->getDocumentElement ());
+
+xml_schema::element_map::serialize (e, r);
+
+// Serialize DOMDocument to XML.
+  </pre>
+
+  <!-- -->
+
+  <h2><a name="2.10">2.10 Mapping for Global Attributes</a></h2>
+
+  <p>An XML Schema attribute definition is called global if it appears
+     directly under the <code>schema</code> element. A global
+     attribute does not have any mapping.
+  </p>
+
+  <!--
+     When it is referenced from
+     a local attribute definition (using the <code>ref</code> attribute)
+     it is treated as a local attribute (see Section 2.8, "Mapping for
+     Local Elements and Attributes").
+  -->
+
+  <h2><a name="2.11">2.11 Mapping for <code>xsi:type</code> and Substitution
+      Groups</a></h2>
+
+  <p>The mapping provides optional support for the XML Schema polymorphism
+     features (<code>xsi:type</code> and substitution groups) which can
+     be requested with the <code>--generate-polymorphic</code> option.
+     When used, the dynamic type of a member may be different from
+     its static type. Consider the following schema definition and
+     instance document:
+  </p>
+
+  <pre class="xml">
+&lt;!-- test.xsd -->
+&lt;schema>
+  &lt;complexType name="base">
+    &lt;attribute name="text" type="string"/>
+  &lt;/complexType>
+
+  &lt;complexType name="derived">
+    &lt;complexContent>
+      &lt;extension base="base">
+        &lt;attribute name="extra-text" type="string"/>
+      &lt;/extension>
+    &lt;/complexContent>
+  &lt;/complexType>
+
+  &lt;complexType name="root_type">
+    &lt;sequence>
+      &lt;element name="item" type="base" maxOccurs="unbounded"/>
+    &lt;/sequence>
+  &lt;/complexType>
+
+  &lt;element name="root" type="root_type"/>
+&lt;/schema>
+
+&lt;!-- test.xml -->
+&lt;root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  &lt;item text="hello"/>
+  &lt;item text="hello" extra-text="world" xsi:type="derived"/>
+&lt;/root>
+  </pre>
+
+  <p>In the resulting object model, the container for
+     the <code>root::item</code> member will have two elements:
+     the first element's type will be <code>base</code> while
+     the second element's (dynamic) type will be
+     <code>derived</code>. This can be discovered using the
+     <code>dynamic_cast</code> operator as shown in the following
+     example:
+  </p>
+
+  <pre class="c++">
+void
+f (root&amp; r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    if (derived* d = dynamic_cast&lt;derived*> (&amp;(*i)))
+    {
+      // derived
+    }
+    else
+    {
+      // base
+    }
+  }
+}
+  </pre>
+
+  <p>The <code>_clone</code> virtual function should be used instead of
+     copy constructors to make copies of members that might use
+     polymorphism:
+  </p>
+
+  <pre class="c++">
+void
+f (root&amp; r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    std::unique_ptr&lt;base> c (i->_clone ());
+  }
+}
+  </pre>
+
+  <p>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 <code>--polymorphic-type</code> 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:</p>
+
+  <pre class="xml">
+&lt;!-- base.xsd -->
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="base">
+    &lt;xs:sequence>
+      &lt;xs:element name="b" type="xs:int"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;!-- substitution group root -->
+  &lt;xs:element name="base" type="base"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <pre class="xml">
+&lt;!-- derived.xsd -->
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;include schemaLocation="base.xsd"/>
+
+  &lt;xs:complexType name="derived">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="base">
+        &lt;xs:sequence>
+          &lt;xs:element name="d" type="xs:string"/>
+        &lt;/xs:sequence>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="derived" type="derived" substitutionGroup="base"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>In this example we need to specify "<code>--polymorphic-type base</code>"
+     when compiling both schemas because the substitution group is declared
+     in a schema other than the one defining type <code>base</code>.</p>
+
+  <p>You can also indicate that all types should be treated as polymorphic
+     with the <code>--polymorphic-type-all</code>. However, this may result
+     in slower generated code with a greater footprint.</p>
+
+
+  <!-- Mapping for any and anyAttribute -->
+
+
+  <h2><a name="2.12">2.12 Mapping for <code>any</code> and <code>anyAttribute</code></a></h2>
+
+  <p>For the XML Schema <code>any</code> and <code>anyAttribute</code>
+     wildcards an optional mapping can be requested with the
+     <code>--generate-wildcard</code> 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 <a href="#3.1">Section 3.1,
+     "Initializing the Xerces-C++ Runtime"</a>.
+  </p>
+
+  <p>The mapping for <code>any</code> is similar to the mapping for
+     local elements (see <a href="#2.8">Section 2.8, "Mapping for Local
+     Elements and Attributes"</a>) except that the type used in the
+     wildcard mapping is <code>xercesc::DOMElement</code>. As with local
+     elements, the mapping divides all possible cardinality combinations
+     into three cardinality classes: <i>one</i>, <i>optional</i>, and
+     <i>sequence</i>.
+  </p>
+
+  <p>The mapping for <code>anyAttribute</code> represents the attributes
+     matched by this wildcard as a set of <code>xercesc::DOMAttr</code>
+     objects with a key being the attribute's name and namespace.</p>
+
+  <p>Similar to local elements and attributes, the <code>any</code> and
+     <code>anyAttribute</code> 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 <code>"any"</code>
+     for the <code>any</code> wildcard and <code>"any_attribute"</code>
+     for the <code>anyAttribute</code> wildcard. The accessor and modifier
+     functions are named <code>"any"</code> for the <code>any</code> wildcard
+     and <code>"any_attribute"</code> for the <code>anyAttribute</code>
+     wildcard. Subsequent wildcards in the same type have escaped names
+     such as <code>"any1"</code> or <code>"any_attribute1"</code>.
+  </p>
+
+  <p>Because Xerces-C++ DOM nodes always belong to a <code>DOMDocument</code>,
+     each type with a wildcard has an associated <code>DOMDocument</code>
+     object. The reference to this object can be obtained using the accessor
+     function called <code>dom_document</code>. The access to the document
+     object from the application code may be necessary to create or modify
+     the wildcard content. For example:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other"/>
+  &lt;/sequence>
+  &lt;anyAttribute namespace="##other"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // any
+  //
+  const xercesc::DOMElement&amp;
+  any () const;
+
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  ...
+
+  // 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&amp;
+  any_attribute () const;
+
+  any_attribute_set&amp;
+  any_attribute ();
+
+  ...
+
+  // DOMDocument object for wildcard content.
+  //
+  const xercesc::DOMDocument&amp;
+  dom_document () const;
+
+  xercesc::DOMDocument&amp;
+  dom_document ();
+
+  ...
+};
+  </pre>
+
+
+  <p>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 <code>any</code>
+     wildcard. They are described in the following sub-sections.
+  </p>
+
+
+  <h3><a name="2.12.1">2.12.1 Mapping for <code>any</code> with the One Cardinality Class</a></h3>
+
+  <p>For <code>any</code> 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 <code>xercesc::DOMElement</code> and
+     can be used for read-only access. The non-constant version returns
+     an unrestricted reference to <code>xercesc::DOMElement</code> and can
+     be used for read-write access.
+  </p>
+
+  <p>The first modifier function expects an argument of type reference
+     to constant <code>xercesc::DOMElement</code> and makes a deep copy
+     of its argument. The second modifier function expects an argument of
+     type pointer to <code>xercesc::DOMElement</code>. 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:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Accessors.
+  //
+  const xercesc::DOMElement&amp;
+  any () const;
+
+  xercesc::DOMElement&amp;
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  void
+  any (xercesc::DOMElement*);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  DOMElement&amp; e1 (o.any ());             // get
+  o.any (e)                              // set, deep copy
+  DOMDocument&amp; doc (o.dom_document ());
+  o.any (doc.createElement (...));       // set, assumes ownership
+}
+  </pre>
+
+  <h3><a name="2.12.2">2.12.2 Mapping for <code>any</code> with the Optional Cardinality Class</a></h3>
+
+  <p>For <code>any</code> with the Optional cardinality class, the type
+     definitions consist of an alias for the container type with name
+     <code>any_optional</code> (or <code>any1_optional</code>, etc., for
+     subsequent wildcards in the type definition).
+  </p>
+
+  <p>Unlike accessor functions for the One cardinality class, accessor
+     functions for the Optional cardinality class return references to
+     corresponding containers rather than directly to <code>DOMElement</code>.
+     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.
+  </p>
+
+  <p>The modifier functions are overloaded for <code>xercesc::DOMElement</code>
+     and the container type. The first modifier function expects an argument of
+     type reference to constant <code>xercesc::DOMElement</code> and
+     makes a deep copy of its argument. The second modifier function
+     expects an argument of type pointer to <code>xercesc::DOMElement</code>.
+     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:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other" minOccurs="0"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_optional any_optional;
+
+  // Accessors.
+  //
+  const any_optional&amp;
+  any () const;
+
+  any_optional&amp;
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  void
+  any (xercesc::DOMElement*);
+
+  void
+  any (const any_optional&amp;);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The <code>element_optional</code> container is a
+     specialization of the <code>optional</code> class template described
+     in <a href="#2.8.2">Section 2.8.2, "Mapping for Members with the Optional
+     Cardinality Class"</a>. Its interface is presented below:
+  </p>
+
+  <pre class="c++">
+class element_optional
+{
+public:
+  explicit
+  element_optional (xercesc::DOMDocument&amp;);
+
+  // Makes a deep copy.
+  //
+  element_optional (const xercesc::DOMElement&amp;, xercesc::DOMDocument&amp;);
+
+  // Assumes ownership.
+  //
+  element_optional (xercesc::DOMElement*, xercesc::DOMDocument&amp;);
+
+  element_optional (const element_optional&amp;, xercesc::DOMDocument&amp;);
+
+public:
+  element_optional&amp;
+  operator= (const xercesc::DOMElement&amp;);
+
+  element_optional&amp;
+  operator= (const element_optional&amp;);
+
+  // Pointer-like interface.
+  //
+public:
+  const xercesc::DOMElement*
+  operator-> () const;
+
+  xercesc::DOMElement*
+  operator-> ();
+
+  const xercesc::DOMElement&amp;
+  operator* () const;
+
+  xercesc::DOMElement&amp;
+  operator* ();
+
+  typedef void (element_optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const xercesc::DOMElement&amp;
+  get () const;
+
+  xercesc::DOMElement&amp;
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  set (xercesc::DOMElement*);
+
+  void
+  reset ();
+};
+
+bool
+operator== (const element_optional&amp;, const element_optional&amp;);
+
+bool
+operator!= (const element_optional&amp;, const element_optional&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  DOMDocument&amp; doc (o.dom_document ());
+
+  if (o.any ().present ())                  // test
+  {
+    DOMElement&amp; 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&amp; e1 (*o.any ());             // get
+    o.any (e);                              // set, deep copy
+    o.any (doc.createElement (...));        // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+}
+  </pre>
+
+
+
+  <h3><a name="2.12.3">2.12.3 Mapping for <code>any</code> with the Sequence Cardinality Class</a></h3>
+
+  <p>For <code>any</code> with the Sequence cardinality class, the type
+     definitions consist of an alias of the container type with name
+     <code>any_sequence</code> (or <code>any1_sequence</code>, etc., for
+     subsequent wildcards in the type definition), an alias of the iterator
+     type with name <code>any_iterator</code> (or <code>any1_iterator</code>,
+     etc., for subsequent wildcards in the type definition), and an alias
+     of the constant iterator type with name <code>any_const_iterator</code>
+     (or <code>any1_const_iterator</code>, etc., for subsequent wildcards
+     in the type definition).
+  </p>
+
+  <p>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.
+  </p>
+
+  <p>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:
+  </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other" minOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+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&amp;
+  any () const;
+
+  any_sequence&amp;
+  any ();
+
+  // Modifier.
+  //
+  void
+  any (const any_sequence&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>element_sequence</code> container is a
+     specialization of the <code>sequence</code> class template described
+     in <a href="#2.8.3">Section 2.8.3, "Mapping for Members with the
+     Sequence Cardinality Class"</a>. 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:
+  </p>
+
+  <pre class="c++">
+class element_sequence
+{
+public:
+  typedef xercesc::DOMElement        value_type;
+  typedef xercesc::DOMElement*       pointer;
+  typedef const xercesc::DOMElement* const_pointer;
+  typedef xercesc::DOMElement&amp;       reference;
+  typedef const xercesc::DOMElement&amp; const_reference;
+
+  typedef &lt;implementation-defined>   iterator;
+  typedef &lt;implementation-defined>   const_iterator;
+  typedef &lt;implementation-defined>   reverse_iterator;
+  typedef &lt;implementation-defined>   const_reverse_iterator;
+
+  typedef &lt;implementation-defined>   size_type;
+  typedef &lt;implementation-defined>   difference_type;
+  typedef &lt;implementation-defined>   allocator_type;
+
+public:
+  explicit
+  element_sequence (xercesc::DOMDocument&amp;);
+
+  // DOMElement cannot be default-constructed.
+  //
+  // explicit
+  // element_sequence (size_type n);
+
+  element_sequence (size_type n,
+                    const xercesc::DOMElement&amp;,
+                    xercesc::DOMDocument&amp;);
+
+  template &lt;typename I>
+  element_sequence (const I&amp; begin,
+                    const I&amp; end,
+                    xercesc::DOMDocument&amp;);
+
+  element_sequence (const element_sequence&amp;, xercesc::DOMDocument&amp;);
+
+  element_sequence&amp;
+  operator= (const element_sequence&amp;);
+
+public:
+  void
+  assign (size_type n, const xercesc::DOMElement&amp;);
+
+  template &lt;typename I>
+  void
+  assign (const I&amp; begin, const I&amp; 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&amp;);
+
+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&amp;
+  operator[] (size_type);
+
+  const xercesc::DOMElement&amp;
+  operator[] (size_type) const;
+
+  xercesc::DOMElement&amp;
+  at (size_type);
+
+  const xercesc::DOMElement&amp;
+  at (size_type) const;
+
+  xercesc::DOMElement&amp;
+  front ();
+
+  const xercesc::DOMElement&amp;
+  front () const;
+
+  xercesc::DOMElement&amp;
+  back ();
+
+  const xercesc::DOMElement&amp;
+  back () const;
+
+public:
+  // Makes a deep copy.
+  //
+  void
+  push_back (const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  push_back (xercesc::DOMElement*);
+
+  void
+  pop_back ();
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMElement*);
+
+  void
+  insert (iterator position, size_type n, const xercesc::DOMElement&amp;);
+
+  template &lt;typename I>
+  void
+  insert (iterator position, const I&amp; begin, const I&amp; 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&amp; x);
+};
+
+inline bool
+operator== (const element_sequence&amp;, const element_sequence&amp;);
+
+inline bool
+operator!= (const element_sequence&amp;, const element_sequence&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  object::any_sequence&amp; s (o.any ());
+
+  // Iteration.
+  //
+  for (object::any_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMElement&amp; e (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back (e);                       // deep copy
+  DOMDocument&amp; doc (o.dom_document ());
+  s.push_back (doc.createElement (...)); // assumes ownership
+}
+  </pre>
+
+  <h3><a name="2.12.4">2.12.4 Element Wildcard Order</a></h3>
+
+  <p>Similar to elements, element wildcards in ordered types
+     (<a href="#2.8.4">Section 2.8.4, "Element Order"</a>) 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="batch">
+  &lt;choice minOccurs="0" maxOccurs="unbounded">
+    &lt;element name="withdraw" type="withdraw"/>
+    &lt;element name="deposit" type="deposit"/>
+    &lt;any namespace="##other" processContents="lax"/>
+  &lt;/choice>
+&lt;/complexType>
+  </pre>
+
+  <p>This will lead to the following changes in the generated
+     <code>batch</code> C++ class:</p>
+
+  <pre class="c++">
+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&amp;
+  any () const;
+
+  any_sequence&amp;
+  any ();
+
+  void
+  any (const any_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>With this change we also need to update the iteration code to handle
+     the new content id:</p>
+
+  <pre class="c++">
+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&amp; e (b.any ()[i->index]);
+      ...
+      break;
+    }
+
+    ...
+  }
+}
+  </pre>
+
+  <p>For the complete working code that shows the use of wildcards in
+     ordered types refer to the <code>order/element</code> example in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <h3><a name="2.12.5">2.12.5 Mapping for <code>anyAttribute</code></a></h3>
+
+  <p>For <code>anyAttribute</code> the type definitions consist of an alias
+     of the container type with name <code>any_attribute_set</code>
+     (or <code>any1_attribute_set</code>, etc., for subsequent wildcards
+     in the type definition), an alias of the iterator type with name
+     <code>any_attribute_iterator</code> (or <code>any1_attribute_iterator</code>,
+     etc., for subsequent wildcards in the type definition), and an alias
+     of the constant iterator type with name <code>any_attribute_const_iterator</code>
+     (or <code>any1_attribute_const_iterator</code>, etc., for subsequent
+     wildcards in the type definition).
+  </p>
+
+  <p>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.
+  </p>
+
+  <p>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:
+  </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    ...
+  &lt;/sequence>
+  &lt;anyAttribute namespace="##other"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+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&amp;
+  any_attribute () const;
+
+  any_attribute_set&amp;
+  any_attribute ();
+
+  // Modifier.
+  //
+  void
+  any_attribute (const any_attribute_set&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>attribute_set</code> class is an associative container
+     similar to the <code>std::set</code> 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 <code>std::set</code>, <code>attribute_set</code>
+     allows searching using names and namespaces instead of
+     <code>xercesc::DOMAttr</code> objects. It is defined in an
+     implementation-specific namespace and its interface is presented
+     below:
+  </p>
+
+  <pre class="c++">
+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&amp;        reference;
+  typedef const xercesc::DOMAttr&amp;  const_reference;
+
+  typedef &lt;implementation-defined> iterator;
+  typedef &lt;implementation-defined> const_iterator;
+  typedef &lt;implementation-defined> reverse_iterator;
+  typedef &lt;implementation-defined> const_reverse_iterator;
+
+  typedef &lt;implementation-defined> size_type;
+  typedef &lt;implementation-defined> difference_type;
+  typedef &lt;implementation-defined> allocator_type;
+
+public:
+  attribute_set (xercesc::DOMDocument&amp;);
+
+  template &lt;typename I>
+  attribute_set (const I&amp; begin, const I&amp; end, xercesc::DOMDocument&amp;);
+
+  attribute_set (const attribute_set&amp;, xercesc::DOMDocument&amp;);
+
+  attribute_set&amp;
+  operator= (const attribute_set&amp;);
+
+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&lt;iterator, bool>
+  insert (const xercesc::DOMAttr&amp;);
+
+  // Assumes ownership.
+  //
+  std::pair&lt;iterator, bool>
+  insert (xercesc::DOMAttr*);
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMAttr&amp;);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMAttr*);
+
+  template &lt;typename I>
+  void
+  insert (const I&amp; begin, const I&amp; end);
+
+public:
+  void
+  erase (iterator position);
+
+  size_type
+  erase (const std::basic_string&lt;C>&amp; name);
+
+  size_type
+  erase (const std::basic_string&lt;C>&amp; namespace_,
+         const std::basic_string&lt;C>&amp; 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&lt;C>&amp; name) const;
+
+  size_type
+  count (const std::basic_string&lt;C>&amp; namespace_,
+         const std::basic_string&lt;C>&amp; 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&lt;C>&amp; name);
+
+  iterator
+  find (const std::basic_string&lt;C>&amp; namespace_,
+        const std::basic_string&lt;C>&amp; name);
+
+  iterator
+  find (const XMLCh* name);
+
+  iterator
+  find (const XMLCh* namespace_, const XMLCh* name);
+
+  const_iterator
+  find (const std::basic_string&lt;C>&amp; name) const;
+
+  const_iterator
+  find (const std::basic_string&lt;C>&amp; namespace_,
+        const std::basic_string&lt;C>&amp; 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&amp;);
+};
+
+bool
+operator== (const attribute_set&amp;, const attribute_set&amp;);
+
+bool
+operator!= (const attribute_set&amp;, const attribute_set&amp;);
+  </pre>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMAttr&amp; a)
+{
+  using namespace xercesc;
+
+  object::any_attribute_set&amp; s (o.any_attribute ());
+
+  // Iteration.
+  //
+  for (object::any_attribute_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMAttr&amp; a (*i);
+  }
+
+  // Modification.
+  //
+  s.insert (a);                         // deep copy
+  DOMDocument&amp; 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");
+}
+  </pre>
+
+  <!-- Mapping for Mixed Content Models -->
+
+  <h2><a name="2.13">2.13 Mapping for Mixed Content Models</a></h2>
+
+  <p>For XML Schema types with mixed content models C++/Tree provides
+     mapping support only if the type is marked as ordered
+     (<a href="#2.8.4">Section 2.8.4, "Element Order"</a>). Use the
+     <code>--ordered-type-mixed</code> XSD compiler option to
+     automatically mark all types with mixed content as ordered.</p>
+
+  <p>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.</p>
+
+  <p>As an example, consider the following schema that describes text
+     with embedded links:</p>
+
+  <pre class="xml">
+&lt;complexType name="anchor">
+  &lt;simpleContent>
+    &lt;extension base="string">
+      &lt;attribute name="href" type="anyURI" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+
+&lt;complexType name="text" mixed="true">
+  &lt;sequence>
+    &lt;element name="a" type="anchor" minOccurs="0" maxOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>The generated <code>text</code> C++ class will provide the following
+     API (assuming it is marked as ordered):</p>
+
+  <pre class="c++">
+class text: public xml_schema::type
+{
+public:
+  // a
+  //
+  typedef anchor a_type;
+  typedef sequence&lt;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&amp;
+  a () const;
+
+  a_sequence&amp;
+  a ();
+
+  void
+  a (const a_sequence&amp;);
+
+  // text_content
+  //
+  typedef xml_schema::string text_content_type;
+  typedef sequence&lt;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&amp;
+  text_content () const;
+
+  text_content_sequence&amp;
+  text_content ();
+
+  void
+  text_content (const text_content_sequence&amp;);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector&lt;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&amp;
+  content_order () const;
+
+  content_order_sequence&amp;
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>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.</p>
+
+  <pre class="c++">
+const text&amp; 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&amp; a (t.a ()[i->index]);
+      cerr &lt;&lt; a &lt;&lt; "[" &lt;&lt; a.href () &lt;&lt; "]";
+      break;
+    }
+  case text::text_content_id:
+    {
+      const xml_schema::string&amp; s (t.text_content ()[i->index]);
+      cerr &lt;&lt; s;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+  </pre>
+
+  <p>For the complete working code that shows the use of mixed content
+     in ordered types refer to the <code>order/mixed</code> example in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <!-- Parsing -->
+
+
+  <h1><a name="3">3 Parsing</a></h1>
+
+  <p>This chapter covers various aspects of parsing XML instance
+     documents in order to obtain corresponding tree-like object
+     model.
+  </p>
+
+  <p>Each global XML Schema element in the form:</p>
+
+  <pre class="xml">
+&lt;element name="name" type="type"/>
+  </pre>
+
+  <p>is mapped to 14 overloaded C++ functions in the form:</p>
+
+  <pre class="c++">
+// Read from a URI or a local file.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from std::istream.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from InputSource.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from DOM.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (const xercesc::DOMDocument&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xml_schema::dom::[unique|auto]_ptr&lt;xercesc::DOMDocument>,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+  </pre>
+
+  <p>You can choose between reading an XML instance from a local file,
+     URI, <code>std::istream</code>, <code>xercesc::InputSource</code>,
+     or a pre-parsed DOM instance in the form of
+     <code>xercesc::DOMDocument</code>. All the parsing functions
+     return a dynamically allocated object model as either
+     <code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     depending on the C++ standard selected. Each of these parsing
+     functions is discussed in more detail in the following sections.
+  </p>
+
+  <h2><a name="3.1">3.1 Initializing the Xerces-C++ Runtime</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>You can instruct parsing functions that initialize and terminate
+     the runtime not to do so by passing the
+     <code>xml_schema::flags::dont_initialize</code> flag (see
+     <a href="#3.2">Section 3.2, "Flags and Properties"</a>).
+  </p>
+
+
+  <h2><a name="3.2">3.2 Flags and Properties</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <p>The following flags are recognized by the parsing functions:</p>
+
+  <dl>
+    <dt><code>xml_schema::flags::keep_dom</code></dt>
+    <dd>Keep association between DOM nodes and the resulting
+        object model nodes. For more information about DOM association
+        refer to <a href="#5.1">Section 5.1, "DOM Association"</a>.</dd>
+
+    <dt><code>xml_schema::flags::own_dom</code></dt>
+    <dd>Assume ownership of the DOM document passed. This flag only
+        makes sense together with the <code>keep_dom</code> flag in
+        the call to the parsing function with the
+        <code>xml_schema::dom::[unique|auto]_ptr&lt;DOMDocument></code>
+        argument.</dd>
+
+    <dt><code>xml_schema::flags::dont_validate</code></dt>
+    <dd>Do not validate instance documents against schemas.</dd>
+
+    <dt><code>xml_schema::flags::dont_initialize</code></dt>
+    <dd>Do not initialize the Xerces-C++ runtime.</dd>
+  </dl>
+
+  <p>You can pass several flags by combining them using the bit-wise OR
+     operator. For example:</p>
+
+  <pre class="c++">
+using xml_schema::flags;
+
+std::unique_ptr&lt;type> r (
+  name ("test.xml", flags::keep_dom | flags::dont_validate));
+  </pre>
+
+  <p>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
+     <code>xml_schema</code> namespace is thrown (see
+     <a href="#3.3">Section 3.3, "Error Handling"</a>).
+  </p>
+
+  <p>For more information on the Xerces-C++ runtime initialization
+     refer to <a href="#3.1">Section 3.1, "Initializing the Xerces-C++
+     Runtime"</a>.
+  </p>
+
+  <p>The <code>xml_schema::properties</code> class allows you to
+     programmatically specify schema locations to be used instead
+     of those specified with the <code>xsi::schemaLocation</code>
+     and <code>xsi::noNamespaceSchemaLocation</code> attributes
+     in instance documents. The interface of the <code>properties</code>
+     class is presented below:
+  </p>
+
+  <pre class="c++">
+class properties
+{
+public:
+  void
+  schema_location (const std::basic_string&lt;C>&amp; namespace_,
+                   const std::basic_string&lt;C>&amp; location);
+  void
+  no_namespace_schema_location (const std::basic_string&lt;C>&amp; location);
+};
+  </pre>
+
+  <p>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
+     <code>file:///absolute/path/to/your/schema</code> as the location
+     argument.
+  </p>
+
+  <h2><a name="3.3">3.3 Error Handling</a></h2>
+
+  <p>As discussed in <a href="#2.2">Section 2.2, "Error Handling"</a>,
+     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.</p>
+
+  <p>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.</p>
+
+  <p>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
+     <code>xml_schema::parsing</code> 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 <code>xml_schema::error_handler</code>
+     and <code>xercesc::DOMErrorHandler</code>. For more information
+     on the <code>xercesc::DOMErrorHandler</code> interface refer to
+     the Xerces-C++ documentation. The <code>xml_schema::error_handler</code>
+     interface is presented below:
+  </p>
+
+  <pre class="c++">
+class error_handler
+{
+public:
+  struct severity
+  {
+    enum value
+    {
+      warning,
+      error,
+      fatal
+    };
+  };
+
+  virtual bool
+  handle (const std::basic_string&lt;C>&amp; id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string&lt;C>&amp; message) = 0;
+
+  virtual
+  ~error_handler ();
+};
+  </pre>
+
+  <p>The <code>id</code> argument of the <code>error_handler::handle</code>
+     function identifies the resource being parsed (e.g., a file name or
+     URI).
+  </p>
+
+  <p>By returning <code>true</code> from the <code>handle</code> function
+     you instruct the parser to recover and continue parsing. Returning
+     <code>false</code> results in termination of the parsing process.
+     An error with the <code>fatal</code> severity level results in
+     termination of the parsing process no matter what is returned from
+     the <code>handle</code> function. It is safe to throw an exception
+     from the <code>handle</code> function.
+  </p>
+
+  <p>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.
+  </p>
+
+
+  <h3><a name="3.3.1">3.3.1 <code>xml_schema::parsing</code></a></h3>
+
+  <pre class="c++">
+struct severity
+{
+  enum value
+  {
+    warning,
+    error
+  };
+
+  severity (value);
+  operator value () const;
+};
+
+struct error
+{
+  error (severity,
+         const std::basic_string&lt;C>&amp; id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string&lt;C>&amp; message);
+
+  severity
+  severity () const;
+
+  const std::basic_string&lt;C>&amp;
+  id () const;
+
+  unsigned long
+  line () const;
+
+  unsigned long
+  column () const;
+
+  const std::basic_string&lt;C>&amp;
+  message () const;
+};
+
+std::basic_ostream&lt;C>&amp;
+operator&lt;&lt; (std::basic_ostream&lt;C>&amp;, const error&amp;);
+
+struct diagnostics: std::vector&lt;error>
+{
+};
+
+std::basic_ostream&lt;C>&amp;
+operator&lt;&lt; (std::basic_ostream&lt;C>&amp;, const diagnostics&amp;);
+
+struct parsing: virtual exception
+{
+  parsing ();
+  parsing (const diagnostics&amp;);
+
+  const diagnostics&amp;
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::parsing</code> 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 <code>diagnostics</code> function. The usual conditions when
+     this exception is thrown include malformed XML instances and, if
+     validation is turned on, invalid instance documents.
+  </p>
+
+  <h3><a name="3.3.2">3.3.2 <code>xml_schema::expected_element</code></a></h3>
+
+  <pre class="c++">
+struct expected_element: virtual exception
+{
+  expected_element (const std::basic_string&lt;C>&amp; name,
+                    const std::basic_string&lt;C>&amp; namespace_);
+
+
+  const std::basic_string&lt;C>&amp;
+  name () const;
+
+  const std::basic_string&lt;C>&amp;
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_element</code> 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 <code>name</code> and <code>namespace_</code> functions respectively.
+  </p>
+
+
+  <h3><a name="3.3.3">3.3.3 <code>xml_schema::unexpected_element</code></a></h3>
+
+  <pre class="c++">
+struct unexpected_element: virtual exception
+{
+  unexpected_element (const std::basic_string&lt;C>&amp; encountered_name,
+                      const std::basic_string&lt;C>&amp; encountered_namespace,
+                      const std::basic_string&lt;C>&amp; expected_name,
+                      const std::basic_string&lt;C>&amp; expected_namespace)
+
+
+  const std::basic_string&lt;C>&amp;
+  encountered_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  encountered_namespace () const;
+
+
+  const std::basic_string&lt;C>&amp;
+  expected_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  expected_namespace () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::unexpected_element</code> 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 <code>encountered_name</code> and
+     <code>encountered_namespace</code> functions respectively. If an
+     element was expected instead of the encountered one, its name
+     and namespace can be obtained using the <code>expected_name</code> and
+     <code>expected_namespace</code> functions respectively. Otherwise
+     these functions return empty strings.
+  </p>
+
+  <h3><a name="3.3.4">3.3.4 <code>xml_schema::expected_attribute</code></a></h3>
+
+  <pre class="c++">
+struct expected_attribute: virtual exception
+{
+  expected_attribute (const std::basic_string&lt;C>&amp; name,
+                      const std::basic_string&lt;C>&amp; namespace_);
+
+
+  const std::basic_string&lt;C>&amp;
+  name () const;
+
+  const std::basic_string&lt;C>&amp;
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_attribute</code> 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 <code>name</code> and <code>namespace_</code> functions respectively.
+  </p>
+
+
+  <h3><a name="3.3.5">3.3.5 <code>xml_schema::unexpected_enumerator</code></a></h3>
+
+  <pre class="c++">
+struct unexpected_enumerator: virtual exception
+{
+  unexpected_enumerator (const std::basic_string&lt;C>&amp; enumerator);
+
+  const std::basic_string&lt;C>&amp;
+  enumerator () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::unexpected_enumerator</code> exception is thrown
+     when an unexpected enumerator is encountered by the DOM-Tree stage.
+     The enumerator can be obtained using the <code>enumerator</code>
+     functions.
+  </p>
+
+  <h3><a name="3.3.6">3.3.6 <code>xml_schema::expected_text_content</code></a></h3>
+
+  <pre class="c++">
+struct expected_text_content: virtual exception
+{
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_text_content</code> exception is thrown
+     when a content other than text is encountered and the text content was
+     expected by the DOM-Tree stage.
+  </p>
+
+  <h3><a name="3.3.7">3.3.7 <code>xml_schema::no_type_info</code></a></h3>
+
+  <pre class="c++">
+struct no_type_info: virtual exception
+{
+  no_type_info (const std::basic_string&lt;C>&amp; type_name,
+                const std::basic_string&lt;C>&amp; type_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::no_type_info</code> exception is thrown
+     when there is no type information associated with a type specified
+     by the <code>xsi:type</code> attribute. This exception is thrown
+     by the DOM-Tree stage. The name and namespace of the type in question
+     can be obtained using the <code>type_name</code> and
+     <code>type_namespace</code> 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
+     <code>--generate-polymorphic</code> option.
+  </p>
+
+
+  <h3><a name="3.3.8">3.3.8 <code>xml_schema::not_derived</code></a></h3>
+
+  <pre class="c++">
+struct not_derived: virtual exception
+{
+  not_derived (const std::basic_string&lt;C>&amp; base_type_name,
+               const std::basic_string&lt;C>&amp; base_type_namespace,
+               const std::basic_string&lt;C>&amp; derived_type_name,
+               const std::basic_string&lt;C>&amp; derived_type_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  base_type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  base_type_namespace () const;
+
+
+  const std::basic_string&lt;C>&amp;
+  derived_type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  derived_type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::not_derived</code> exception is thrown
+     when a type specified by the <code>xsi:type</code> 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 <code>base_type_name</code> and
+     <code>base_type_namespace</code> functions respectively. The name
+     and namespace of the offending type can be obtained using the
+     <code>derived_type_name</code> and
+     <code>derived_type_namespace</code> functions respectively.
+  </p>
+
+  <h3><a name="3.3.9">3.3.9 <code>xml_schema::no_prefix_mapping</code></a></h3>
+
+  <pre class="c++">
+struct no_prefix_mapping: virtual exception
+{
+  no_prefix_mapping (const std::basic_string&lt;C>&amp; prefix);
+
+  const std::basic_string&lt;C>&amp;
+  prefix () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::no_prefix_mapping</code> 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 <code>prefix</code>
+     function.
+  </p>
+
+  <h2><a name="3.4">3.4 Reading from a Local File or URI</a></h2>
+
+  <p>Using a local file or URI is the simplest way to parse an XML instance.
+     For example:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+unique_ptr&lt;type> r1 (name ("test.xml"));
+unique_ptr&lt;type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+  </pre>
+
+  <p>Or, in the C++98 mode:</p>
+
+  <pre class="c++">
+using std::auto_ptr;
+
+auto_ptr&lt;type> r1 (name ("test.xml"));
+auto_ptr&lt;type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+  </pre>
+
+  <h2><a name="3.5">3.5 Reading from <code>std::istream</code></a></h2>
+
+  <p>When using an <code>std::istream</code> 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:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+{
+  std::ifstream ifs ("test.xml");
+  unique_ptr&lt;type> r (name (ifs, "test.xml"));
+}
+
+{
+  std::string str ("..."); // Some XML fragment.
+  std::istringstream iss (str);
+  unique_ptr&lt;type> r (name (iss));
+}
+  </pre>
+
+  <h2><a name="3.6">3.6 Reading from <code>xercesc::InputSource</code></a></h2>
+
+  <p>Reading from a <code>xercesc::InputSource</code> instance
+     is similar to the <code>std::istream</code> case except
+     the resource id is maintained by the <code>InputSource</code>
+     object. For instance:</p>
+
+  <pre class="c++">
+xercesc::StdInInputSource is;
+std::unique_ptr&lt;type> r (name (is));
+  </pre>
+
+  <h2><a name="3.7">3.7 Reading from DOM</a></h2>
+
+  <p>Reading from a <code>xercesc::DOMDocument</code> 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
+     <a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree Mapping
+     FAQ</a> shows how to parse an XML instance to a Xerces-C++
+     DOM document using the XSD runtime utilities.
+  </p>
+
+  <p>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 <code>DOMDocument</code>
+     pointer is reset and the resulting object model assumes ownership
+     of the DOM document passed. For example:</p>
+
+  <pre class="c++">
+// C++11 version.
+//
+xml_schema::dom::unique_ptr&lt;xercesc::DOMDocument> doc = ...
+
+std::unique_ptr&lt;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&lt;xercesc::DOMDocument> doc = ...
+
+std::auto_ptr&lt;type> r (
+  name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+  </pre>
+
+  <h1><a name="4">4 Serialization</a></h1>
+
+  <p>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 <a href="#3">Chapter 3,
+     "Parsing"</a>. Note that the generation of the serialization code
+     is optional and should be explicitly requested with the
+     <code>--generate-serialization</code> option. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.
+  </p>
+
+  <p>Each global XML Schema element in the form:
+  </p>
+
+
+  <pre class="xml">
+&lt;xsd:element name="name" type="type"/>
+  </pre>
+
+  <p>is mapped to 8 overloaded C++ functions in the form:</p>
+
+  <pre class="c++">
+// Serialize to std::ostream.
+//
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      const xml_schema::namespace_fomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      xml_schema::error_handler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to XMLFormatTarget.
+//
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      xml_schema::error_handler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::[unique|auto]_ptr&lt;xercesc::DOMDocument>
+name (const type&amp;,
+      const xml_schema::namespace_infomap&amp;
+        xml_schema::namespace_infomap (),
+      xml_schema::flags = 0);
+
+void
+name (xercesc::DOMDocument&amp;,
+      const type&amp;,
+      xml_schema::flags = 0);
+  </pre>
+
+  <p>You can choose between writing XML to <code>std::ostream</code> or
+     <code>xercesc::XMLFormatTarget</code> and creating a DOM instance
+     in the form of <code>xercesc::DOMDocument</code>. Serialization
+     to <code>ostream</code> or <code>XMLFormatTarget</code> 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.
+  </p>
+
+
+  <h2><a name="4.1">4.1 Initializing the Xerces-C++ Runtime</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>You can instruct serialization functions that initialize and terminate
+     the runtime not to do so by passing the
+     <code>xml_schema::flags::dont_initialize</code> flag (see
+     <a href="#4.3">Section 4.3, "Flags"</a>).
+  </p>
+
+  <h2><a name="4.2">4.2 Namespace Infomap and Character Encoding</a></h2>
+
+  <p>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
+     (<code>p1</code>, <code>p2</code>, etc) are automatically assigned
+     to namespaces as needed. Also, if
+     you would like the resulting instance document to contain the
+     <code>schemaLocation</code> or <code>noNamespaceSchemaLocation</code>
+     attributes, you will need to provide namespace-schema associations.
+     The <code>xml_schema::namespace_infomap</code> class is used
+     to capture this information:</p>
+
+  <pre class="c++">
+struct namespace_info
+{
+  namespace_info ();
+  namespace_info (const std::basic_string&lt;C>&amp; name,
+                  const std::basic_string&lt;C>&amp; schema);
+
+  std::basic_string&lt;C> name;
+  std::basic_string&lt;C> schema;
+};
+
+// Map of namespace prefix to namespace_info.
+//
+struct namespace_infomap: public std::map&lt;std::basic_string&lt;C>,
+                                          namespace_info>
+{
+};
+  </pre>
+
+  <p>Consider the following associations as an example:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+  </pre>
+
+  <p>This map, if passed to one of the serialization functions,
+     could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>As you can see, the serialization function automatically added namespace
+     mapping for the <code>xsi</code> prefix. You can change this by
+     providing your own prefix:</p>
+
+  <pre class="c++">
+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";
+  </pre>
+
+  <p>This could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>To specify the location of a schema without a namespace you can use
+     an empty prefix as in the example below: </p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].schema = "test.xsd";
+  </pre>
+
+  <p>This would result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">
+  </pre>
+
+  <p>To make a particular namespace default you can use an empty
+     prefix, for example:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].name = "https://www.codesynthesis.com/test";
+map[""].schema = "test.xsd";
+  </pre>
+
+  <p>This could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+
+  <p>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 <code>"US-ASCII"</code>,
+     <code>"ISO8859-1"</code>, <code>"UTF-8"</code>,
+     <code>"UTF-16BE"</code>, <code>"UTF-16LE"</code>,
+     <code>"UCS-4BE"</code>, and <code>"UCS-4LE"</code>. The default
+     encoding is <code>"UTF-8"</code>. For more information on
+     encoding methods see the
+     "<a href="http://en.wikipedia.org/wiki/Character_code">Character
+     Encoding</a>" article from Wikipedia.
+  </p>
+
+  <h2><a name="4.3">4.3 Flags</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <p>The following flags are recognized by the serialization
+     functions:</p>
+
+  <dl>
+    <dt><code>xml_schema::flags::dont_initialize</code></dt>
+    <dd>Do not initialize the Xerces-C++ runtime.</dd>
+
+    <dt><code>xml_schema::flags::dont_pretty_print</code></dt>
+    <dd>Do not add extra spaces or new lines that make the resulting XML
+        slightly bigger but easier to read.</dd>
+
+    <dt><code>xml_schema::flags::no_xml_declaration</code></dt>
+    <dd>Do not write XML declaration (&lt;?xml ... ?>).</dd>
+  </dl>
+
+  <p>You can pass several flags by combining them using the bit-wise OR
+     operator. For example:</p>
+
+  <pre class="c++">
+std::unique_ptr&lt;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);
+  </pre>
+
+  <p>For more information on the Xerces-C++ runtime initialization
+     refer to <a href="#4.1">Section 4.1, "Initializing the Xerces-C++
+     Runtime"</a>.
+  </p>
+
+  <h2><a name="4.4">4.4 Error Handling</a></h2>
+
+  <p>As with the parsing functions (see <a href="#3.3">Section 3.3,
+     "Error Handling"</a>), 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.
+  </p>
+
+  <p>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
+     <code>xml_schema::serialization</code> 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 <code>xml_schema::error_handler</code> and
+     <code>xercesc::DOMErrorHandler</code>. The
+     <code>xml_schema::error_handler</code> interface is described in
+     <a href="#3.3">Section 3.3, "Error Handling"</a>. For more information
+     on the <code>xercesc::DOMErrorHandler</code> interface refer to the
+     Xerces-C++ documentation.
+  </p>
+
+  <p>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.
+  </p>
+
+  <h3><a name="4.4.1">4.4.1 <code>xml_schema::serialization</code></a></h3>
+
+  <pre class="c++">
+struct serialization: virtual exception
+{
+  serialization ();
+  serialization (const diagnostics&amp;);
+
+  const diagnostics&amp;
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::diagnostics</code> class is described in
+     <a href="#3.3.1">Section 3.3.1, "<code>xml_schema::parsing</code>"</a>.
+     The <code>xml_schema::serialization</code> 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 <code>diagnostics</code> function.
+  </p>
+
+
+  <h3><a name="4.4.2">4.4.2 <code>xml_schema::unexpected_element</code></a></h3>
+
+  <p>The <code>xml_schema::unexpected_element</code> exception is
+     described in <a href="#3.3.3">Section 3.3.3,
+     "<code>xml_schema::unexpected_element</code>"</a>. 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.
+  </p>
+
+  <h3><a name="4.4.3">4.4.3 <code>xml_schema::no_type_info</code></a></h3>
+
+  <p>The <code>xml_schema::no_type_info</code> exception is
+     described in <a href="#3.3.7">Section 3.3.7,
+     "<code>xml_schema::no_type_info</code>"</a>. 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 <code>--generate-polymorphic</code> option.
+  </p>
+
+  <h2><a name="4.5">4.5 Serializing to <code>std::ostream</code></a></h2>
+
+  <p>In order to serialize to <code>std::ostream</code> you will need
+     an object model, an output stream and, optionally, a namespace
+     infomap. For instance:</p>
+
+  <pre class="c++">
+// Obtain the object model.
+//
+std::unique_ptr&lt;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);
+  </pre>
+
+  <p>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 <code>char</code>, for instance UTF-16 or UCS-4. For
+     example, things will most likely break if you try to serialize
+     to <code>std::ostringstream</code> with UTF-16 or UCS-4 as an
+     encoding. This is due to the special value,
+     <code>'\0'</code>, that will most likely occur as part of such
+     serialization and it won't have the special meaning assumed by
+     <code>std::ostringstream</code>.
+  </p>
+
+
+  <h2><a name="4.6">4.6 Serializing to <code>xercesc::XMLFormatTarget</code></a></h2>
+
+  <p>Serializing to an <code>xercesc::XMLFormatTarget</code> instance
+     is similar the <code>std::ostream</code> case. For instance:
+  </p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+// Obtain the object model.
+//
+unique_ptr&lt;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&lt;XMLFormatTarget> ft;
+
+  if (argc != 2)
+  {
+    ft = unique_ptr&lt;XMLFormatTarget> (new StdOutFormatTarget ());
+  }
+  else
+  {
+    ft = unique_ptr&lt;XMLFormatTarget> (
+      new LocalFileFormatTarget (argv[1]));
+  }
+
+  // Write it out.
+  //
+  name (*ft, *r, map);
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>Note that we had to initialize the Xerces-C++ runtime before we
+     could call this serialization function.</p>
+
+  <h2><a name="4.7">4.7 Serializing to DOM</a></h2>
+
+  <p>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 <code>std::ostream</code> or <code>xercesc::XMLFormatTarget</code>,
+     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 <code>schemaLocation</code> and/or
+     <code>noNamespaceSchemaLocation</code> attributes. The following
+     listing should give you an idea about what needs to be done:
+  </p>
+
+  <pre class="c++">
+// Obtain the object model.
+//
+std::unique_ptr&lt;type> r = ...
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Create a DOM instance. Set custom namespace mapping and schema
+  // location attributes.
+  //
+  DOMDocument&amp; doc = ...
+
+  // Serialize to DOM.
+  //
+  name (doc, *r);
+
+  // Serialize the DOM document to XML.
+  //
+  ...
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>For more information on how to create and serialize a DOM instance
+     refer to the Xerces-C++ documentation. In addition, the
+     <a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree Mapping
+     FAQ</a> shows how to implement these operations using the XSD
+     runtime utilities.
+  </p>
+
+  <h1><a name="5">5 Additional Functionality</a></h1>
+
+  <p>The C++/Tree mapping provides a number of optional features
+     that can be useful in certain situations. They are described
+     in the following sections.</p>
+
+  <h2><a name="5.1">5.1 DOM Association</a></h2>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>To request DOM association you will need to pass the
+     <code>xml_schema::flags::keep_dom</code> flag to one of the
+     parsing functions (see <a href="#3.2">Section 3.2,
+     "Flags and Properties"</a> 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 <code>keep_dom</code> flag and
+     terminate it after the object model is destroyed (see
+     <a href="#3.1">Section 3.1, "Initializing the Xerces-C++ Runtime"</a>).</p>
+
+   <p>If the <code>keep_dom</code> 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:</p>
+
+  <pre class="c++">
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr&lt;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 ();
+  </pre>
+
+
+  <p>To obtain the corresponding DOM node from an object model node
+     you will need to call the <code>_node</code> accessor function
+     which returns a pointer to <code>DOMNode</code>. You can then query
+     this DOM node's type and cast it to either <code>DOMAttr*</code>
+     or <code>DOMElement*</code>. To obtain the corresponding object
+     model node from a DOM node, the DOM user data API is used. The
+     <code>xml_schema::dom::tree_node_key</code> 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="a" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="object"/>
+  </pre>
+
+  <pre class="c++">
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr&lt;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&lt;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&lt;DOMElement*> (n);
+      break;
+    }
+  }
+
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type&amp; t (
+    *reinterpret_cast&lt;xml_schema::type*> (
+       ae->getUserData (xml_schema::dom::tree_node_key)));
+
+  xml_schema::string&amp; a (dynamic_cast&lt;xml_schema::string&amp;> (t));
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>The 'mixed' example which can be found in the XSD distribution
+     shows how to handle the mixed content using DOM association.</p>
+
+  <h2><a name="5.2">5.2 Binary Serialization</a></h2>
+
+  <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 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.</p>
+
+  <p>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.</p>
+
+  <p>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
+     <code>--generate-insertion</code> and <code>--generate-extraction</code>
+     compiler options. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.</p>
+
+  <p>Once the insertion operators and extraction constructors are
+     generated, you can use the <code>xml_schema::istream</code>
+     and <code>xml_schema::ostream</code> 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="a" type="string"/>
+    &lt;element name="b" type="int"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="object"/>
+  </pre>
+
+  <pre class="c++">
+// Parse XML to object model.
+//
+std::unique_ptr&lt;type> r (root ("root.xml"));
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream&lt;ACE_OutputCDR> ocdr (ace_ocdr);
+
+ocdr &lt;&lt; *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::istream&lt;ACE_InputCDR> icdr (ace_icdr);
+
+std::unique_ptr&lt;object> copy (new object (icdr));
+
+// Serialize to XML.
+//
+root (std::cout, *copy);
+  </pre>
+
+  <p>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.</p>
+
+  <!--  Appendix A -->
+
+
+  <h1><a name="A">Appendix A &mdash; Default and Fixed Values</a></h1>
+
+  <p>The following table summarizes the effect of default and fixed
+     values (specified with the <code>default</code> and <code>fixed</code>
+     attributes, respectively) on attribute and element values. The
+     <code>default</code> and <code>fixed</code> attributes are mutually
+     exclusive. It is also worthwhile to note that the fixed value semantics
+     is a superset of the default value semantics.
+  </p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="default-fixed" border="1">
+    <tr>
+      <th></th>
+      <th></th>
+      <th colspan="2">default</th>
+      <th colspan="2">fixed</th>
+    </tr>
+
+    <!-- element -->
+
+    <tr>
+      <th rowspan="4">element</th>
+      <th rowspan="2">not present</th>
+      <th>optional</th>
+      <th>required</th>
+      <th>optional</th>
+      <th>required</th>
+    </tr>
+    <tr>
+      <td>not present</td>
+      <td>invalid instance</td>
+      <td>not present</td>
+      <td>invalid instance</td>
+    </tr>
+
+
+    <tr>
+      <th>empty</th>
+      <td colspan="2">default value is used</td>
+      <td colspan="2">fixed value is used</td>
+    </tr>
+
+    <tr>
+      <th>value</th>
+      <td colspan="2">value is used</td>
+      <td colspan="2">value is used provided it's the same as fixed</td>
+    </tr>
+
+    <!-- attribute -->
+
+    <!-- element -->
+
+    <tr>
+      <th rowspan="4">attribute</th>
+      <th rowspan="2">not present</th>
+      <th>optional</th>
+      <th>required</th>
+      <th>optional</th>
+      <th>required</th>
+    </tr>
+    <tr>
+      <td>default value is used</td>
+      <td>invalid schema</td>
+      <td>fixed value is used</td>
+      <td>invalid instance</td>
+    </tr>
+
+
+    <tr>
+      <th>empty</th>
+      <td colspan="2">empty value is used</td>
+      <td colspan="2">empty value is used provided it's the same as fixed</td>
+    </tr>
+
+    <tr>
+      <th>value</th>
+      <td colspan="2">value is used</td>
+      <td colspan="2">value is used provided it's the same as fixed</td>
+    </tr>
+
+  </table>
+
+  </div>
+</div>
+
+
+</body>
+</html>
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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>C++/Tree Mapping User Manual</title>
+
+  <meta name="copyright" content="&#169; @copyright@"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,tree,serialization,guide,manual,examples"/>
+  <meta name="description" content="C++/Tree Mapping User Manual"/>
+  <meta name="revision" content="4.1.0"/>
+
+  <link rel="stylesheet" type="text/css" href="../../../default.css" />
+
+<style type="text/css">
+  pre {
+    padding    : 0 0 0 0em;
+    margin     : 0em 0em 0em 0;
+
+    font-size  : 102%
+  }
+
+  body {
+    min-width: 48em;
+  }
+
+  h1 {
+    font-weight: bold;
+    font-size: 200%;
+  }
+
+  h2 {
+    font-weight : bold;
+    font-size   : 150%;
+
+    padding-top : 0.8em;
+  }
+
+  h3 {
+    font-size   : 130%;
+    padding-top : 0.8em;
+  }
+
+  /* Adjust indentation for three levels. */
+  #container {
+    max-width: 48em;
+  }
+
+  #content {
+    padding: 0 0.1em 0 4em;
+    /*background-color: red;*/
+  }
+
+  #content h1 {
+    margin-left: -2.06em;
+  }
+
+  #content h2 {
+    margin-left: -1.33em;
+  }
+
+  /* Title page */
+
+  #titlepage {
+    padding: 2em 0 1em 0;
+    border-bottom: 1px solid black;
+  }
+
+  #titlepage #title {
+    font-weight: bold;
+    font-size: 200%;
+    text-align: center;
+    padding: 1em 0 2em 0;
+  }
+
+  /* Lists */
+  ul.list li {
+    padding-top      : 0.3em;
+    padding-bottom   : 0.3em;
+  }
+
+
+  /* Built-in table */
+  #builtin {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #builtin th, #builtin td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #builtin th {
+    background : #cde8f6;
+  }
+
+  #builtin td {
+    text-align: left;
+  }
+
+
+  /* default-fixed */
+  #default-fixed {
+    margin: 2em 0 2em 0;
+
+    border-collapse   : collapse;
+    border            : 1px solid;
+    border-color      : #000000;
+
+    font-size        : 11px;
+    line-height      : 14px;
+  }
+
+  #default-fixed th, #default-fixed td {
+    border: 1px solid;
+    padding           : 0.9em 0.9em 0.7em 0.9em;
+  }
+
+  #default-fixed th {
+    background : #cde8f6;
+  }
+
+  #default-fixed td {
+    text-align: center;
+  }
+
+
+  /*  */
+  dl dt {
+    padding   : 0.8em 0 0 0;
+  }
+
+
+  /* TOC */
+  table.toc {
+    border-style      : none;
+    border-collapse   : separate;
+    border-spacing    : 0;
+
+    margin            : 0.2em 0 0.2em 0;
+    padding           : 0 0 0 0;
+  }
+
+  table.toc tr {
+    padding           : 0 0 0 0;
+    margin            : 0 0 0 0;
+  }
+
+  table.toc * td, table.toc * th {
+    border-style      : none;
+    margin            : 0 0 0 0;
+    vertical-align    : top;
+  }
+
+  table.toc * th {
+    font-weight       : normal;
+    padding           : 0em 0.1em 0em 0;
+    text-align        : left;
+    white-space       : nowrap;
+  }
+
+  table.toc * table.toc th {
+    padding-left      : 1em;
+  }
+
+  table.toc * td {
+    padding           : 0em 0 0em 0.7em;
+    text-align        : left;
+  }
+</style>
+
+
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <div class="noprint">
+
+  <div id="titlepage">
+    <div id="title">C++/Tree Mapping User Manual</div>
+
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps">PostScript</a>.</p>
+  </div>
+
+  <h1>Table of Contents</h1>
+
+  <table class="toc">
+    <tr>
+      <th></th><td><a href="#0">Preface</a>
+        <table class="toc">
+          <tr><th></th><td><a href="#0.1">About This Document</a></td></tr>
+	  <tr><th></th><td><a href="#0.2">More Information</a></td></tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>1</th><td><a href="#1">Introduction</a></td>
+    </tr>
+
+    <tr>
+      <th>2</th><td><a href="#2">C++/Tree Mapping</a>
+        <table class="toc">
+          <tr>
+            <th>2.1</th><td><a href="#2.1">Preliminary Information</a>
+              <table class="toc">
+		<tr><th>2.1.1</th><td><a href="#2.1.1">C++ Standard</a></td></tr>
+                <tr><th>2.1.2</th><td><a href="#2.1.2">Identifiers</a></td></tr>
+                <tr><th>2.1.3</th><td><a href="#2.1.3">Character Type and Encoding</a></td></tr>
+                <tr><th>2.1.4</th><td><a href="#2.1.4">XML Schema Namespace</a></td></tr>
+		<tr><th>2.1.5</th><td><a href="#2.1.5">Anonymous Types</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.2</th><td><a href="#2.2">Error Handling</a>
+              <table class="toc">
+                <tr><th>2.2.1</th><td><a href="#2.2.1"><code>xml_schema::duplicate_id</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.3</th><td><a href="#2.3">Mapping for <code>import</code> and <code>include</code></a>
+              <table class="toc">
+                <tr><th>2.3.1</th><td><a href="#2.3.1">Import</a></td></tr>
+		<tr><th>2.3.2</th><td><a href="#2.3.2">Inclusion with Target Namespace</a></td></tr>
+		<tr><th>2.3.3</th><td><a href="#2.3.3">Inclusion without Target Namespace</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.4</th><td><a href="#2.4">Mapping for Namespaces</a></td>
+          </tr>
+          <tr>
+            <th>2.5</th><td><a href="#2.5">Mapping for Built-in Data Types</a>
+              <table class="toc">
+                <tr><th>2.5.1</th><td><a href="#2.5.1">Inheritance from Built-in Data Types</a></td></tr>
+                <tr><th>2.5.2</th><td><a href="#2.5.2">Mapping for <code>anyType</code></a></td></tr>
+                <tr><th>2.5.3</th><td><a href="#2.5.3">Mapping for <code>anySimpleType</code></a></td></tr>
+                <tr><th>2.5.4</th><td><a href="#2.5.4">Mapping for <code>QName</code></a></td></tr>
+                <tr><th>2.5.5</th><td><a href="#2.5.5">Mapping for <code>IDREF</code></a></td></tr>
+		<tr><th>2.5.6</th><td><a href="#2.5.6">Mapping for <code>base64Binary</code> and <code>hexBinary</code></a></td></tr>
+		<tr><th>2.5.7</th><td><a href="#2.5.7">Time Zone Representation</a></td></tr>
+		<tr><th>2.5.8</th><td><a href="#2.5.8">Mapping for <code>date</code></a></td></tr>
+		<tr><th>2.5.9</th><td><a href="#2.5.9">Mapping for <code>dateTime</code></a></td></tr>
+		<tr><th>2.5.10</th><td><a href="#2.5.10">Mapping for <code>duration</code></a></td></tr>
+		<tr><th>2.5.11</th><td><a href="#2.5.11">Mapping for <code>gDay</code></a></td></tr>
+		<tr><th>2.5.12</th><td><a href="#2.5.12">Mapping for <code>gMonth</code></a></td></tr>
+		<tr><th>2.5.13</th><td><a href="#2.5.13">Mapping for <code>gMonthDay</code></a></td></tr>
+		<tr><th>2.5.14</th><td><a href="#2.5.14">Mapping for <code>gYear</code></a></td></tr>
+		<tr><th>2.5.15</th><td><a href="#2.5.15">Mapping for <code>gYearMonth</code></a></td></tr>
+		<tr><th>2.5.16</th><td><a href="#2.5.16">Mapping for <code>time</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.6</th><td><a href="#2.6">Mapping for Simple Types</a>
+              <table class="toc">
+                <tr><th>2.6.1</th><td><a href="#2.6.1">Mapping for Derivation by Restriction</a></td></tr>
+                <tr><th>2.6.2</th><td><a href="#2.6.2">Mapping for Enumerations</a></td></tr>
+                <tr><th>2.6.3</th><td><a href="#2.6.3">Mapping for Derivation by List</a></td></tr>
+                <tr><th>2.6.4</th><td><a href="#2.6.4">Mapping for Derivation by Union</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.7</th><td><a href="#2.7">Mapping for Complex Types</a>
+              <table class="toc">
+	        <tr><th>2.7.1</th><td><a href="#2.7.1">Mapping for Derivation by Extension</a></td></tr>
+                <tr><th>2.7.2</th><td><a href="#2.7.2">Mapping for Derivation by Restriction</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.8</th><td><a href="#2.8">Mapping for Local Elements and Attributes</a>
+              <table class="toc">
+	        <tr><th>2.8.1</th><td><a href="#2.8.1">Mapping for Members with the One Cardinality Class</a></td></tr>
+	        <tr><th>2.8.2</th><td><a href="#2.8.2">Mapping for Members with the Optional Cardinality Class</a></td></tr>
+	        <tr><th>2.8.3</th><td><a href="#2.8.3">Mapping for Members with the Sequence Cardinality Class</a></td></tr>
+		<tr><th>2.8.4</th><td><a href="#2.8.4">Element Order</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.9</th><td><a href="#2.9">Mapping for Global Elements</a>
+              <table class="toc">
+	        <tr><th>2.9.1</th><td><a href="#2.9.1">Element Types</a></td></tr>
+	        <tr><th>2.9.2</th><td><a href="#2.9.2">Element Map</a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>2.10</th><td><a href="#2.10">Mapping for Global Attributes</a></td>
+          </tr>
+          <tr>
+            <th>2.11</th><td><a href="#2.11">Mapping for <code>xsi:type</code> and Substitution Groups</a></td>
+          </tr>
+          <tr>
+            <th>2.12</th><td><a href="#2.12">Mapping for <code>any</code> and <code>anyAttribute</code></a>
+              <table class="toc">
+	        <tr><th>2.12.1</th><td><a href="#2.12.1">Mapping for <code>any</code> with the One Cardinality Class</a></td></tr>
+	        <tr><th>2.12.2</th><td><a href="#2.12.2">Mapping for <code>any</code> with the Optional Cardinality Class</a></td></tr>
+	        <tr><th>2.12.3</th><td><a href="#2.12.3">Mapping for <code>any</code> with the Sequence Cardinality Class</a></td></tr>
+		<tr><th>2.12.4</th><td><a href="#2.12.4">Element Wildcard Order</a></td></tr>
+		<tr><th>2.12.5</th><td><a href="#2.12.5">Mapping for <code>anyAttribute</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+	  <tr>
+            <th>2.13</th><td><a href="#2.13">Mapping for Mixed Content Models</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>3</th><td><a href="#3">Parsing</a>
+        <table class="toc">
+          <tr>
+            <th>3.1</th><td><a href="#3.1">Initializing the Xerces-C++ Runtime</a></td>
+          </tr>
+          <tr>
+            <th>3.2</th><td><a href="#3.2">Flags and Properties</a></td>
+          </tr>
+          <tr>
+            <th>3.3</th><td><a href="#3.3">Error Handling</a>
+              <table class="toc">
+	        <tr><th>3.3.1</th><td><a href="#3.3.1"><code>xml_schema::parsing</code></a></td></tr>
+	        <tr><th>3.3.2</th><td><a href="#3.3.2"><code>xml_schema::expected_element</code></a></td></tr>
+	        <tr><th>3.3.3</th><td><a href="#3.3.3"><code>xml_schema::unexpected_element</code></a></td></tr>
+	        <tr><th>3.3.4</th><td><a href="#3.3.4"><code>xml_schema::expected_attribute</code></a></td></tr>
+	        <tr><th>3.3.5</th><td><a href="#3.3.5"><code>xml_schema::unexpected_enumerator</code></a></td></tr>
+		<tr><th>3.3.6</th><td><a href="#3.3.6"><code>xml_schema::expected_text_content</code></a></td></tr>
+	        <tr><th>3.3.7</th><td><a href="#3.3.7"><code>xml_schema::no_type_info</code></a></td></tr>
+	        <tr><th>3.3.8</th><td><a href="#3.3.8"><code>xml_schema::not_derived</code></a></td></tr>
+		<tr><th>3.3.9</th><td><a href="#3.3.9"><code>xml_schema::not_prefix_mapping</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>3.4</th><td><a href="#3.4">Reading from a Local File or URI</a></td>
+          </tr>
+          <tr>
+            <th>3.5</th><td><a href="#3.5">Reading from <code>std::istream</code></a></td>
+          </tr>
+          <tr>
+            <th>3.6</th><td><a href="#3.6">Reading from <code>xercesc::InputSource</code></a></td>
+          </tr>
+          <tr>
+            <th>3.7</th><td><a href="#3.7">Reading from DOM</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>4</th><td><a href="#4">Serialization</a>
+        <table class="toc">
+          <tr>
+            <th>4.1</th><td><a href="#4.1">Initializing the Xerces-C++ Runtime</a></td>
+          </tr>
+          <tr>
+            <th>4.2</th><td><a href="#4.2">Namespace Infomap and Character Encoding</a></td>
+          </tr>
+          <tr>
+            <th>4.3</th><td><a href="#4.3">Flags</a></td>
+          </tr>
+          <tr>
+            <th>4.4</th><td><a href="#4.4">Error Handling</a>
+              <table class="toc">
+	        <tr><th>4.4.1</th><td><a href="#4.4.1"><code>xml_schema::serialization</code></a></td></tr>
+		<tr><th>4.4.2</th><td><a href="#4.4.2"><code>xml_schema::unexpected_element</code></a></td></tr>
+		<tr><th>4.4.3</th><td><a href="#4.4.3"><code>xml_schema::no_type_info</code></a></td></tr>
+              </table>
+            </td>
+          </tr>
+          <tr>
+            <th>4.5</th><td><a href="#4.5">Serializing to <code>std::ostream</code></a></td>
+          </tr>
+          <tr>
+            <th>4.6</th><td><a href="#4.6">Serializing to <code>xercesc::XMLFormatTarget</code></a></td>
+          </tr>
+          <tr>
+            <th>4.7</th><td><a href="#4.7">Serializing to DOM</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th>5</th><td><a href="#5">Additional Functionality</a>
+        <table class="toc">
+          <tr>
+            <th>5.1</th><td><a href="#5.1">DOM Association</a></td>
+          </tr>
+          <tr>
+            <th>5.2</th><td><a href="#5.2">Binary Serialization</a></td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+
+    <tr>
+      <th></th><td><a href="#A">Appendix A &mdash; Default and Fixed Values</a></td>
+    </tr>
+
+  </table>
+  </div>
+
+  <h1><a name="0">Preface</a></h1>
+
+  <h2><a name="0.1">About This Document</a></h2>
+
+  <p>This document describes the mapping of W3C XML Schema
+     to the C++ programming language as implemented by
+     <a href="https://www.codesynthesis.com/products/xsd">CodeSynthesis
+     XSD</a> - 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.
+  </p>
+
+  <p>Revision 4.1.0<br/> <!-- Remember to change revision in other places -->
+     This revision of the manual describes the C++/Tree
+     mapping as implemented by CodeSynthesis XSD version 4.1.0.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml">XHTML</a>,
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf">PDF</a>, and
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps">PostScript</a>.</p>
+
+  <h2><a name="0.2">More Information</a></h2>
+
+  <p>Beyond this manual, you may also find the following sources of
+     information useful:</p>
+
+  <ul class="list">
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/">C++/Tree
+        Mapping Getting Started Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/Customization_guide">C++/Tree
+        Mapping Customization Guide</a></li>
+
+    <li><a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree
+        Mapping Frequently Asked Questions (FAQ)</a></li>
+
+    <li><a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+        Compiler Command Line Manual</a></li>
+
+    <li>The <code>cxx/tree/</code> directory in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        contains a collection of examples and a README file with an overview
+        of each example.</li>
+
+    <li>The <code>README</code> file in the
+        <a href="https://cppget.org/xsd-examples">xsd-examples</a> package
+        explains how to build the examples.</li>
+
+    <li>The <a href="https://www.codesynthesis.com/mailman/listinfo/xsd-users">xsd-users</a>
+        mailing list is a place to ask questions. Furthermore the
+        <a href="https://www.codesynthesis.com/pipermail/xsd-users/">archives</a>
+        may already have answers to some of your questions.</li>
+  </ul>
+
+
+  <h1><a name="1">1 Introduction</a></h1>
+
+  <p>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.</p>
+
+  <p>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.
+  </p>
+
+  <p>The C++/Tree mapping consists of C++ types that represent the
+     given vocabulary (<a href="#2">Chapter 2, "C++/Tree Mapping"</a>),
+     a set of parsing functions that convert XML documents to
+     a tree-like in-memory data structure (<a href="#3">Chapter 3,
+     "Parsing"</a>), and a set of serialization functions that convert
+     the object model back to XML (<a href="#4">Chapter 4,
+     "Serialization"</a>). Furthermore, the mapping provides a number
+     of additional features, such as DOM association and binary
+     serialization, that can be useful in some applications
+     (<a href="#5">Chapter 5, "Additional Functionality"</a>).
+  </p>
+
+
+  <!-- Chapter 2 -->
+
+
+  <h1><a name="2">2 C++/Tree Mapping</a></h1>
+
+  <h2><a name="2.1">2.1 Preliminary Information</a></h2>
+
+  <h3><a name="2.1.1">2.1.1 C++ Standard</a></h3>
+
+  <p>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 <code>--std</code> 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.</p>
+
+  <h3><a name="2.1.2">2.1.2 Identifiers</a></h3>
+
+  <p>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 "_".
+  </p>
+
+  <p>For example, XML Schema name <code>try</code> will be mapped to
+     C++ identifier <code>try_</code>. Similarly, XML Schema name
+     <code>strange.na-me</code> will be mapped to C++ identifier
+     <code>strange_na_me</code>.
+  </p>
+
+  <p>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 <a href="#2.9">Section
+     2.9, "Mapping for Global Elements"</a>) 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.</p>
+
+  <p>For example, if we had a global type <code>catalog</code>
+     and a global element with the same name then the type would be
+     mapped to a C++ class with name <code>catalog</code> while the
+     parsing functions corresponding to the global element would have
+     their names escaped as <code>catalog_</code>.
+  </p>
+
+  <p>By default the mapping uses the so-called K&amp;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 <code>--type-naming</code> and
+     <code>--function-naming</code> options. You can also further
+     refine one of the predefined conventions or create a completely
+     custom naming scheme by using the  <code>--*-regex</code> options.
+     For more detailed information on these options refer to the NAMING
+     CONVENTION section in the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+  <h3><a name="2.1.3">2.1.3 Character Type and Encoding</a></h3>
+
+  <p>The code that implements the mapping, depending on the
+     <code>--char-type</code>  option, is generated using either
+     <code>char</code> or <code>wchar_t</code> as the character
+     type. In this document code samples use symbol <code>C</code>
+     to refer to the character type you have selected when translating
+     your schemas, for example <code>std::basic_string&lt;C></code>.
+  </p>
+
+  <p>Another aspect of the mapping that depends on the character type
+     is character encoding. For the <code>char</code> 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
+     <code>--char-encoding</code> command line option.</p>
+
+  <p>For the <code>wchar_t</code> character type the encoding is
+     automatically selected between UTF-16 and UTF-32/UCS-4 depending
+     on the size of the <code>wchar_t</code> type. On some platforms
+     (for example, Windows with Visual C++ and AIX with IBM XL C++)
+     <code>wchar_t</code> is 2 bytes long. For these platforms the
+     encoding is UTF-16. On other platforms <code>wchar_t</code> is 4 bytes
+     long and UTF-32/UCS-4 is used.</p>
+
+  <h3><a name="2.1.4">2.1.4 XML Schema Namespace</a></h3>
+
+  <p>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 (<code>http://www.w3.org/2001/XMLSchema</code>).
+     By default, this namespace is mapped to C++ namespace
+     <code>xml_schema</code>. It is automatically accessible
+     from a C++ compilation unit that includes a header file generated
+     from an XML Schema definition.
+  </p>
+
+  <p>Note that, if desired, the default mapping of this namespace can be
+     changed as described in <a href="#2.4">Section 2.4, "Mapping for
+     Namespaces"</a>.
+  </p>
+
+
+  <h3><a name="2.1.5">2.1.5 Anonymous Types</a></h3>
+
+  <p>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 <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>
+     and <a href="#2.7">Section 2.7, "Mapping for Complex Types"</a>).
+     For example, in the following schema fragment:
+  </p>
+
+  <pre class="xml">
+&lt;element name="object">
+  &lt;complexType>
+    ...
+  &lt;/complexType>
+&lt;/element>
+  </pre>
+
+  <p>The anonymous type defined inside element <code>object</code> will
+     be given name <code>object</code>. The compiler has a number of
+     options that control the process of anonymous type naming. For more
+     information refer to the <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a>.</p>
+
+
+  <h2><a name="2.2">2.2 Error Handling</a></h2>
+
+  <p>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 <code>xml_schema::exception</code> which
+     itself is derived from <code>std::exception</code>:
+  </p>
+
+  <pre class="c++">
+struct exception: virtual std::exception
+{
+  friend
+  std::basic_ostream&lt;C>&amp;
+  operator&lt;&lt; (std::basic_ostream&lt;C>&amp; os, const exception&amp; e)
+  {
+    e.print (os);
+    return os;
+  }
+
+protected:
+  virtual void
+  print (std::basic_ostream&lt;C>&amp;) const = 0;
+};
+  </pre>
+
+  <p>The exception hierarchy supports "virtual" <code>operator&lt;&lt;</code>
+     which allows you to obtain diagnostics corresponding to the thrown
+     exception using the base exception interface. For example:</p>
+
+  <pre class="c++">
+try
+{
+  ...
+}
+catch (const xml_schema::exception&amp; e)
+{
+  cerr &lt;&lt; e &lt;&lt; endl;
+}
+  </pre>
+
+  <p>The following sub-sections describe exceptions thrown by the
+     types that constitute the object model.
+     <a href="#3.3">Section 3.3, "Error Handling"</a> of
+     <a href="#3">Chapter 3, "Parsing"</a> describes exceptions
+     and error handling mechanisms specific to the parsing functions.
+     <a href="#4.4">Section 4.4, "Error Handling"</a> of
+     <a href="#4">Chapter 4, "Serialization"</a> describes exceptions
+     and error handling mechanisms specific to the serialization functions.
+  </p>
+
+
+  <h3><a name="2.2.1">2.2.1 <code>xml_schema::duplicate_id</code></a></h3>
+
+  <pre class="c++">
+struct duplicate_id: virtual exception
+{
+  duplicate_id (const std::basic_string&lt;C>&amp; id);
+
+  const std::basic_string&lt;C>&amp;
+  id () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::duplicate_id</code> is thrown when
+     a conflicting instance of <code>xml_schema::id</code> (see
+     <a href="#2.5">Section 2.5, "Mapping for Built-in Data Types"</a>)
+     is added to a tree. The offending ID value can be obtained using
+     the <code>id</code> function.
+  </p>
+
+  <h2><a name="2.3">2.3 Mapping for <code>import</code> and <code>include</code></a></h2>
+
+  <h3><a name="2.3.1">2.3.1 Import</a></h3>
+
+  <p>The XML Schema <code>import</code> element is mapped to the C++
+     Preprocessor <code>#include</code> directive. The value of
+     the <code>schemaLocation</code> attribute is used to derive
+     the name of the header file that appears in the <code>#include</code>
+     directive. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;import namespace="https://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+#include "test.hxx"
+  </pre>
+
+  <p>Note that you will need to compile imported schemas separately
+     in order to produce corresponding header files.</p>
+
+  <h3><a name="2.3.2">2.3.2 Inclusion with Target Namespace</a></h3>
+
+  <p>The XML Schema <code>include</code> 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 <code>import</code> element,
+     see <a href="#2.3.1">Section 2.3.1, "Import"</a>.
+  </p>
+
+  <h3><a name="2.3.3">2.3.3 Inclusion without Target Namespace</a></h3>
+
+  <p>For the XML Schema <code>include</code> 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:
+  </p>
+
+  <pre class="xml">
+&lt;-- common.xsd -->
+&lt;schema>
+  &lt;complexType name="type">
+  ...
+  &lt;/complexType>
+&lt;/schema>
+
+&lt;-- test.xsd -->
+&lt;schema targetNamespace="https://www.codesynthesis.com/test">
+  &lt;include schemaLocation="common.xsd"/>
+&lt;/schema>
+  </pre>
+
+  <p>The fragment of interest from the generated header file for
+     <code>text.xsd</code> would look like this:</p>
+
+  <pre class="c++">
+// test.hxx
+namespace test
+{
+  class type
+  {
+    ...
+  };
+}
+  </pre>
+
+  <h2><a name="2.4">2.4 Mapping for Namespaces</a></h2>
+
+  <p>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 '<code>/</code>'
+     as the name separator. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;schema targetNamespace="https://www.codesynthesis.com/system/test">
+  ...
+&lt;/schema>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+namespace system
+{
+  namespace test
+  {
+    ...
+  }
+}
+  </pre>
+
+  <p>The default mapping of namespace URIs to C++ namespace names can be
+     altered using the <code>--namespace-map</code> and
+     <code>--namespace-regex</code> options. See  the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.
+  </p>
+
+  <h2><a name="2.5">2.5 Mapping for Built-in Data Types</a></h2>
+
+  <p>The mapping of XML Schema built-in data types to C++ types is
+     summarized in the table below.</p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="builtin" border="1">
+    <tr>
+      <th>XML Schema type</th>
+      <th>Alias in the <code>xml_schema</code> namespace</th>
+      <th>C++ type</th>
+    </tr>
+
+    <tr>
+      <th colspan="3">anyType and anySimpleType types</th>
+    </tr>
+    <tr>
+      <td><code>anyType</code></td>
+      <td><code>type</code></td>
+      <td><a href="#2.5.2">Section 2.5.2, "Mapping for <code>anyType</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>anySimpleType</code></td>
+      <td><code>simple_type</code></td>
+      <td><a href="#2.5.3">Section 2.5.3, "Mapping for <code>anySimpleType</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-length integral types</th>
+    </tr>
+    <!-- 8-bit -->
+    <tr>
+      <td><code>byte</code></td>
+      <td><code>byte</code></td>
+      <td><code>signed&nbsp;char</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedByte</code></td>
+      <td><code>unsigned_byte</code></td>
+      <td><code>unsigned&nbsp;char</code></td>
+    </tr>
+
+    <!-- 16-bit -->
+    <tr>
+      <td><code>short</code></td>
+      <td><code>short_</code></td>
+      <td><code>short</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedShort</code></td>
+      <td><code>unsigned_short</code></td>
+      <td><code>unsigned&nbsp;short</code></td>
+    </tr>
+
+    <!-- 32-bit -->
+    <tr>
+      <td><code>int</code></td>
+      <td><code>int_</code></td>
+      <td><code>int</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedInt</code></td>
+      <td><code>unsigned_int</code></td>
+      <td><code>unsigned&nbsp;int</code></td>
+    </tr>
+
+    <!-- 64-bit -->
+    <tr>
+      <td><code>long</code></td>
+      <td><code>long_</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>unsignedLong</code></td>
+      <td><code>unsigned_long</code></td>
+      <td><code>unsigned&nbsp;long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-length integral types</th>
+    </tr>
+    <tr>
+      <td><code>integer</code></td>
+      <td><code>integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonPositiveInteger</code></td>
+      <td><code>non_positive_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>nonNegativeInteger</code></td>
+      <td><code>non_negative_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>positiveInteger</code></td>
+      <td><code>positive_integer</code></td>
+      <td><code>unsigned long&nbsp;long</code></td>
+    </tr>
+    <tr>
+      <td><code>negativeInteger</code></td>
+      <td><code>negative_integer</code></td>
+      <td><code>long&nbsp;long</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">boolean types</th>
+    </tr>
+    <tr>
+      <td><code>boolean</code></td>
+      <td><code>boolean</code></td>
+      <td><code>bool</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">fixed-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>float</code></td>
+      <td><code>float_</code></td>
+      <td><code>float</code></td>
+    </tr>
+    <tr>
+      <td><code>double</code></td>
+      <td><code>double_</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">arbitrary-precision floating-point types</th>
+    </tr>
+    <tr>
+      <td><code>decimal</code></td>
+      <td><code>decimal</code></td>
+      <td><code>double</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">string types</th>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td><code>string</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+    <tr>
+      <td><code>normalizedString</code></td>
+      <td><code>normalized_string</code></td>
+      <td>type derived from <code>string</code></td>
+    </tr>
+    <tr>
+      <td><code>token</code></td>
+      <td><code>token</code></td>
+      <td>type&nbsp;derived&nbsp;from&nbsp;<code>normalized_string</code></td>
+    </tr>
+    <tr>
+      <td><code>Name</code></td>
+      <td><code>name</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKEN</code></td>
+      <td><code>nmtoken</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+    <tr>
+      <td><code>NMTOKENS</code></td>
+      <td><code>nmtokens</code></td>
+      <td>type derived from <code>sequence&lt;nmtoken></code></td>
+    </tr>
+    <tr>
+      <td><code>NCName</code></td>
+      <td><code>ncname</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>language</code></td>
+      <td><code>language</code></td>
+      <td>type derived from <code>token</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">qualified name</th>
+    </tr>
+    <tr>
+      <td><code>QName</code></td>
+      <td><code>qname</code></td>
+      <td><a href="#2.5.4">Section 2.5.4, "Mapping for <code>QName</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">ID/IDREF types</th>
+    </tr>
+    <tr>
+      <td><code>ID</code></td>
+      <td><code>id</code></td>
+      <td>type derived from <code>ncname</code></td>
+    </tr>
+    <tr>
+      <td><code>IDREF</code></td>
+      <td><code>idref</code></td>
+      <td><a href="#2.5.5">Section 2.5.5, "Mapping for <code>IDREF</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>IDREFS</code></td>
+      <td><code>idrefs</code></td>
+      <td>type derived from <code>sequence&lt;idref></code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">URI types</th>
+    </tr>
+    <tr>
+      <td><code>anyURI</code></td>
+      <td><code>uri</code></td>
+      <td>type derived from <code>std::basic_string</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">binary types</th>
+    </tr>
+    <tr>
+      <td><code>base64Binary</code></td>
+      <td><code>base64_binary</code></td>
+      <td rowspan="2"><a href="#2.5.6">Section 2.5.6, "Mapping for
+         <code>base64Binary</code> and <code>hexBinary</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>hexBinary</code></td>
+      <td><code>hex_binary</code></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">date/time types</th>
+    </tr>
+    <tr>
+      <td><code>date</code></td>
+      <td><code>date</code></td>
+      <td><a href="#2.5.8">Section 2.5.8, "Mapping for
+          <code>date</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>dateTime</code></td>
+      <td><code>date_time</code></td>
+      <td><a href="#2.5.9">Section 2.5.9, "Mapping for
+          <code>dateTime</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>duration</code></td>
+      <td><code>duration</code></td>
+      <td><a href="#2.5.10">Section 2.5.10, "Mapping for
+          <code>duration</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gDay</code></td>
+      <td><code>gday</code></td>
+      <td><a href="#2.5.11">Section 2.5.11, "Mapping for
+          <code>gDay</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonth</code></td>
+      <td><code>gmonth</code></td>
+      <td><a href="#2.5.12">Section 2.5.12, "Mapping for
+          <code>gMonth</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gMonthDay</code></td>
+      <td><code>gmonth_day</code></td>
+      <td><a href="#2.5.13">Section 2.5.13, "Mapping for
+          <code>gMonthDay</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYear</code></td>
+      <td><code>gyear</code></td>
+      <td><a href="#2.5.14">Section 2.5.14, "Mapping for
+          <code>gYear</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>gYearMonth</code></td>
+      <td><code>gyear_month</code></td>
+      <td><a href="#2.5.15">Section 2.5.15, "Mapping for
+          <code>gYearMonth</code>"</a></td>
+    </tr>
+    <tr>
+      <td><code>time</code></td>
+      <td><code>time</code></td>
+      <td><a href="#2.5.16">Section 2.5.16, "Mapping for
+          <code>time</code>"</a></td>
+    </tr>
+
+    <tr>
+      <th colspan="3">entity types</th>
+    </tr>
+    <tr>
+      <td><code>ENTITY</code></td>
+      <td><code>entity</code></td>
+      <td>type derived from <code>name</code></td>
+    </tr>
+    <tr>
+      <td><code>ENTITIES</code></td>
+      <td><code>entities</code></td>
+      <td>type derived from <code>sequence&lt;entity></code></td>
+    </tr>
+  </table>
+
+  <p>All XML Schema built-in types are mapped to C++ classes that are
+     derived from the <code>xml_schema::simple_type</code> class except
+     where the mapping is to a fundamental C++ type.</p>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. One notable extension
+     to the standard interface that is available only for
+     sequences of non-fundamental C++ types is the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     member functions which instead of the constant reference
+     to the element type accept automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, 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.
+  </p>
+
+  <h3><a name="2.5.1">2.5.1 Inheritance from Built-in Data Types</a></h3>
+
+  <p>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:</p>
+
+  <pre class="xml">
+&lt;simpleType name="my_int">
+  &lt;restriction base="int"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class my_int: public fundamental_base&lt;int>
+{
+  ...
+};
+  </pre>
+
+  <p>The <code>fundamental_base</code> 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:</p>
+
+  <pre class="c++">
+template &lt;typename X>
+class fundamental_base: public simple_type
+{
+public:
+  fundamental_base ();
+  fundamental_base (X)
+  fundamental_base (const fundamental_base&amp;)
+
+public:
+  fundamental_base&amp;
+  operator= (const X&amp;);
+
+public:
+  operator const X &amp; () const;
+  operator X&amp; ();
+
+  template &lt;typename Y>
+  operator Y () const;
+
+  template &lt;typename Y>
+  operator Y ();
+};
+  </pre>
+
+  <h3><a name="2.5.2">2.5.2 Mapping for <code>anyType</code></a></h3>
+
+  <p>The XML Schema <code>anyType</code> built-in data type is mapped to the
+     <code>xml_schema::type</code> C++ class:</p>
+
+  <pre class="c++">
+class type
+{
+public:
+  virtual
+  ~type ();
+
+  type ();
+  type (const type&amp;);
+
+  type&amp;
+  operator= (const type&amp;);
+
+  virtual type*
+  _clone () const;
+
+  // anyType DOM content.
+  //
+public:
+  typedef element_optional dom_content_optional;
+
+  const dom_content_optional&amp;
+  dom_content () const;
+
+  dom_content_optional&amp;
+  dom_content ();
+
+  void
+  dom_content (const xercesc::DOMElement&amp;);
+
+  void
+  dom_content (xercesc::DOMElement*);
+
+  void
+  dom_content (const dom_content_optional&amp;);
+
+  const xercesc::DOMDocument&amp;
+  dom_content_document () const;
+
+  xercesc::DOMDocument&amp;
+  dom_content_document ();
+
+  bool
+  null_content () const;
+
+  // DOM association.
+  //
+public:
+  const xercesc::DOMNode*
+  _node () const;
+
+  xercesc::DOMNode*
+  _node ();
+};
+  </pre>
+
+  <p>When <code>xml_schema::type</code> is used to create an instance
+     (as opposed to being a base of a derived type), it represents
+     the XML Schema <code>anyType</code> type. <code>anyType</code>
+     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 (<a href="#2.12">Section
+     2.12, "Mapping for <code>any</code> and
+     <code>anyAttribute</code>"</a>).</p>
+
+  <p>To enable automatic extraction of <code>anyType</code> content
+     during parsing, the <code>--generate-any-type</code> 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 <a href="#3.1">Section 3.1, "Initializing the
+     Xerces-C++ Runtime"</a>.</p>
+
+  <p>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 <a href="#2.12.2">Section 2.12.2, "Mapping for <code>any</code>
+     with the Optional Cardinality Class"</a> for details on their
+     semantics.</p>
+
+  <p>The <code>dom_content_document()</code> function returns the
+     DOM document used to store the raw XML content corresponding
+     to the <code>anyType</code> instance. It is equivalent to the
+     <code>dom_document()</code> function generated for types
+     with wildcards.</p>
+
+  <p>The <code>null_content()</code> 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
+     <code>anyType</code> or empty string for <code>anySimpleType</code>
+     (see the following section for details on <code>anySimpleType</code>).</p>
+
+  <p>For more information on DOM association refer to
+     <a href="#5.1">Section 5.1, "DOM Association"</a>.</p>
+
+  <h3><a name="2.5.3">2.5.3 Mapping for <code>anySimpleType</code></a></h3>
+
+  <p>The XML Schema <code>anySimpleType</code> built-in data type is mapped
+     to the <code>xml_schema::simple_type</code> C++ class:</p>
+
+  <pre class="c++">
+class simple_type: public type
+{
+public:
+  simple_type ();
+  simple_type (const C*);
+  simple_type (const std::basic_string&lt;C>&amp;);
+
+  simple_type (const simple_type&amp;);
+
+  simple_type&amp;
+  operator= (const simple_type&amp;);
+
+  virtual simple_type*
+  _clone () const;
+
+  // anySimpleType text content.
+  //
+public:
+  const std::basic_string&lt;C>&amp;
+  text_content () const;
+
+  std::basic_string&lt;C>&amp;
+  text_content ();
+
+  void
+  text_content (const std::basic_string&lt;C>&amp;);
+};
+  </pre>
+
+  <p>When <code>xml_schema::simple_type</code> is used to create an instance
+     (as opposed to being a base of a derived type), it represents
+     the XML Schema <code>anySimpleType</code> type. <code>anySimpleType</code>
+     allows any simple content. In the C++/Tree mapping this content can
+     be represented as a string and accessed or modified with the
+     <code>text_content()</code> functions shown above.</p>
+
+  <h3><a name="2.5.4">2.5.4 Mapping for <code>QName</code></a></h3>
+
+  <p>The XML Schema <code>QName</code> built-in data type is mapped to the
+     <code>xml_schema::qname</code> C++ class:</p>
+
+  <pre class="c++">
+class qname: public simple_type
+{
+public:
+  qname (const ncname&amp;);
+  qname (const uri&amp;, const ncname&amp;);
+  qname (const qname&amp;);
+
+public:
+  qname&amp;
+  operator= (const qname&amp;);
+
+public:
+  virtual qname*
+  _clone () const;
+
+public:
+  bool
+  qualified () const;
+
+  const uri&amp;
+  namespace_ () const;
+
+  const ncname&amp;
+  name () const;
+};
+  </pre>
+
+  <p>The <code>qualified</code> accessor function can be used to determine
+     if the name is qualified.</p>
+
+  <h3><a name="2.5.5">2.5.5 Mapping for <code>IDREF</code></a></h3>
+
+  <p>The XML Schema <code>IDREF</code> built-in data type is mapped to the
+     <code>xml_schema::idref</code> C++ class. This class implements the
+     smart pointer C++ idiom:</p>
+
+  <pre class="c++">
+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&lt;C>&amp;);
+  idref (const std::basic_string&lt;C>&amp;,
+         std::size_t pos,
+         std::size_t n = npos);
+
+public:
+  idref (const idref&amp;);
+
+public:
+  virtual idref*
+  _clone () const;
+
+public:
+  idref&amp;
+  operator= (C c);
+
+  idref&amp;
+  operator= (const C* s);
+
+  idref&amp;
+  operator= (const std::basic_string&lt;C>&amp;)
+
+  idref&amp;
+  operator= (const idref&amp;);
+
+public:
+  const type*
+  operator-> () const;
+
+  type*
+  operator-> ();
+
+  const type&amp;
+  operator* () const;
+
+  type&amp;
+  operator* ();
+
+  const type*
+  get () const;
+
+  type*
+  get ();
+
+  // Conversion to bool.
+  //
+public:
+  typedef void (idref::*bool_convertible)();
+  operator bool_convertible () const;
+};
+  </pre>
+
+  <p>The object, <code>idref</code> instance refers to, is the immediate
+     container of the matching <code>id</code> instance. For example,
+     with the following instance document and schema:
+  </p>
+
+
+  <pre class="xml">
+&lt;!-- test.xml -->
+&lt;root>
+  &lt;object id="obj-1" text="hello"/>
+  &lt;reference>obj-1&lt;/reference>
+&lt;/root>
+
+&lt;!-- test.xsd -->
+&lt;schema>
+  &lt;complexType name="object_type">
+    &lt;attribute name="id" type="ID"/>
+    &lt;attribute name="text" type="string"/>
+  &lt;/complexType>
+
+  &lt;complexType name="root_type">
+    &lt;sequence>
+      &lt;element name="object" type="object_type"/>
+      &lt;element name="reference" type="IDREF"/>
+    &lt;/sequence>
+  &lt;/complexType>
+
+  &lt;element name="root" type="root_type"/>
+&lt;/schema>
+  </pre>
+
+  <p>The <code>ref</code> instance in the code below will refer to
+     an object of type <code>object_type</code>:</p>
+
+  <pre class="c++">
+root_type&amp; root = ...;
+xml_schema::idref&amp; ref (root.reference ());
+object_type&amp; obj (dynamic_cast&lt;object_type&amp;> (*ref));
+cout &lt;&lt; obj.text () &lt;&lt; endl;
+  </pre>
+
+  <p>The smart pointer interface of the <code>idref</code> class always
+     returns a pointer or reference to <code>xml_schema::type</code>.
+     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
+     <code>xml_schema::type</code>). As a special extension to the XML
+     Schema language, the mapping supports static typing of <code>idref</code>
+     references by employing the <code>refType</code> extension attribute.
+     The following example illustrates this mechanism:
+  </p>
+
+  <pre class="xml">
+&lt;!-- test.xsd -->
+&lt;schema
+  xmlns:xse="https://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      &lt;element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+&lt;/schema>
+  </pre>
+
+  <p>With this modification we do not need to do manual casting anymore:
+  </p>
+
+  <pre class="c++">
+root_type&amp; root = ...;
+root_type::reference_type&amp; ref (root.reference ());
+object_type&amp; obj (*ref);
+cout &lt;&lt; ref->text () &lt;&lt; endl;
+  </pre>
+
+
+  <h3><a name="2.5.6">2.5.6 Mapping for <code>base64Binary</code> and
+      <code>hexBinary</code></a></h3>
+
+  <p>The XML Schema <code>base64Binary</code> and <code>hexBinary</code>
+     built-in data types are mapped to the
+     <code>xml_schema::base64_binary</code> and
+     <code>xml_schema::hex_binary</code> C++ classes, respectively. The
+     <code>base64_binary</code> and <code>hex_binary</code> classes
+     support a simple buffer abstraction by inheriting from the
+     <code>xml_schema::buffer</code> class:
+  </p>
+
+  <pre class="c++">
+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&amp;);
+
+  buffer&amp;
+  operator= (const buffer&amp;);
+
+  void
+  swap (buffer&amp;);
+
+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 ();
+};
+  </pre>
+
+  <p>The last overloaded constructor reuses an existing data buffer instead
+     of making a copy. If the <code>assume_ownership</code> argument is
+     <code>true</code>, the instance assumes ownership of the
+     memory block pointed to by the <code>data</code> argument and will
+     eventually release it by calling <code>operator delete</code>. The
+     <code>capacity</code> and <code>size</code> modifier functions return
+     <code>true</code> if the underlying buffer has moved.
+  </p>
+
+  <p>The <code>bounds</code> exception is thrown if the constructor
+     arguments violate the <code>(size&nbsp;&lt;=&nbsp;capacity)</code>
+     constraint.</p>
+
+  <p>The <code>base64_binary</code> and <code>hex_binary</code> classes
+     support the <code>buffer</code> interface and perform automatic
+     decoding/encoding from/to the Base64 and Hex formats, respectively:
+  </p>
+
+  <pre class="c++">
+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&amp;);
+
+  base64_binary&amp;
+  operator= (const base64_binary&amp;);
+
+  virtual base64_binary*
+  _clone () const;
+
+public:
+  std::basic_string&lt;C>
+  encode () const;
+};
+  </pre>
+
+  <pre class="c++">
+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&amp;);
+
+  hex_binary&amp;
+  operator= (const hex_binary&amp;);
+
+  virtual hex_binary*
+  _clone () const;
+
+public:
+  std::basic_string&lt;C>
+  encode () const;
+};
+  </pre>
+
+
+  <h2><a name="2.5.7">2.5.7 Time Zone Representation</a></h2>
+
+  <p>The <code>date</code>, <code>dateTime</code>, <code>gDay</code>,
+     <code>gMonth</code>, <code>gMonthDay</code>, <code>gYear</code>,
+     <code>gYearMonth</code>, and <code>time</code> XML Schema built-in
+     types all include an optional time zone component. The following
+     <code>xml_schema::time_zone</code> base class is used to represent
+     this information:</p>
+
+  <pre class="c++">
+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&amp;, const time_zone&amp;);
+
+bool
+operator!= (const time_zone&amp;, const time_zone&amp;);
+  </pre>
+
+  <p>The <code>zone_present()</code> accessor function returns <code>true</code>
+     if the time zone is specified. The <code>zone_reset()</code> modifier
+     function resets the time zone object to the <em>not specified</em>
+     state. If the time zone offset is negative then both hours and
+     minutes components are represented as negative integers.</p>
+
+
+  <h2><a name="2.5.8">2.5.8 Mapping for <code>date</code></a></h2>
+
+ <p>The XML Schema <code>date</code> built-in data type is mapped to the
+    <code>xml_schema::date</code> 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 <code>xml_schema::time_zone</code>
+    class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+    Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  date&amp;
+  operator= (const date&amp;);
+
+  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&amp;, const date&amp;);
+
+bool
+operator!= (const date&amp;, const date&amp;);
+  </pre>
+
+  <h2><a name="2.5.9">2.5.9 Mapping for <code>dateTime</code></a></h2>
+
+ <p>The XML Schema <code>dateTime</code> built-in data type is mapped to the
+    <code>xml_schema::date_time</code> 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
+    <code>xml_schema::time_zone</code> class refer to <a href="#2.5.7">Section
+    2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  date_time&amp;
+  operator= (const date_time&amp;);
+
+  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&amp;, const date_time&amp;);
+
+bool
+operator!= (const date_time&amp;, const date_time&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.10">2.5.10 Mapping for <code>duration</code></a></h2>
+
+  <p>The XML Schema <code>duration</code> built-in data type is mapped to the
+    <code>xml_schema::duration</code> C++ class which represents a potentially
+     negative duration in the form of years, months, days, hours, minutes,
+     and seconds. Its interface is presented below.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  duration&amp;
+  operator= (const duration&amp;);
+
+  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&amp;, const duration&amp;);
+
+bool
+operator!= (const duration&amp;, const duration&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.11">2.5.11 Mapping for <code>gDay</code></a></h2>
+
+  <p>The XML Schema <code>gDay</code> built-in data type is mapped to the
+    <code>xml_schema::gday</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gday&amp;
+  operator= (const gday&amp;);
+
+  virtual gday*
+  _clone () const;
+
+public:
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gday&amp;, const gday&amp;);
+
+bool
+operator!= (const gday&amp;, const gday&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.12">2.5.12 Mapping for <code>gMonth</code></a></h2>
+
+  <p>The XML Schema <code>gMonth</code> built-in data type is mapped to the
+    <code>xml_schema::gmonth</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gmonth&amp;
+  operator= (const gmonth&amp;);
+
+  virtual gmonth*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gmonth&amp;, const gmonth&amp;);
+
+bool
+operator!= (const gmonth&amp;, const gmonth&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.13">2.5.13 Mapping for <code>gMonthDay</code></a></h2>
+
+  <p>The XML Schema <code>gMonthDay</code> built-in data type is mapped to the
+    <code>xml_schema::gmonth_day</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gmonth_day&amp;
+  operator= (const gmonth_day&amp;);
+
+  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&amp;, const gmonth_day&amp;);
+
+bool
+operator!= (const gmonth_day&amp;, const gmonth_day&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.14">2.5.14 Mapping for <code>gYear</code></a></h2>
+
+  <p>The XML Schema <code>gYear</code> built-in data type is mapped to the
+    <code>xml_schema::gyear</code> C++ class which represents a year with
+     an optional time zone. Its interface is presented below. For more
+     information on the base <code>xml_schema::time_zone</code> class refer
+     to <a href="#2.5.7">Section 2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gyear&amp;
+  operator= (const gyear&amp;);
+
+  virtual gyear*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+};
+
+bool
+operator== (const gyear&amp;, const gyear&amp;);
+
+bool
+operator!= (const gyear&amp;, const gyear&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.15">2.5.15 Mapping for <code>gYearMonth</code></a></h2>
+
+  <p>The XML Schema <code>gYearMonth</code> built-in data type is mapped to
+     the <code>xml_schema::gyear_month</code> 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 <code>xml_schema::time_zone</code>
+     class refer to <a href="#2.5.7">Section 2.5.7, "Time Zone
+     Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  gyear_month&amp;
+  operator= (const gyear_month&amp;);
+
+  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&amp;, const gyear_month&amp;);
+
+bool
+operator!= (const gyear_month&amp;, const gyear_month&amp;);
+  </pre>
+
+
+  <h2><a name="2.5.16">2.5.16 Mapping for <code>time</code></a></h2>
+
+  <p>The XML Schema <code>time</code> built-in data type is mapped to
+     the <code>xml_schema::time</code> C++ class which represents hours,
+     minutes, and seconds with an optional time zone. Its interface is
+     presented below. For more information on the base
+     <code>xml_schema::time_zone</code> class refer to
+     <a href="#2.5.7">Section 2.5.7, "Time Zone Representation"</a>.</p>
+
+  <pre class="c++">
+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&amp;);
+
+  time&amp;
+  operator= (const time&amp;);
+
+  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&amp;, const time&amp;);
+
+bool
+operator!= (const time&amp;, const time&amp;);
+  </pre>
+
+
+  <!-- Mapping for Simple Types -->
+
+  <h2><a name="2.6">2.6 Mapping for Simple Types</a></h2>
+
+  <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 constructor,
+     a public copy assignment operator, and a public virtual
+     <code>_clone</code> function. The <code>_clone</code> function is
+     declared <code>const</code>, does not take any arguments, and returns
+     a pointer to a complete copy of the instance allocated in the free
+     store. The <code>_clone</code> function shall be used to make copies
+     when static type and dynamic type of the instance may differ (see
+     <a href="#2.11">Section 2.11, "Mapping for <code>xsi:type</code>
+     and Substitution Groups"</a>). For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="object">
+  ...
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: ...
+{
+public:
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  </pre>
+
+  <p>The base class specification and the rest of the class definition
+     depend on the type of derivation used to define the simple type. </p>
+
+
+  <h3><a name="2.6.1">2.6.1 Mapping for Derivation by Restriction</a></h3>
+
+  <p>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 <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>, the
+     resulting C++ class defines a public constructor with the base type
+     as its single argument. For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="object">
+  &lt;restriction base="base">
+    ...
+  &lt;/restriction>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public base
+{
+public:
+  object (const base&amp;);
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+};
+  </pre>
+
+
+  <h3><a name="2.6.2">2.6.2 Mapping for Enumerations</a></h3>
+
+<p>XML Schema restriction by enumeration is mapped to a C++ class
+   with semantics similar to C++ <code>enum</code>. Each XML Schema
+   enumeration element is mapped to a C++ enumerator with the
+   name derived from the <code>value</code> attribute and defined
+   in the class scope. In addition to the members
+   described in <a href="#2.6">Section 2.6, "Mapping for Simple Types"</a>,
+   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.</p>
+
+<p>Furthermore, for string-based enumeration types, the resulting C++
+   class defines a public constructor with a single argument of type
+   <code>const C*</code> and a public constructor with a single
+   argument of type <code>const std::basic_string&lt;C>&amp;</code>.
+   For instance:</p>
+
+  <pre class="xml">
+&lt;simpleType name="color">
+  &lt;restriction base="string">
+    &lt;enumeration value="red"/>
+    &lt;enumeration value="green"/>
+    &lt;enumeration value="blue"/>
+  &lt;/restriction>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string&lt;C>&amp;);
+  color (const xml_schema::string&amp;);
+  color (const color&amp;);
+
+public:
+  color&amp;
+  operator= (value);
+
+  color&amp;
+  operator= (const color&amp;);
+
+public:
+  virtual color*
+  _clone () const;
+
+public:
+  operator value () const;
+};
+  </pre>
+
+  <h3><a name="2.6.3">2.6.3 Mapping for Derivation by List</a></h3>
+
+  <p>XML Schema derivation by list is mapped to C++ public
+     inheritance from <code>xml_schema::simple_type</code>
+     (<a href="#2.5.3">Section 2.5.3, "Mapping for
+     <code>anySimpleType</code>"</a>) and a suitable sequence type.
+     The list item type becomes the element type of the sequence.
+     In addition to the members described in <a href="#2.6">Section 2.6,
+     "Mapping for Simple Types"</a>, the resulting C++ class defines
+     a public default constructor, a public constructor
+     with the first argument of type <code>size_type</code> 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:
+  </p>
+
+  <pre class="xml">
+&lt;simpleType name="int_list">
+  &lt;list itemType="int"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class int_list: public simple_type,
+                public sequence&lt;int>
+{
+public:
+  int_list ();
+  int_list (size_type n, int x);
+
+  template &lt;typename I>
+  int_list (const I&amp; begin, const I&amp; end);
+  int_list (const int_list&amp;);
+
+public:
+  int_list&amp;
+  operator= (const int_list&amp;);
+
+public:
+  virtual int_list*
+  _clone () const;
+};
+  </pre>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. One notable extension
+     to the standard interface that is available only for
+     sequences of non-fundamental C++ types is the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     member functions which instead of the constant reference
+     to the element type accept automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, 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.
+  </p>
+
+  <h3><a name="2.6.4">2.6.4 Mapping for Derivation by Union</a></h3>
+
+  <p>XML Schema derivation by union is mapped to C++ public
+     inheritance from <code>xml_schema::simple_type</code>
+     (<a href="#2.5.3">Section 2.5.3, "Mapping for
+     <code>anySimpleType</code>"</a>) and <code>std::basic_string&lt;C></code>.
+     In addition to the members described in <a href="#2.6">Section 2.6,
+     "Mapping for Simple Types"</a>, the resulting C++ class defines a
+     public constructor with a single argument of type <code>const C*</code>
+     and a public constructor with a single argument of type
+     <code>const std::basic_string&lt;C>&amp;</code>. For instance:
+  </p>
+
+  <pre class="xml">
+&lt;simpleType name="int_string_union">
+  &lt;xsd:union memberTypes="xsd:int xsd:string"/>
+&lt;/simpleType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class int_string_union: public simple_type,
+                        public std::basic_string&lt;C>
+{
+public:
+  int_string_union (const C*);
+  int_string_union (const std::basic_string&lt;C>&amp;);
+  int_string_union (const int_string_union&amp;);
+
+public:
+  int_string_union&amp;
+  operator= (const int_string_union&amp;);
+
+public:
+  virtual int_string_union*
+  _clone () const;
+};
+  </pre>
+
+  <h2><a name="2.7">2.7 Mapping for Complex Types</a></h2>
+
+  <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 constructor,
+     a public copy assignment operator, and a public virtual
+     <code>_clone</code> function. The <code>_clone</code> function is
+     declared <code>const</code>, does not take any arguments, and returns
+     a pointer to a complete copy of the instance allocated in the free
+     store. The <code>_clone</code> function shall be used to make copies
+     when static type and dynamic type of the instance may differ (see
+     <a href="#2.11">Section 2.11, "Mapping for <code>xsi:type</code>
+     and Substitution Groups"</a>).</p>
+
+  <p>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 <a href="#2.8">Section 2.8, "Mapping
+     for Local Elements and Attributes"</a>). 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 <code>std::unique_ptr</code> (C++11) or <code>std::auto_ptr</code>
+     (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 <code>std::[unique|auto]_ptr</code>
+     arguments are reset to <code>0</code>. For instance:</p>
+
+  <pre class="xml">
+&lt;complexType name="complex">
+  &lt;sequence>
+    &lt;element name="a" type="int"/>
+    &lt;element name="b" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="s-one" type="boolean"/>
+    &lt;element name="c-one" type="complex"/>
+    &lt;element name="optional" type="int" minOccurs="0"/>
+    &lt;element name="sequence" type="string" maxOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class complex: public xml_schema::type
+{
+public:
+  object (const int&amp; a, const xml_schema::string&amp; b);
+  object (const complex&amp;);
+
+public:
+  object&amp;
+  operator= (const complex&amp;);
+
+public:
+  virtual complex*
+  _clone () const;
+
+  ...
+
+};
+
+class object: public xml_schema::type
+{
+public:
+  object (const bool&amp; s_one, const complex&amp; c_one);
+  object (const bool&amp; s_one, std::[unique|auto]_ptr&lt;complex> c_one);
+  object (const object&amp;);
+
+public:
+  object&amp;
+  operator= (const object&amp;);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  </pre>
+
+  <p>Notice that the generated <code>complex</code> class does not
+     have the second (<code>std::[unique|auto]_ptr</code>) version of the
+     constructor since all its required members are of simple types.</p>
+
+  <p>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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;simpleContent>
+    &lt;extension base="date">
+      &lt;attribute name="lang" type="language" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::string
+{
+public:
+  object (const xml_schema::language&amp; lang);
+
+  object (const xml_schema::date&amp; base,
+          const xml_schema::language&amp; lang);
+
+  ...
+
+};
+  </pre>
+
+  <p>Furthermore, for string-based XML Schema complex types, the resulting C++
+     class also defines two  public constructors with the first arguments
+     of type <code>const C*</code> and <code>std::basic_string&lt;C>&amp;</code>,
+     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:</p>
+
+  <pre class="xml">
+&lt;simpleType name="color">
+  &lt;restriction base="string">
+    &lt;enumeration value="red"/>
+    &lt;enumeration value="green"/>
+    &lt;enumeration value="blue"/>
+  &lt;/restriction>
+&lt;/simpleType>
+
+&lt;complexType name="object">
+  &lt;simpleContent>
+    &lt;extension base="color">
+      &lt;attribute name="lang" type="language" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string&lt;C>&amp;);
+
+  ...
+
+};
+
+class object: color
+{
+public:
+  object (const color&amp; base,
+          const xml_schema::language&amp; lang);
+
+  object (const color::value&amp; base,
+          const xml_schema::language&amp; lang);
+
+  object (const C* base,
+          const xml_schema::language&amp; lang);
+
+  object (const std::basic_string&lt;C>&amp; base,
+          const xml_schema::language&amp; lang);
+
+  ...
+
+};
+  </pre>
+
+  <p>Additional constructors can be requested with the
+     <code>--generate-default-ctor</code> and
+     <code>--generate-from-base-ctor</code> options. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for details.</p>
+
+  <p>If an XML Schema complex type is not explicitly derived from any type,
+     the resulting C++ class is derived from <code>xml_schema::type</code>.
+     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.
+  </p>
+
+  <p>The mapping for elements and attributes that are defined in a complex
+     type is described in <a href="#2.8">Section 2.8, "Mapping for Local
+     Elements and Attributes"</a>.
+  </p>
+
+  <h3><a name="2.7.1">2.7.1 Mapping for Derivation by Extension</a></h3>
+
+  <p>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.
+  </p>
+
+  <h3><a name="2.7.2">2.7.2 Mapping for Derivation by Restriction</a></h3>
+
+  <p>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.
+  </p>
+
+  <!-- 2.8 Mapping for Local Elements and Attributes -->
+
+  <h2><a name="2.8">2.8 Mapping for Local Elements and Attributes</a></h2>
+
+   <p>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.
+   </p>
+
+   <p>Local XML Schema element and attribute definitions have the same
+      C++ mapping. Therefore, in this section, local elements and
+      attributes are collectively called members.
+   </p>
+
+   <p>While there are many different member cardinality combinations
+      (determined by the <code>use</code> attribute for attributes and
+       the <code>minOccurs</code> and <code>maxOccurs</code> attributes
+       for elements), the mapping divides all possible cardinality
+       combinations into three cardinality classes:
+   </p>
+
+   <dl>
+     <dt><i>one</i></dt>
+     <dd>attributes: <code>use == "required"</code></dd>
+     <dd>attributes: <code>use == "optional"</code> and has default or fixed value</dd>
+     <dd>elements: <code>minOccurs == "1"</code> and <code>maxOccurs == "1"</code></dd>
+
+     <dt><i>optional</i></dt>
+     <dd>attributes: <code>use == "optional"</code> and doesn't have default or fixed value</dd>
+     <dd>elements: <code>minOccurs == "0"</code> and <code>maxOccurs == "1"</code></dd>
+
+     <dt><i>sequence</i></dt>
+     <dd>elements: <code>maxOccurs > "1"</code></dd>
+   </dl>
+
+   <p>An optional attribute with a default or fixed value acquires this value
+      if the attribute hasn't been specified in an instance document (see
+      <a href="#A">Appendix A, "Default and Fixed Values"</a>). This
+      mapping places such optional attributes to the One cardinality
+      class.</p>
+
+   <p>A member is mapped to a set of public type definitions
+      (<code>typedef</code>s) 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:
+   </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string member_type;
+
+  const member_type&amp;
+  member () const;
+
+  ...
+
+};
+  </pre>
+
+   <p>In addition, if a member has a default or fixed value, a static
+      accessor function is generated that returns this value. For
+      example:</p>
+
+<pre class="xml">
+&lt;complexType name="object">
+  &lt;attribute name="data" type="string" default="test"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string data_type;
+
+  const data_type&amp;
+  data () const;
+
+  static const data_type&amp;
+  data_default_value ();
+
+  ...
+
+};
+  </pre>
+
+   <p>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.
+   </p>
+
+
+  <h3><a name="2.8.1">2.8.1 Mapping for Members with the One Cardinality Class</a></h3>
+
+   <p>For the One cardinality class, the type definitions consist of
+      an alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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 (<code>std::unique_ptr</code> or
+      <code>std::auto_ptr</code>, 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+
+  // Accessors.
+  //
+  const member_type&amp;
+  member () const;
+
+  member_type&amp;
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&amp;);
+
+  void
+  member (std::[unique|auto]_ptr&lt;member_type>);
+  ...
+
+};
+  </pre>
+
+   <p>In addition, if requested by specifying the <code>--generate-detach</code>
+      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:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  ...
+
+  std::[unique|auto]_ptr&lt;member_type>
+  detach_member ();
+  ...
+
+};
+  </pre>
+
+   <p>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.</p>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  string s (o.member ());                // get
+  object::member_type&amp; sr (o.member ()); // get
+
+  o.member ("hello");           // set, deep copy
+  o.member () = "hello";        // set, deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr&lt;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&lt;string> p (new string ("hello"));
+  o.member (p);                 // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (p);                 // re-attach
+}
+  </pre>
+
+
+<h3><a name="2.8.2">2.8.2 Mapping for Members with the Optional Cardinality Class</a></h3>
+
+   <p>For the Optional cardinality class, the type definitions consist of
+      an alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name and an alias for
+      the container type with the name created by appending the
+      <code>_optional</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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 (<code>std::unique_ptr</code> or
+      <code>std::auto_ptr</code>, 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:
+   </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string" minOccurs="0"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef optional&lt;member_type> member_optional;
+
+  // Accessors.
+  //
+  const member_optional&amp;
+  member () const;
+
+  member_optional&amp;
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&amp;);
+
+  void
+  member (std::[unique|auto]_ptr&lt;member_type>);
+
+  void
+  member (const member_optional&amp;);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The <code>optional</code> class template is defined in an
+     implementation-specific namespace and has the following
+     interface. The <code>[unique|auto]_ptr</code>-based constructor
+     and modifier function are only available if the template
+     argument is not a fundamental C++ type.
+  </p>
+
+  <pre class="c++">
+template &lt;typename X>
+class optional
+{
+public:
+  optional ();
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional (const X&amp;);
+
+  // Assumes ownership.
+  //
+  explicit
+  optional (std::[unique|auto]_ptr&lt;X>);
+
+  optional (const optional&amp;);
+
+public:
+  optional&amp;
+  operator= (const X&amp;);
+
+  optional&amp;
+  operator= (const optional&amp;);
+
+  // Pointer-like interface.
+  //
+public:
+  const X*
+  operator-> () const;
+
+  X*
+  operator-> ();
+
+  const X&amp;
+  operator* () const;
+
+  X&amp;
+  operator* ();
+
+  typedef void (optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const X&amp;
+  get () const;
+
+  X&amp;
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const X&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  set (std::[unique|auto]_ptr&lt;X>);
+
+  // Detach and return the contained value.
+  //
+  std::[unique|auto]_ptr&lt;X>
+  detach ();
+
+  void
+  reset ();
+};
+
+template &lt;typename X>
+bool
+operator== (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator!= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator&lt; (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator> (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator&lt;= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+
+template &lt;typename X>
+bool
+operator>= (const optional&lt;X>&amp;, const optional&lt;X>&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  if (o.member ().present ())       // test
+  {
+    string&amp; 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&amp; 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&lt;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&lt;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
+}
+  </pre>
+
+
+  <h3><a name="2.8.3">2.8.3 Mapping for Members with the Sequence Cardinality Class</a></h3>
+
+   <p>For the Sequence cardinality class, the type definitions consist of an
+      alias for the member's type with the name created by appending
+      the <code>_type</code> suffix to the member's name, an alias of
+      the container type with the name created by appending the
+      <code>_sequence</code> suffix to the member's name, an alias of
+      the iterator type with the name created by appending the
+      <code>_iterator</code> suffix to the member's name, and an alias
+      of the constant iterator type with the name created by appending the
+      <code>_const_iterator</code> suffix to the member's name.
+   </p>
+
+   <p>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.
+   </p>
+
+   <p>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:
+   </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="member" type="string" minOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef sequence&lt;member_type> member_sequence;
+  typedef member_sequence::iterator member_iterator;
+  typedef member_sequence::const_iterator member_const_iterator;
+
+  // Accessors.
+  //
+  const member_sequence&amp;
+  member () const;
+
+  member_sequence&amp;
+  member ();
+
+  // Modifier.
+  //
+  void
+  member (const member_sequence&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>sequence</code> 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 <code>std::vector</code>. Two notable extensions
+     to the standard interface that are available only for
+     sequences of non-fundamental C++ types are the addition of
+     the overloaded <code>push_back</code> and <code>insert</code>
+     as well as the <code>detach_back</code> and <code>detach</code>
+     member functions. The additional <code>push_back</code> and
+     <code>insert</code> functions accept an automatic pointer
+     (<code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     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 <code>detach_back</code> and
+     <code>detach</code> 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:</p>
+
+  <pre class="c++">
+template &lt;typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back (std::[unique|auto]_ptr&lt;X>)
+
+  iterator
+  insert (iterator position, std::[unique|auto]_ptr&lt;X>)
+
+  std::[unique|auto]_ptr&lt;X>
+  detach_back (bool pop = true);
+
+  iterator
+  detach (iterator position,
+          std::[unique|auto]_ptr&lt;X>&amp; result,
+          bool erase = true)
+
+  ...
+}
+  </pre>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o)
+{
+  using xml_schema::string;
+
+  object::member_sequence&amp; s (o.member ());
+
+  // Iteration.
+  //
+  for (object::member_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    string&amp; value (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back ("hello");  // deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr&lt;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&lt;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
+}
+  </pre>
+
+  <h3><a name="2.8.4">2.8.4 Element Order</a></h3>
+
+  <p>C++/Tree is a "flattening" mapping in a sense that many levels of
+     nested compositors (<code>choice</code> and <code>sequence</code>),
+     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:</p>
+
+  <pre class="xml">
+&lt;complexType name="withdraw">
+  &lt;sequence>
+    &lt;element name="account" type="unsignedInt"/>
+    &lt;element name="amount" type="unsignedInt"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="deposit">
+  &lt;sequence>
+    &lt;element name="account" type="unsignedInt"/>
+    &lt;element name="amount" type="unsignedInt"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;complexType name="batch">
+  &lt;choice minOccurs="0" maxOccurs="unbounded">
+    &lt;element name="withdraw" type="withdraw"/>
+    &lt;element name="deposit" type="deposit"/>
+  &lt;/choice>
+&lt;/complexType>
+  </pre>
+
+  <p>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.</p>
+
+  <p>For the <code>batch</code> 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.</p>
+
+  <p>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.</p>
+
+  <p>There are several command line options that control which
+     schema types are treated as ordered. To make an individual
+     type ordered, we use the <code>--ordered-type</code> option,
+     for example:</p>
+
+  <pre class="term">
+--ordered-type batch
+  </pre>
+
+  <p>To automatically treat all the types that are derived from an ordered
+     type also ordered, we use the <code>--ordered-type-derived</code>
+     option. This is primarily useful if you would like to iterate
+     over the complete hierarchy's content using the content order
+     sequence (discussed below).</p>
+
+  <p>Ordered types are also useful for handling mixed content. To
+     automatically mark all the types with mixed content as ordered
+     we use the <code>--ordered-type-mixed</code> option. For more
+     information on handling mixed content see <a href="#2.13">Section
+     2.13, "Mapping for Mixed Content Models"</a>.</p>
+
+  <p>Finally, we can mark all the types in the schema we are
+     compiling with the <code>--ordered-type-all</code> 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
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information on
+     these options.</p>
+
+  <p>Once a type is marked ordered, C++/Tree alters its mapping
+     in several ways. Firstly, for each local element, element
+     wildcard (<a href="#2.12.4">Section 2.12.4, "Element Wildcard
+     Order"</a>), and mixed content text (<a href="#2.13">Section
+     2.13, "Mapping for Mixed Content Models"</a>) 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 <code>batch</code> class changes
+     once we make it ordered:</p>
+
+  <pre class="c++">
+class batch: public xml_schema::type
+{
+public:
+  // withdraw
+  //
+  typedef withdraw withdraw_type;
+  typedef sequence&lt;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&amp;
+  withdraw () const;
+
+  withdraw_sequence&amp;
+  withdraw ();
+
+  void
+  withdraw (const withdraw_sequence&amp;);
+
+  // deposit
+  //
+  typedef deposit deposit_type;
+  typedef sequence&lt;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&amp;
+  deposit () const;
+
+  deposit_sequence&amp;
+  deposit ();
+
+  void
+  deposit (const deposit_sequence&amp;);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector&lt;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&amp;
+  content_order () const;
+
+  content_order_sequence&amp;
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>Notice the <code>withdraw_id</code> and <code>deposit_id</code>
+     content ids as well as the extra <code>content_order</code>
+     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 <code>content_order</code>
+     sequence while during serialization this sequence is used to
+     determine the order in which content is serialized. The
+     <code>content_order</code> sequence is also copied during
+     copy construction and assigned during copy assignment. It is also
+     taken into account during comparison.</p>
+
+  <p>The entry type of the <code>content_order</code> sequence is the
+     <code>xml_schema::content_order</code> type that has the following
+     interface:</p>
+
+  <pre class="c++">
+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&amp;, const content_order&amp;);
+
+  bool
+  operator!= (const content_order&amp;, const content_order&amp;);
+
+  bool
+  operator&lt; (const content_order&amp;, const content_order&amp;);
+}
+  </pre>
+
+  <p>The <code>content_order</code> 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, <code>withdraw_id</code> or <code>deposit_id</code>
+     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 <code>withdraw_id</code>,
+     then the index will point into the <code>withdraw</code> element
+     sequence.</p>
+
+  <p>With all this information we can now examine how to iterate over
+     transaction in the batch in content order:</p>
+
+  <pre class="c++">
+batch&amp; 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&amp; t (b.withdraw ()[i->index]);
+      cerr &lt;&lt; t.account () &lt;&lt; " withdraw " &lt;&lt; t.amount () &lt;&lt; endl;
+      break;
+    }
+  case batch::deposit_id:
+    {
+      const deposit&amp; t (b.deposit ()[i->index]);
+      cerr &lt;&lt; t.account () &lt;&lt; " deposit " &lt;&lt; t.amount () &lt;&lt; endl;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+  </pre>
+
+  <p>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.</p>
+
+  <p>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:</p>
+
+  <pre class="c++">
+using xml_schema::content_order;
+
+batch::deposit_sequence&amp; d (b.deposit ());
+batch::withdraw_sequence&amp; w (b.withdraw ());
+batch::content_order_sequence&amp; co (b.content_order ());
+
+d.push_back (deposit (123456789, 100000));
+co.push_back (content_order (batch::deposit_id, d.size () - 1));
+  </pre>
+
+  <p>In the above example we first added the content (deposit
+     transaction) and then updated the content order information
+     by adding an entry with <code>deposit_id</code> content
+     id and the index of the just added deposit transaction.</p>
+
+  <p>Removing the last transaction can be easy if we know which
+     transaction (deposit or withdrawal) is last:</p>
+
+  <pre class="c++">
+d.pop_back ();
+co.pop_back ();
+  </pre>
+
+  <p>If, however, we do not know which transaction is last, then
+     things get a bit more complicated:</p>
+
+  <pre class="c++">
+switch (co.back ().id)
+{
+case batch::withdraw_id:
+  {
+    d.pop_back ();
+    break;
+  }
+case batch::deposit_id:
+  {
+    w.pop_back ();
+    break;
+  }
+}
+
+co.pop_back ();
+  </pre>
+
+  <p>The following example shows how to add a transaction at the
+     beginning of the batch:</p>
+
+  <pre class="c++">
+w.push_back (withdraw (123456789, 100000));
+co.insert (co.begin (),
+           content_order (batch::withdraw_id, w.size () - 1));
+  </pre>
+
+  <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 withdrawal:</p>
+
+  <pre class="c++">
+w[0].amount (10000);
+  </pre>
+
+  <p>For the complete working code shown in this section refer to the
+     <code>order/element</code> example in the
+     <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <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 hierarchy. In this case
+     the content order sequence for the derived type contains
+     ordering information for both base and derived content.</p>
+
+  <p>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, <code>std::vector</code>, 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
+     <code>std::vector</code> but also search by the content
+     id as well as the content id and index pair.</p>
+
+  <p>While C++/Tree does not provide this functionality by
+     default, it allows us to specify a custom container
+     type for content order with the <code>--order-container</code>
+     command line option. The only requirement from the
+     generated code side for such a container is to provide
+     the <code>vector</code>-like <code>push_back()</code>,
+     <code>size()</code>, and const iteration interfaces.</p>
+
+  <p>As an example, here is how we can use the Boost Multi-Index
+     container for content order. First we create the
+     <code>content-order-container.hxx</code> header with the
+     following definition:</p>
+
+  <pre class="c++">
+#ifndef CONTENT_ORDER_CONTAINER
+#define CONTENT_ORDER_CONTAINER
+
+#include &lt;cstddef> // std::size_t
+
+#include &lt;boost/multi_index_container.hpp>
+#include &lt;boost/multi_index/member.hpp>
+#include &lt;boost/multi_index/identity.hpp>
+#include &lt;boost/multi_index/ordered_index.hpp>
+#include &lt;boost/multi_index/random_access_index.hpp>
+
+struct by_id {};
+struct by_id_index {};
+
+template &lt;typename T>
+using content_order_container =
+  boost::multi_index::multi_index_container&lt;
+    T,
+    boost::multi_index::indexed_by&lt;
+      boost::multi_index::random_access&lt;>,
+      boost::multi_index::ordered_unique&lt;
+        boost::multi_index::tag&lt;by_id_index>,
+        boost::multi_index::identity&lt;T>
+      >,
+      boost::multi_index::ordered_non_unique&lt;
+        boost::multi_index::tag&lt;by_id>,
+        boost::multi_index::member&lt;T, std::size_t, &amp;T::id>
+      >
+    >
+  >;
+
+#endif
+  </pre>
+
+  <p>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):</p>
+
+  <pre class="term">
+--hxx-prologue '#include "content-order-container.hxx"'
+--order-container content_order_container
+  </pre>
+
+  <p>With these changes we can now use the multi-index functionality,
+     for example, to search for a specific content id:</p>
+
+  <pre class="c++">
+typedef batch::content_order_sequence::index&lt;by_id>::type id_set;
+typedef id_set::iterator id_iterator;
+
+const id_set&amp; ids (b.content_order ().get&lt;by_id> ());
+
+std::pair&lt;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&amp; t (b.deposit ()[i->index]);
+  cerr &lt;&lt; t.account () &lt;&lt; " deposit " &lt;&lt; t.amount () &lt;&lt; endl;
+}
+  </pre>
+
+  <h2><a name="2.9">2.9 Mapping for Global Elements</a></h2>
+
+  <p>An XML Schema element definition is called global if it appears
+     directly under the <code>schema</code> 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
+     <a href="#2.9.1">Section 2.9.1, "Element Types"</a> 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 <a href="#2.9.2">Section 2.9.2, "Element Map"</a>
+     for details.
+  </p>
+
+  <p>The parsing functions read XML instance documents and return
+     corresponding object models as an automatic pointer
+     (<code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     depending on the C++ standard selected). Their signatures
+     have the following pattern (<code>type</code> denotes
+     element's type and <code>name</code> denotes element's
+     name):
+  </p>
+
+  <pre class="c++">
+std::[unique|auto]_ptr&lt;type>
+name (....);
+  </pre>
+
+  <p>The process of parsing, including the exact signatures of the parsing
+     functions, is the subject of <a href="#3">Chapter 3, "Parsing"</a>.
+  </p>
+
+  <p>The serialization functions write object models back to XML instance
+     documents. Their signatures have the following pattern:
+  </p>
+
+  <pre class="c++">
+void
+name (&lt;stream type>&amp;, const type&amp;, ....);
+  </pre>
+
+  <p>The process of serialization, including the exact signatures of the
+     serialization functions, is the subject of <a href="#4">Chapter 4,
+     "Serialization"</a>.
+  </p>
+
+
+  <h3><a name="2.9.1">2.9.1 Element Types</a></h3>
+
+  <p>The generation of element types is requested with the
+     <code>--generate-element-type</code> 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
+     <code>xml_schema::element_type</code> 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 <code>"value"</code>. 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="type">
+  &lt;sequence>
+    ...
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="type"/>
+  </pre>
+
+<p>is mapped to:</p>
+
+  <pre class="c++">
+class type
+{
+  ...
+};
+
+class root: public xml_schema::element_type
+{
+public:
+  // Element value.
+  //
+  typedef type value_type;
+
+  const value_type&amp;
+  value () const;
+
+  value_type&amp;
+  value ();
+
+  void
+  value (const value_type&amp;);
+
+  void
+  value (std::[unique|auto]_ptr&lt;value_type>);
+
+  // Constructors.
+  //
+  root (const value_type&amp;);
+
+  root (std::[unique|auto]_ptr&lt;value_type>);
+
+  root (const xercesc::DOMElement&amp;, xml_schema::flags = 0);
+
+  root (const root&amp;, xml_schema::flags = 0);
+
+  virtual root*
+  _clone (xml_schema::flags = 0) const;
+
+  // Element name and namespace.
+  //
+  static const std::string&amp;
+  name ();
+
+  static const std::string&amp;
+  namespace_ ();
+
+  virtual const std::string&amp;
+  _name () const;
+
+  virtual const std::string&amp;
+  _namespace () const;
+
+  // Element value as xml_schema::type.
+  //
+  virtual const xml_schema::type*
+  _value () const;
+
+  virtual xml_schema::type*
+  _value ();
+};
+
+void
+operator&lt;&lt; (xercesc::DOMElement&amp;, const root&amp;);
+  </pre>
+
+  <p>The <code>xml_schema::element_type</code> class is a common
+     base type for all element types and is defined as follows:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class element_type
+  {
+  public:
+    virtual
+    ~element_type ();
+
+    virtual element_type*
+    _clone (flags f = 0) const = 0;
+
+    virtual const std::basic_string&lt;C>&amp;
+    _name () const = 0;
+
+    virtual const std::basic_string&lt;C>&amp;
+    _namespace () const = 0;
+
+    virtual xml_schema::type*
+    _value () = 0;
+
+    virtual const xml_schema::type*
+    _value () const = 0;
+  };
+}
+  </pre>
+
+  <p>The <code>_value()</code> 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 <code>xml_schema::type</code>.
+  </p>
+
+  <p>Unlike parsing and serialization functions, element types
+     are only capable of parsing and serializing from/to a
+     <code>DOMElement</code> 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.</p>
+
+
+  <h3><a name="2.9.2">2.9.2 Element Map</a></h3>
+
+  <p>When element types are generated for root elements it is also
+     possible to request the generation of an element map with the
+     <code>--generate-element-map</code> option. The element map
+     allows uniform parsing and serialization of multiple root
+     elements via the common <code>xml_schema::element_type</code>
+     base type. The <code>xml_schema::element_map</code> class is
+     defined as follows:</p>
+
+  <pre class="c++">
+namespace xml_schema
+{
+  class element_map
+  {
+  public:
+    static std::[unique|auto]_ptr&lt;xml_schema::element_type>
+    parse (const xercesc::DOMElement&amp;, flags = 0);
+
+    static void
+    serialize (xercesc::DOMElement&amp;, const element_type&amp;);
+  };
+}
+  </pre>
+
+  <p>The <code>parse()</code> function creates the corresponding
+     element type object based on the element name and namespace
+     and returns it as an automatic pointer (<code>std::unique_ptr</code>
+     or <code>std::auto_ptr</code>, depending on the C++ standard
+     selected) to <code>xml_schema::element_type</code>.
+     The <code>serialize()</code> function serializes the passed element
+     object to <code>DOMElement</code>. Note that in case of
+     <code>serialize()</code>, the <code>DOMElement</code> object
+     should have the correct name and namespace. If no element type is
+     available for an element, both functions throw the
+     <code>xml_schema::no_element_info</code> exception:</p>
+
+  <pre class="c++">
+struct no_element_info: virtual exception
+{
+  no_element_info (const std::basic_string&lt;C>&amp; element_name,
+                   const std::basic_string&lt;C>&amp; element_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  element_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  element_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The application can discover the actual type of the element
+     object returned by <code>parse()</code> either using
+     <code>dynamic_cast</code> or by comparing element names and
+     namespaces. The following code fragments illustrate how the
+     element map can be used:</p>
+
+  <pre class="c++">
+// Parsing.
+//
+DOMElement&amp; e = ... // Parse XML to DOM.
+
+unique_ptr&lt;xml_schema::element_type> r (
+  xml_schema::element_map::parse (e));
+
+if (root1 r1 = dynamic_cast&lt;root1*> (r.get ()))
+{
+  ...
+}
+else if (r->_name == root2::name () &amp;&amp;
+         r->_namespace () == root2::namespace_ ())
+{
+  root2&amp; r2 (static_cast&lt;root2&amp;> (*r));
+
+  ...
+}
+  </pre>
+
+  <pre class="c++">
+// Serialization.
+//
+xml_schema::element_type&amp; r = ...
+
+string name (r._name ());
+string ns (r._namespace ());
+
+DOMDocument&amp; doc = ... // Create a new DOMDocument with name and ns.
+DOMElement&amp; e (*doc->getDocumentElement ());
+
+xml_schema::element_map::serialize (e, r);
+
+// Serialize DOMDocument to XML.
+  </pre>
+
+  <!-- -->
+
+  <h2><a name="2.10">2.10 Mapping for Global Attributes</a></h2>
+
+  <p>An XML Schema attribute definition is called global if it appears
+     directly under the <code>schema</code> element. A global
+     attribute does not have any mapping.
+  </p>
+
+  <!--
+     When it is referenced from
+     a local attribute definition (using the <code>ref</code> attribute)
+     it is treated as a local attribute (see Section 2.8, "Mapping for
+     Local Elements and Attributes").
+  -->
+
+  <h2><a name="2.11">2.11 Mapping for <code>xsi:type</code> and Substitution
+      Groups</a></h2>
+
+  <p>The mapping provides optional support for the XML Schema polymorphism
+     features (<code>xsi:type</code> and substitution groups) which can
+     be requested with the <code>--generate-polymorphic</code> option.
+     When used, the dynamic type of a member may be different from
+     its static type. Consider the following schema definition and
+     instance document:
+  </p>
+
+  <pre class="xml">
+&lt;!-- test.xsd -->
+&lt;schema>
+  &lt;complexType name="base">
+    &lt;attribute name="text" type="string"/>
+  &lt;/complexType>
+
+  &lt;complexType name="derived">
+    &lt;complexContent>
+      &lt;extension base="base">
+        &lt;attribute name="extra-text" type="string"/>
+      &lt;/extension>
+    &lt;/complexContent>
+  &lt;/complexType>
+
+  &lt;complexType name="root_type">
+    &lt;sequence>
+      &lt;element name="item" type="base" maxOccurs="unbounded"/>
+    &lt;/sequence>
+  &lt;/complexType>
+
+  &lt;element name="root" type="root_type"/>
+&lt;/schema>
+
+&lt;!-- test.xml -->
+&lt;root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  &lt;item text="hello"/>
+  &lt;item text="hello" extra-text="world" xsi:type="derived"/>
+&lt;/root>
+  </pre>
+
+  <p>In the resulting object model, the container for
+     the <code>root::item</code> member will have two elements:
+     the first element's type will be <code>base</code> while
+     the second element's (dynamic) type will be
+     <code>derived</code>. This can be discovered using the
+     <code>dynamic_cast</code> operator as shown in the following
+     example:
+  </p>
+
+  <pre class="c++">
+void
+f (root&amp; r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    if (derived* d = dynamic_cast&lt;derived*> (&amp;(*i)))
+    {
+      // derived
+    }
+    else
+    {
+      // base
+    }
+  }
+}
+  </pre>
+
+  <p>The <code>_clone</code> virtual function should be used instead of
+     copy constructors to make copies of members that might use
+     polymorphism:
+  </p>
+
+  <pre class="c++">
+void
+f (root&amp; r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    std::unique_ptr&lt;base> c (i->_clone ());
+  }
+}
+  </pre>
+
+  <p>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 <code>--polymorphic-type</code> 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:</p>
+
+  <pre class="xml">
+&lt;!-- base.xsd -->
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;xs:complexType name="base">
+    &lt;xs:sequence>
+      &lt;xs:element name="b" type="xs:int"/>
+    &lt;/xs:sequence>
+  &lt;/xs:complexType>
+
+  &lt;!-- substitution group root -->
+  &lt;xs:element name="base" type="base"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <pre class="xml">
+&lt;!-- derived.xsd -->
+&lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  &lt;include schemaLocation="base.xsd"/>
+
+  &lt;xs:complexType name="derived">
+    &lt;xs:complexContent>
+      &lt;xs:extension base="base">
+        &lt;xs:sequence>
+          &lt;xs:element name="d" type="xs:string"/>
+        &lt;/xs:sequence>
+      &lt;/xs:extension>
+    &lt;/xs:complexContent>
+  &lt;/xs:complexType>
+
+  &lt;xs:element name="derived" type="derived" substitutionGroup="base"/>
+
+&lt;/xs:schema>
+  </pre>
+
+  <p>In this example we need to specify "<code>--polymorphic-type base</code>"
+     when compiling both schemas because the substitution group is declared
+     in a schema other than the one defining type <code>base</code>.</p>
+
+  <p>You can also indicate that all types should be treated as polymorphic
+     with the <code>--polymorphic-type-all</code>. However, this may result
+     in slower generated code with a greater footprint.</p>
+
+
+  <!-- Mapping for any and anyAttribute -->
+
+
+  <h2><a name="2.12">2.12 Mapping for <code>any</code> and <code>anyAttribute</code></a></h2>
+
+  <p>For the XML Schema <code>any</code> and <code>anyAttribute</code>
+     wildcards an optional mapping can be requested with the
+     <code>--generate-wildcard</code> 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 <a href="#3.1">Section 3.1,
+     "Initializing the Xerces-C++ Runtime"</a>.
+  </p>
+
+  <p>The mapping for <code>any</code> is similar to the mapping for
+     local elements (see <a href="#2.8">Section 2.8, "Mapping for Local
+     Elements and Attributes"</a>) except that the type used in the
+     wildcard mapping is <code>xercesc::DOMElement</code>. As with local
+     elements, the mapping divides all possible cardinality combinations
+     into three cardinality classes: <i>one</i>, <i>optional</i>, and
+     <i>sequence</i>.
+  </p>
+
+  <p>The mapping for <code>anyAttribute</code> represents the attributes
+     matched by this wildcard as a set of <code>xercesc::DOMAttr</code>
+     objects with a key being the attribute's name and namespace.</p>
+
+  <p>Similar to local elements and attributes, the <code>any</code> and
+     <code>anyAttribute</code> 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 <code>"any"</code>
+     for the <code>any</code> wildcard and <code>"any_attribute"</code>
+     for the <code>anyAttribute</code> wildcard. The accessor and modifier
+     functions are named <code>"any"</code> for the <code>any</code> wildcard
+     and <code>"any_attribute"</code> for the <code>anyAttribute</code>
+     wildcard. Subsequent wildcards in the same type have escaped names
+     such as <code>"any1"</code> or <code>"any_attribute1"</code>.
+  </p>
+
+  <p>Because Xerces-C++ DOM nodes always belong to a <code>DOMDocument</code>,
+     each type with a wildcard has an associated <code>DOMDocument</code>
+     object. The reference to this object can be obtained using the accessor
+     function called <code>dom_document</code>. The access to the document
+     object from the application code may be necessary to create or modify
+     the wildcard content. For example:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other"/>
+  &lt;/sequence>
+  &lt;anyAttribute namespace="##other"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // any
+  //
+  const xercesc::DOMElement&amp;
+  any () const;
+
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  ...
+
+  // 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&amp;
+  any_attribute () const;
+
+  any_attribute_set&amp;
+  any_attribute ();
+
+  ...
+
+  // DOMDocument object for wildcard content.
+  //
+  const xercesc::DOMDocument&amp;
+  dom_document () const;
+
+  xercesc::DOMDocument&amp;
+  dom_document ();
+
+  ...
+};
+  </pre>
+
+
+  <p>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 <code>any</code>
+     wildcard. They are described in the following sub-sections.
+  </p>
+
+
+  <h3><a name="2.12.1">2.12.1 Mapping for <code>any</code> with the One Cardinality Class</a></h3>
+
+  <p>For <code>any</code> 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 <code>xercesc::DOMElement</code> and
+     can be used for read-only access. The non-constant version returns
+     an unrestricted reference to <code>xercesc::DOMElement</code> and can
+     be used for read-write access.
+  </p>
+
+  <p>The first modifier function expects an argument of type reference
+     to constant <code>xercesc::DOMElement</code> and makes a deep copy
+     of its argument. The second modifier function expects an argument of
+     type pointer to <code>xercesc::DOMElement</code>. 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:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Accessors.
+  //
+  const xercesc::DOMElement&amp;
+  any () const;
+
+  xercesc::DOMElement&amp;
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  void
+  any (xercesc::DOMElement*);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  DOMElement&amp; e1 (o.any ());             // get
+  o.any (e)                              // set, deep copy
+  DOMDocument&amp; doc (o.dom_document ());
+  o.any (doc.createElement (...));       // set, assumes ownership
+}
+  </pre>
+
+  <h3><a name="2.12.2">2.12.2 Mapping for <code>any</code> with the Optional Cardinality Class</a></h3>
+
+  <p>For <code>any</code> with the Optional cardinality class, the type
+     definitions consist of an alias for the container type with name
+     <code>any_optional</code> (or <code>any1_optional</code>, etc., for
+     subsequent wildcards in the type definition).
+  </p>
+
+  <p>Unlike accessor functions for the One cardinality class, accessor
+     functions for the Optional cardinality class return references to
+     corresponding containers rather than directly to <code>DOMElement</code>.
+     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.
+  </p>
+
+  <p>The modifier functions are overloaded for <code>xercesc::DOMElement</code>
+     and the container type. The first modifier function expects an argument of
+     type reference to constant <code>xercesc::DOMElement</code> and
+     makes a deep copy of its argument. The second modifier function
+     expects an argument of type pointer to <code>xercesc::DOMElement</code>.
+     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:
+  </p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other" minOccurs="0"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_optional any_optional;
+
+  // Accessors.
+  //
+  const any_optional&amp;
+  any () const;
+
+  any_optional&amp;
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&amp;);
+
+  void
+  any (xercesc::DOMElement*);
+
+  void
+  any (const any_optional&amp;);
+
+  ...
+
+};
+  </pre>
+
+
+  <p>The <code>element_optional</code> container is a
+     specialization of the <code>optional</code> class template described
+     in <a href="#2.8.2">Section 2.8.2, "Mapping for Members with the Optional
+     Cardinality Class"</a>. Its interface is presented below:
+  </p>
+
+  <pre class="c++">
+class element_optional
+{
+public:
+  explicit
+  element_optional (xercesc::DOMDocument&amp;);
+
+  // Makes a deep copy.
+  //
+  element_optional (const xercesc::DOMElement&amp;, xercesc::DOMDocument&amp;);
+
+  // Assumes ownership.
+  //
+  element_optional (xercesc::DOMElement*, xercesc::DOMDocument&amp;);
+
+  element_optional (const element_optional&amp;, xercesc::DOMDocument&amp;);
+
+public:
+  element_optional&amp;
+  operator= (const xercesc::DOMElement&amp;);
+
+  element_optional&amp;
+  operator= (const element_optional&amp;);
+
+  // Pointer-like interface.
+  //
+public:
+  const xercesc::DOMElement*
+  operator-> () const;
+
+  xercesc::DOMElement*
+  operator-> ();
+
+  const xercesc::DOMElement&amp;
+  operator* () const;
+
+  xercesc::DOMElement&amp;
+  operator* ();
+
+  typedef void (element_optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const xercesc::DOMElement&amp;
+  get () const;
+
+  xercesc::DOMElement&amp;
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  set (xercesc::DOMElement*);
+
+  void
+  reset ();
+};
+
+bool
+operator== (const element_optional&amp;, const element_optional&amp;);
+
+bool
+operator!= (const element_optional&amp;, const element_optional&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  DOMDocument&amp; doc (o.dom_document ());
+
+  if (o.any ().present ())                  // test
+  {
+    DOMElement&amp; 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&amp; e1 (*o.any ());             // get
+    o.any (e);                              // set, deep copy
+    o.any (doc.createElement (...));        // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+}
+  </pre>
+
+
+
+  <h3><a name="2.12.3">2.12.3 Mapping for <code>any</code> with the Sequence Cardinality Class</a></h3>
+
+  <p>For <code>any</code> with the Sequence cardinality class, the type
+     definitions consist of an alias of the container type with name
+     <code>any_sequence</code> (or <code>any1_sequence</code>, etc., for
+     subsequent wildcards in the type definition), an alias of the iterator
+     type with name <code>any_iterator</code> (or <code>any1_iterator</code>,
+     etc., for subsequent wildcards in the type definition), and an alias
+     of the constant iterator type with name <code>any_const_iterator</code>
+     (or <code>any1_const_iterator</code>, etc., for subsequent wildcards
+     in the type definition).
+  </p>
+
+  <p>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.
+  </p>
+
+  <p>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:
+  </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;any namespace="##other" minOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+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&amp;
+  any () const;
+
+  any_sequence&amp;
+  any ();
+
+  // Modifier.
+  //
+  void
+  any (const any_sequence&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>element_sequence</code> container is a
+     specialization of the <code>sequence</code> class template described
+     in <a href="#2.8.3">Section 2.8.3, "Mapping for Members with the
+     Sequence Cardinality Class"</a>. 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:
+  </p>
+
+  <pre class="c++">
+class element_sequence
+{
+public:
+  typedef xercesc::DOMElement        value_type;
+  typedef xercesc::DOMElement*       pointer;
+  typedef const xercesc::DOMElement* const_pointer;
+  typedef xercesc::DOMElement&amp;       reference;
+  typedef const xercesc::DOMElement&amp; const_reference;
+
+  typedef &lt;implementation-defined>   iterator;
+  typedef &lt;implementation-defined>   const_iterator;
+  typedef &lt;implementation-defined>   reverse_iterator;
+  typedef &lt;implementation-defined>   const_reverse_iterator;
+
+  typedef &lt;implementation-defined>   size_type;
+  typedef &lt;implementation-defined>   difference_type;
+  typedef &lt;implementation-defined>   allocator_type;
+
+public:
+  explicit
+  element_sequence (xercesc::DOMDocument&amp;);
+
+  // DOMElement cannot be default-constructed.
+  //
+  // explicit
+  // element_sequence (size_type n);
+
+  element_sequence (size_type n,
+                    const xercesc::DOMElement&amp;,
+                    xercesc::DOMDocument&amp;);
+
+  template &lt;typename I>
+  element_sequence (const I&amp; begin,
+                    const I&amp; end,
+                    xercesc::DOMDocument&amp;);
+
+  element_sequence (const element_sequence&amp;, xercesc::DOMDocument&amp;);
+
+  element_sequence&amp;
+  operator= (const element_sequence&amp;);
+
+public:
+  void
+  assign (size_type n, const xercesc::DOMElement&amp;);
+
+  template &lt;typename I>
+  void
+  assign (const I&amp; begin, const I&amp; 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&amp;);
+
+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&amp;
+  operator[] (size_type);
+
+  const xercesc::DOMElement&amp;
+  operator[] (size_type) const;
+
+  xercesc::DOMElement&amp;
+  at (size_type);
+
+  const xercesc::DOMElement&amp;
+  at (size_type) const;
+
+  xercesc::DOMElement&amp;
+  front ();
+
+  const xercesc::DOMElement&amp;
+  front () const;
+
+  xercesc::DOMElement&amp;
+  back ();
+
+  const xercesc::DOMElement&amp;
+  back () const;
+
+public:
+  // Makes a deep copy.
+  //
+  void
+  push_back (const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  void
+  push_back (xercesc::DOMElement*);
+
+  void
+  pop_back ();
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMElement&amp;);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMElement*);
+
+  void
+  insert (iterator position, size_type n, const xercesc::DOMElement&amp;);
+
+  template &lt;typename I>
+  void
+  insert (iterator position, const I&amp; begin, const I&amp; 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&amp; x);
+};
+
+inline bool
+operator== (const element_sequence&amp;, const element_sequence&amp;);
+
+inline bool
+operator!= (const element_sequence&amp;, const element_sequence&amp;);
+  </pre>
+
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMElement&amp; e)
+{
+  using namespace xercesc;
+
+  object::any_sequence&amp; s (o.any ());
+
+  // Iteration.
+  //
+  for (object::any_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMElement&amp; e (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back (e);                       // deep copy
+  DOMDocument&amp; doc (o.dom_document ());
+  s.push_back (doc.createElement (...)); // assumes ownership
+}
+  </pre>
+
+  <h3><a name="2.12.4">2.12.4 Element Wildcard Order</a></h3>
+
+  <p>Similar to elements, element wildcards in ordered types
+     (<a href="#2.8.4">Section 2.8.4, "Element Order"</a>) 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="batch">
+  &lt;choice minOccurs="0" maxOccurs="unbounded">
+    &lt;element name="withdraw" type="withdraw"/>
+    &lt;element name="deposit" type="deposit"/>
+    &lt;any namespace="##other" processContents="lax"/>
+  &lt;/choice>
+&lt;/complexType>
+  </pre>
+
+  <p>This will lead to the following changes in the generated
+     <code>batch</code> C++ class:</p>
+
+  <pre class="c++">
+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&amp;
+  any () const;
+
+  any_sequence&amp;
+  any ();
+
+  void
+  any (const any_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>With this change we also need to update the iteration code to handle
+     the new content id:</p>
+
+  <pre class="c++">
+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&amp; e (b.any ()[i->index]);
+      ...
+      break;
+    }
+
+    ...
+  }
+}
+  </pre>
+
+  <p>For the complete working code that shows the use of wildcards in
+     ordered types refer to the <code>order/element</code> example in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <h3><a name="2.12.5">2.12.5 Mapping for <code>anyAttribute</code></a></h3>
+
+  <p>For <code>anyAttribute</code> the type definitions consist of an alias
+     of the container type with name <code>any_attribute_set</code>
+     (or <code>any1_attribute_set</code>, etc., for subsequent wildcards
+     in the type definition), an alias of the iterator type with name
+     <code>any_attribute_iterator</code> (or <code>any1_attribute_iterator</code>,
+     etc., for subsequent wildcards in the type definition), and an alias
+     of the constant iterator type with name <code>any_attribute_const_iterator</code>
+     (or <code>any1_attribute_const_iterator</code>, etc., for subsequent
+     wildcards in the type definition).
+  </p>
+
+  <p>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.
+  </p>
+
+  <p>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:
+  </p>
+
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    ...
+  &lt;/sequence>
+  &lt;anyAttribute namespace="##other"/>
+&lt;/complexType>
+  </pre>
+
+  <p>is mapped to:</p>
+
+  <pre class="c++">
+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&amp;
+  any_attribute () const;
+
+  any_attribute_set&amp;
+  any_attribute ();
+
+  // Modifier.
+  //
+  void
+  any_attribute (const any_attribute_set&amp;);
+
+  ...
+
+};
+  </pre>
+
+  <p>The <code>attribute_set</code> class is an associative container
+     similar to the <code>std::set</code> 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 <code>std::set</code>, <code>attribute_set</code>
+     allows searching using names and namespaces instead of
+     <code>xercesc::DOMAttr</code> objects. It is defined in an
+     implementation-specific namespace and its interface is presented
+     below:
+  </p>
+
+  <pre class="c++">
+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&amp;        reference;
+  typedef const xercesc::DOMAttr&amp;  const_reference;
+
+  typedef &lt;implementation-defined> iterator;
+  typedef &lt;implementation-defined> const_iterator;
+  typedef &lt;implementation-defined> reverse_iterator;
+  typedef &lt;implementation-defined> const_reverse_iterator;
+
+  typedef &lt;implementation-defined> size_type;
+  typedef &lt;implementation-defined> difference_type;
+  typedef &lt;implementation-defined> allocator_type;
+
+public:
+  attribute_set (xercesc::DOMDocument&amp;);
+
+  template &lt;typename I>
+  attribute_set (const I&amp; begin, const I&amp; end, xercesc::DOMDocument&amp;);
+
+  attribute_set (const attribute_set&amp;, xercesc::DOMDocument&amp;);
+
+  attribute_set&amp;
+  operator= (const attribute_set&amp;);
+
+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&lt;iterator, bool>
+  insert (const xercesc::DOMAttr&amp;);
+
+  // Assumes ownership.
+  //
+  std::pair&lt;iterator, bool>
+  insert (xercesc::DOMAttr*);
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMAttr&amp;);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMAttr*);
+
+  template &lt;typename I>
+  void
+  insert (const I&amp; begin, const I&amp; end);
+
+public:
+  void
+  erase (iterator position);
+
+  size_type
+  erase (const std::basic_string&lt;C>&amp; name);
+
+  size_type
+  erase (const std::basic_string&lt;C>&amp; namespace_,
+         const std::basic_string&lt;C>&amp; 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&lt;C>&amp; name) const;
+
+  size_type
+  count (const std::basic_string&lt;C>&amp; namespace_,
+         const std::basic_string&lt;C>&amp; 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&lt;C>&amp; name);
+
+  iterator
+  find (const std::basic_string&lt;C>&amp; namespace_,
+        const std::basic_string&lt;C>&amp; name);
+
+  iterator
+  find (const XMLCh* name);
+
+  iterator
+  find (const XMLCh* namespace_, const XMLCh* name);
+
+  const_iterator
+  find (const std::basic_string&lt;C>&amp; name) const;
+
+  const_iterator
+  find (const std::basic_string&lt;C>&amp; namespace_,
+        const std::basic_string&lt;C>&amp; 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&amp;);
+};
+
+bool
+operator== (const attribute_set&amp;, const attribute_set&amp;);
+
+bool
+operator!= (const attribute_set&amp;, const attribute_set&amp;);
+  </pre>
+
+  <p>The following code shows how one could use this mapping:</p>
+
+  <pre class="c++">
+void
+f (object&amp; o, const xercesc::DOMAttr&amp; a)
+{
+  using namespace xercesc;
+
+  object::any_attribute_set&amp; s (o.any_attribute ());
+
+  // Iteration.
+  //
+  for (object::any_attribute_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMAttr&amp; a (*i);
+  }
+
+  // Modification.
+  //
+  s.insert (a);                         // deep copy
+  DOMDocument&amp; 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");
+}
+  </pre>
+
+  <!-- Mapping for Mixed Content Models -->
+
+  <h2><a name="2.13">2.13 Mapping for Mixed Content Models</a></h2>
+
+  <p>For XML Schema types with mixed content models C++/Tree provides
+     mapping support only if the type is marked as ordered
+     (<a href="#2.8.4">Section 2.8.4, "Element Order"</a>). Use the
+     <code>--ordered-type-mixed</code> XSD compiler option to
+     automatically mark all types with mixed content as ordered.</p>
+
+  <p>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.</p>
+
+  <p>As an example, consider the following schema that describes text
+     with embedded links:</p>
+
+  <pre class="xml">
+&lt;complexType name="anchor">
+  &lt;simpleContent>
+    &lt;extension base="string">
+      &lt;attribute name="href" type="anyURI" use="required"/>
+    &lt;/extension>
+  &lt;/simpleContent>
+&lt;/complexType>
+
+&lt;complexType name="text" mixed="true">
+  &lt;sequence>
+    &lt;element name="a" type="anchor" minOccurs="0" maxOccurs="unbounded"/>
+  &lt;/sequence>
+&lt;/complexType>
+  </pre>
+
+  <p>The generated <code>text</code> C++ class will provide the following
+     API (assuming it is marked as ordered):</p>
+
+  <pre class="c++">
+class text: public xml_schema::type
+{
+public:
+  // a
+  //
+  typedef anchor a_type;
+  typedef sequence&lt;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&amp;
+  a () const;
+
+  a_sequence&amp;
+  a ();
+
+  void
+  a (const a_sequence&amp;);
+
+  // text_content
+  //
+  typedef xml_schema::string text_content_type;
+  typedef sequence&lt;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&amp;
+  text_content () const;
+
+  text_content_sequence&amp;
+  text_content ();
+
+  void
+  text_content (const text_content_sequence&amp;);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector&lt;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&amp;
+  content_order () const;
+
+  content_order_sequence&amp;
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&amp;);
+
+  ...
+};
+  </pre>
+
+  <p>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.</p>
+
+  <pre class="c++">
+const text&amp; 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&amp; a (t.a ()[i->index]);
+      cerr &lt;&lt; a &lt;&lt; "[" &lt;&lt; a.href () &lt;&lt; "]";
+      break;
+    }
+  case text::text_content_id:
+    {
+      const xml_schema::string&amp; s (t.text_content ()[i->index]);
+      cerr &lt;&lt; s;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+  </pre>
+
+  <p>For the complete working code that shows the use of mixed content
+     in ordered types refer to the <code>order/mixed</code> example in
+     the <code>cxx/tree/</code> directory in the
+     <a href="https://cppget.org/xsd-examples">xsd-examples</a>
+     package.</p>
+
+  <!-- Parsing -->
+
+
+  <h1><a name="3">3 Parsing</a></h1>
+
+  <p>This chapter covers various aspects of parsing XML instance
+     documents in order to obtain corresponding tree-like object
+     model.
+  </p>
+
+  <p>Each global XML Schema element in the form:</p>
+
+  <pre class="xml">
+&lt;element name="name" type="type"/>
+  </pre>
+
+  <p>is mapped to 14 overloaded C++ functions in the form:</p>
+
+  <pre class="c++">
+// Read from a URI or a local file.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (const std::basic_string&lt;C>&amp; uri,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from std::istream.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (std::istream&amp;,
+      const std::basic_string&lt;C>&amp; id,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from InputSource.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xml_schema::error_handler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xercesc::InputSource&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+
+// Read from DOM.
+//
+
+std::[unique|auto]_ptr&lt;type>
+name (const xercesc::DOMDocument&amp;,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+
+std::[unique|auto]_ptr&lt;type>
+name (xml_schema::dom::[unique|auto]_ptr&lt;xercesc::DOMDocument>,
+      xml_schema::flags = 0,
+      const xml_schema::properties&amp; = xml_schema::properties ());
+  </pre>
+
+  <p>You can choose between reading an XML instance from a local file,
+     URI, <code>std::istream</code>, <code>xercesc::InputSource</code>,
+     or a pre-parsed DOM instance in the form of
+     <code>xercesc::DOMDocument</code>. All the parsing functions
+     return a dynamically allocated object model as either
+     <code>std::unique_ptr</code> or <code>std::auto_ptr</code>,
+     depending on the C++ standard selected. Each of these parsing
+     functions is discussed in more detail in the following sections.
+  </p>
+
+  <h2><a name="3.1">3.1 Initializing the Xerces-C++ Runtime</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>You can instruct parsing functions that initialize and terminate
+     the runtime not to do so by passing the
+     <code>xml_schema::flags::dont_initialize</code> flag (see
+     <a href="#3.2">Section 3.2, "Flags and Properties"</a>).
+  </p>
+
+
+  <h2><a name="3.2">3.2 Flags and Properties</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <p>The following flags are recognized by the parsing functions:</p>
+
+  <dl>
+    <dt><code>xml_schema::flags::keep_dom</code></dt>
+    <dd>Keep association between DOM nodes and the resulting
+        object model nodes. For more information about DOM association
+        refer to <a href="#5.1">Section 5.1, "DOM Association"</a>.</dd>
+
+    <dt><code>xml_schema::flags::own_dom</code></dt>
+    <dd>Assume ownership of the DOM document passed. This flag only
+        makes sense together with the <code>keep_dom</code> flag in
+        the call to the parsing function with the
+        <code>xml_schema::dom::[unique|auto]_ptr&lt;DOMDocument></code>
+        argument.</dd>
+
+    <dt><code>xml_schema::flags::dont_validate</code></dt>
+    <dd>Do not validate instance documents against schemas.</dd>
+
+    <dt><code>xml_schema::flags::dont_initialize</code></dt>
+    <dd>Do not initialize the Xerces-C++ runtime.</dd>
+  </dl>
+
+  <p>You can pass several flags by combining them using the bit-wise OR
+     operator. For example:</p>
+
+  <pre class="c++">
+using xml_schema::flags;
+
+std::unique_ptr&lt;type> r (
+  name ("test.xml", flags::keep_dom | flags::dont_validate));
+  </pre>
+
+  <p>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
+     <code>xml_schema</code> namespace is thrown (see
+     <a href="#3.3">Section 3.3, "Error Handling"</a>).
+  </p>
+
+  <p>For more information on the Xerces-C++ runtime initialization
+     refer to <a href="#3.1">Section 3.1, "Initializing the Xerces-C++
+     Runtime"</a>.
+  </p>
+
+  <p>The <code>xml_schema::properties</code> class allows you to
+     programmatically specify schema locations to be used instead
+     of those specified with the <code>xsi::schemaLocation</code>
+     and <code>xsi::noNamespaceSchemaLocation</code> attributes
+     in instance documents. The interface of the <code>properties</code>
+     class is presented below:
+  </p>
+
+  <pre class="c++">
+class properties
+{
+public:
+  void
+  schema_location (const std::basic_string&lt;C>&amp; namespace_,
+                   const std::basic_string&lt;C>&amp; location);
+  void
+  no_namespace_schema_location (const std::basic_string&lt;C>&amp; location);
+};
+  </pre>
+
+  <p>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
+     <code>file:///absolute/path/to/your/schema</code> as the location
+     argument.
+  </p>
+
+  <h2><a name="3.3">3.3 Error Handling</a></h2>
+
+  <p>As discussed in <a href="#2.2">Section 2.2, "Error Handling"</a>,
+     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.</p>
+
+  <p>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.</p>
+
+  <p>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
+     <code>xml_schema::parsing</code> 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 <code>xml_schema::error_handler</code>
+     and <code>xercesc::DOMErrorHandler</code>. For more information
+     on the <code>xercesc::DOMErrorHandler</code> interface refer to
+     the Xerces-C++ documentation. The <code>xml_schema::error_handler</code>
+     interface is presented below:
+  </p>
+
+  <pre class="c++">
+class error_handler
+{
+public:
+  struct severity
+  {
+    enum value
+    {
+      warning,
+      error,
+      fatal
+    };
+  };
+
+  virtual bool
+  handle (const std::basic_string&lt;C>&amp; id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string&lt;C>&amp; message) = 0;
+
+  virtual
+  ~error_handler ();
+};
+  </pre>
+
+  <p>The <code>id</code> argument of the <code>error_handler::handle</code>
+     function identifies the resource being parsed (e.g., a file name or
+     URI).
+  </p>
+
+  <p>By returning <code>true</code> from the <code>handle</code> function
+     you instruct the parser to recover and continue parsing. Returning
+     <code>false</code> results in termination of the parsing process.
+     An error with the <code>fatal</code> severity level results in
+     termination of the parsing process no matter what is returned from
+     the <code>handle</code> function. It is safe to throw an exception
+     from the <code>handle</code> function.
+  </p>
+
+  <p>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.
+  </p>
+
+
+  <h3><a name="3.3.1">3.3.1 <code>xml_schema::parsing</code></a></h3>
+
+  <pre class="c++">
+struct severity
+{
+  enum value
+  {
+    warning,
+    error
+  };
+
+  severity (value);
+  operator value () const;
+};
+
+struct error
+{
+  error (severity,
+         const std::basic_string&lt;C>&amp; id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string&lt;C>&amp; message);
+
+  severity
+  severity () const;
+
+  const std::basic_string&lt;C>&amp;
+  id () const;
+
+  unsigned long
+  line () const;
+
+  unsigned long
+  column () const;
+
+  const std::basic_string&lt;C>&amp;
+  message () const;
+};
+
+std::basic_ostream&lt;C>&amp;
+operator&lt;&lt; (std::basic_ostream&lt;C>&amp;, const error&amp;);
+
+struct diagnostics: std::vector&lt;error>
+{
+};
+
+std::basic_ostream&lt;C>&amp;
+operator&lt;&lt; (std::basic_ostream&lt;C>&amp;, const diagnostics&amp;);
+
+struct parsing: virtual exception
+{
+  parsing ();
+  parsing (const diagnostics&amp;);
+
+  const diagnostics&amp;
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::parsing</code> 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 <code>diagnostics</code> function. The usual conditions when
+     this exception is thrown include malformed XML instances and, if
+     validation is turned on, invalid instance documents.
+  </p>
+
+  <h3><a name="3.3.2">3.3.2 <code>xml_schema::expected_element</code></a></h3>
+
+  <pre class="c++">
+struct expected_element: virtual exception
+{
+  expected_element (const std::basic_string&lt;C>&amp; name,
+                    const std::basic_string&lt;C>&amp; namespace_);
+
+
+  const std::basic_string&lt;C>&amp;
+  name () const;
+
+  const std::basic_string&lt;C>&amp;
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_element</code> 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 <code>name</code> and <code>namespace_</code> functions respectively.
+  </p>
+
+
+  <h3><a name="3.3.3">3.3.3 <code>xml_schema::unexpected_element</code></a></h3>
+
+  <pre class="c++">
+struct unexpected_element: virtual exception
+{
+  unexpected_element (const std::basic_string&lt;C>&amp; encountered_name,
+                      const std::basic_string&lt;C>&amp; encountered_namespace,
+                      const std::basic_string&lt;C>&amp; expected_name,
+                      const std::basic_string&lt;C>&amp; expected_namespace)
+
+
+  const std::basic_string&lt;C>&amp;
+  encountered_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  encountered_namespace () const;
+
+
+  const std::basic_string&lt;C>&amp;
+  expected_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  expected_namespace () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::unexpected_element</code> 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 <code>encountered_name</code> and
+     <code>encountered_namespace</code> functions respectively. If an
+     element was expected instead of the encountered one, its name
+     and namespace can be obtained using the <code>expected_name</code> and
+     <code>expected_namespace</code> functions respectively. Otherwise
+     these functions return empty strings.
+  </p>
+
+  <h3><a name="3.3.4">3.3.4 <code>xml_schema::expected_attribute</code></a></h3>
+
+  <pre class="c++">
+struct expected_attribute: virtual exception
+{
+  expected_attribute (const std::basic_string&lt;C>&amp; name,
+                      const std::basic_string&lt;C>&amp; namespace_);
+
+
+  const std::basic_string&lt;C>&amp;
+  name () const;
+
+  const std::basic_string&lt;C>&amp;
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_attribute</code> 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 <code>name</code> and <code>namespace_</code> functions respectively.
+  </p>
+
+
+  <h3><a name="3.3.5">3.3.5 <code>xml_schema::unexpected_enumerator</code></a></h3>
+
+  <pre class="c++">
+struct unexpected_enumerator: virtual exception
+{
+  unexpected_enumerator (const std::basic_string&lt;C>&amp; enumerator);
+
+  const std::basic_string&lt;C>&amp;
+  enumerator () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::unexpected_enumerator</code> exception is thrown
+     when an unexpected enumerator is encountered by the DOM-Tree stage.
+     The enumerator can be obtained using the <code>enumerator</code>
+     functions.
+  </p>
+
+  <h3><a name="3.3.6">3.3.6 <code>xml_schema::expected_text_content</code></a></h3>
+
+  <pre class="c++">
+struct expected_text_content: virtual exception
+{
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::expected_text_content</code> exception is thrown
+     when a content other than text is encountered and the text content was
+     expected by the DOM-Tree stage.
+  </p>
+
+  <h3><a name="3.3.7">3.3.7 <code>xml_schema::no_type_info</code></a></h3>
+
+  <pre class="c++">
+struct no_type_info: virtual exception
+{
+  no_type_info (const std::basic_string&lt;C>&amp; type_name,
+                const std::basic_string&lt;C>&amp; type_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::no_type_info</code> exception is thrown
+     when there is no type information associated with a type specified
+     by the <code>xsi:type</code> attribute. This exception is thrown
+     by the DOM-Tree stage. The name and namespace of the type in question
+     can be obtained using the <code>type_name</code> and
+     <code>type_namespace</code> 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
+     <code>--generate-polymorphic</code> option.
+  </p>
+
+
+  <h3><a name="3.3.8">3.3.8 <code>xml_schema::not_derived</code></a></h3>
+
+  <pre class="c++">
+struct not_derived: virtual exception
+{
+  not_derived (const std::basic_string&lt;C>&amp; base_type_name,
+               const std::basic_string&lt;C>&amp; base_type_namespace,
+               const std::basic_string&lt;C>&amp; derived_type_name,
+               const std::basic_string&lt;C>&amp; derived_type_namespace);
+
+  const std::basic_string&lt;C>&amp;
+  base_type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  base_type_namespace () const;
+
+
+  const std::basic_string&lt;C>&amp;
+  derived_type_name () const;
+
+  const std::basic_string&lt;C>&amp;
+  derived_type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::not_derived</code> exception is thrown
+     when a type specified by the <code>xsi:type</code> 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 <code>base_type_name</code> and
+     <code>base_type_namespace</code> functions respectively. The name
+     and namespace of the offending type can be obtained using the
+     <code>derived_type_name</code> and
+     <code>derived_type_namespace</code> functions respectively.
+  </p>
+
+  <h3><a name="3.3.9">3.3.9 <code>xml_schema::no_prefix_mapping</code></a></h3>
+
+  <pre class="c++">
+struct no_prefix_mapping: virtual exception
+{
+  no_prefix_mapping (const std::basic_string&lt;C>&amp; prefix);
+
+  const std::basic_string&lt;C>&amp;
+  prefix () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::no_prefix_mapping</code> 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 <code>prefix</code>
+     function.
+  </p>
+
+  <h2><a name="3.4">3.4 Reading from a Local File or URI</a></h2>
+
+  <p>Using a local file or URI is the simplest way to parse an XML instance.
+     For example:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+unique_ptr&lt;type> r1 (name ("test.xml"));
+unique_ptr&lt;type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+  </pre>
+
+  <p>Or, in the C++98 mode:</p>
+
+  <pre class="c++">
+using std::auto_ptr;
+
+auto_ptr&lt;type> r1 (name ("test.xml"));
+auto_ptr&lt;type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+  </pre>
+
+  <h2><a name="3.5">3.5 Reading from <code>std::istream</code></a></h2>
+
+  <p>When using an <code>std::istream</code> 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:</p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+{
+  std::ifstream ifs ("test.xml");
+  unique_ptr&lt;type> r (name (ifs, "test.xml"));
+}
+
+{
+  std::string str ("..."); // Some XML fragment.
+  std::istringstream iss (str);
+  unique_ptr&lt;type> r (name (iss));
+}
+  </pre>
+
+  <h2><a name="3.6">3.6 Reading from <code>xercesc::InputSource</code></a></h2>
+
+  <p>Reading from a <code>xercesc::InputSource</code> instance
+     is similar to the <code>std::istream</code> case except
+     the resource id is maintained by the <code>InputSource</code>
+     object. For instance:</p>
+
+  <pre class="c++">
+xercesc::StdInInputSource is;
+std::unique_ptr&lt;type> r (name (is));
+  </pre>
+
+  <h2><a name="3.7">3.7 Reading from DOM</a></h2>
+
+  <p>Reading from a <code>xercesc::DOMDocument</code> 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
+     <a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree Mapping
+     FAQ</a> shows how to parse an XML instance to a Xerces-C++
+     DOM document using the XSD runtime utilities.
+  </p>
+
+  <p>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 <code>DOMDocument</code>
+     pointer is reset and the resulting object model assumes ownership
+     of the DOM document passed. For example:</p>
+
+  <pre class="c++">
+// C++11 version.
+//
+xml_schema::dom::unique_ptr&lt;xercesc::DOMDocument> doc = ...
+
+std::unique_ptr&lt;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&lt;xercesc::DOMDocument> doc = ...
+
+std::auto_ptr&lt;type> r (
+  name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+  </pre>
+
+  <h1><a name="4">4 Serialization</a></h1>
+
+  <p>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 <a href="#3">Chapter 3,
+     "Parsing"</a>. Note that the generation of the serialization code
+     is optional and should be explicitly requested with the
+     <code>--generate-serialization</code> option. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.
+  </p>
+
+  <p>Each global XML Schema element in the form:
+  </p>
+
+
+  <pre class="xml">
+&lt;xsd:element name="name" type="type"/>
+  </pre>
+
+  <p>is mapped to 8 overloaded C++ functions in the form:</p>
+
+  <pre class="c++">
+// Serialize to std::ostream.
+//
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      const xml_schema::namespace_fomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      xml_schema::error_handler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&amp;,
+      const type&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to XMLFormatTarget.
+//
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      xml_schema::error_handler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&amp;,
+      const type&amp;,
+      xercesc::DOMErrorHandler&amp;,
+      const xml_schema::namespace_infomap&amp; =
+        xml_schema::namespace_infomap (),
+      const std::basic_string&lt;C>&amp; encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::[unique|auto]_ptr&lt;xercesc::DOMDocument>
+name (const type&amp;,
+      const xml_schema::namespace_infomap&amp;
+        xml_schema::namespace_infomap (),
+      xml_schema::flags = 0);
+
+void
+name (xercesc::DOMDocument&amp;,
+      const type&amp;,
+      xml_schema::flags = 0);
+  </pre>
+
+  <p>You can choose between writing XML to <code>std::ostream</code> or
+     <code>xercesc::XMLFormatTarget</code> and creating a DOM instance
+     in the form of <code>xercesc::DOMDocument</code>. Serialization
+     to <code>ostream</code> or <code>XMLFormatTarget</code> 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.
+  </p>
+
+
+  <h2><a name="4.1">4.1 Initializing the Xerces-C++ Runtime</a></h2>
+
+  <p>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.
+  </p>
+
+  <p>You can instruct serialization functions that initialize and terminate
+     the runtime not to do so by passing the
+     <code>xml_schema::flags::dont_initialize</code> flag (see
+     <a href="#4.3">Section 4.3, "Flags"</a>).
+  </p>
+
+  <h2><a name="4.2">4.2 Namespace Infomap and Character Encoding</a></h2>
+
+  <p>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
+     (<code>p1</code>, <code>p2</code>, etc) are automatically assigned
+     to namespaces as needed. Also, if
+     you would like the resulting instance document to contain the
+     <code>schemaLocation</code> or <code>noNamespaceSchemaLocation</code>
+     attributes, you will need to provide namespace-schema associations.
+     The <code>xml_schema::namespace_infomap</code> class is used
+     to capture this information:</p>
+
+  <pre class="c++">
+struct namespace_info
+{
+  namespace_info ();
+  namespace_info (const std::basic_string&lt;C>&amp; name,
+                  const std::basic_string&lt;C>&amp; schema);
+
+  std::basic_string&lt;C> name;
+  std::basic_string&lt;C> schema;
+};
+
+// Map of namespace prefix to namespace_info.
+//
+struct namespace_infomap: public std::map&lt;std::basic_string&lt;C>,
+                                          namespace_info>
+{
+};
+  </pre>
+
+  <p>Consider the following associations as an example:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+  </pre>
+
+  <p>This map, if passed to one of the serialization functions,
+     could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>As you can see, the serialization function automatically added namespace
+     mapping for the <code>xsi</code> prefix. You can change this by
+     providing your own prefix:</p>
+
+  <pre class="c++">
+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";
+  </pre>
+
+  <p>This could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+  <p>To specify the location of a schema without a namespace you can use
+     an empty prefix as in the example below: </p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].schema = "test.xsd";
+  </pre>
+
+  <p>This would result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">
+  </pre>
+
+  <p>To make a particular namespace default you can use an empty
+     prefix, for example:</p>
+
+  <pre class="c++">
+xml_schema::namespace_infomap map;
+
+map[""].name = "https://www.codesynthesis.com/test";
+map[""].schema = "test.xsd";
+  </pre>
+
+  <p>This could result in the following XML fragment:</p>
+
+  <pre class="xml">
+&lt;?xml version="1.0" ?>
+&lt;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">
+  </pre>
+
+
+  <p>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 <code>"US-ASCII"</code>,
+     <code>"ISO8859-1"</code>, <code>"UTF-8"</code>,
+     <code>"UTF-16BE"</code>, <code>"UTF-16LE"</code>,
+     <code>"UCS-4BE"</code>, and <code>"UCS-4LE"</code>. The default
+     encoding is <code>"UTF-8"</code>. For more information on
+     encoding methods see the
+     "<a href="http://en.wikipedia.org/wiki/Character_code">Character
+     Encoding</a>" article from Wikipedia.
+  </p>
+
+  <h2><a name="4.3">4.3 Flags</a></h2>
+
+  <p>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.
+  </p>
+
+
+  <p>The following flags are recognized by the serialization
+     functions:</p>
+
+  <dl>
+    <dt><code>xml_schema::flags::dont_initialize</code></dt>
+    <dd>Do not initialize the Xerces-C++ runtime.</dd>
+
+    <dt><code>xml_schema::flags::dont_pretty_print</code></dt>
+    <dd>Do not add extra spaces or new lines that make the resulting XML
+        slightly bigger but easier to read.</dd>
+
+    <dt><code>xml_schema::flags::no_xml_declaration</code></dt>
+    <dd>Do not write XML declaration (&lt;?xml ... ?>).</dd>
+  </dl>
+
+  <p>You can pass several flags by combining them using the bit-wise OR
+     operator. For example:</p>
+
+  <pre class="c++">
+std::unique_ptr&lt;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);
+  </pre>
+
+  <p>For more information on the Xerces-C++ runtime initialization
+     refer to <a href="#4.1">Section 4.1, "Initializing the Xerces-C++
+     Runtime"</a>.
+  </p>
+
+  <h2><a name="4.4">4.4 Error Handling</a></h2>
+
+  <p>As with the parsing functions (see <a href="#3.3">Section 3.3,
+     "Error Handling"</a>), 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.
+  </p>
+
+  <p>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
+     <code>xml_schema::serialization</code> 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 <code>xml_schema::error_handler</code> and
+     <code>xercesc::DOMErrorHandler</code>. The
+     <code>xml_schema::error_handler</code> interface is described in
+     <a href="#3.3">Section 3.3, "Error Handling"</a>. For more information
+     on the <code>xercesc::DOMErrorHandler</code> interface refer to the
+     Xerces-C++ documentation.
+  </p>
+
+  <p>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.
+  </p>
+
+  <h3><a name="4.4.1">4.4.1 <code>xml_schema::serialization</code></a></h3>
+
+  <pre class="c++">
+struct serialization: virtual exception
+{
+  serialization ();
+  serialization (const diagnostics&amp;);
+
+  const diagnostics&amp;
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  </pre>
+
+  <p>The <code>xml_schema::diagnostics</code> class is described in
+     <a href="#3.3.1">Section 3.3.1, "<code>xml_schema::parsing</code>"</a>.
+     The <code>xml_schema::serialization</code> 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 <code>diagnostics</code> function.
+  </p>
+
+
+  <h3><a name="4.4.2">4.4.2 <code>xml_schema::unexpected_element</code></a></h3>
+
+  <p>The <code>xml_schema::unexpected_element</code> exception is
+     described in <a href="#3.3.3">Section 3.3.3,
+     "<code>xml_schema::unexpected_element</code>"</a>. 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.
+  </p>
+
+  <h3><a name="4.4.3">4.4.3 <code>xml_schema::no_type_info</code></a></h3>
+
+  <p>The <code>xml_schema::no_type_info</code> exception is
+     described in <a href="#3.3.7">Section 3.3.7,
+     "<code>xml_schema::no_type_info</code>"</a>. 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 <code>--generate-polymorphic</code> option.
+  </p>
+
+  <h2><a name="4.5">4.5 Serializing to <code>std::ostream</code></a></h2>
+
+  <p>In order to serialize to <code>std::ostream</code> you will need
+     an object model, an output stream and, optionally, a namespace
+     infomap. For instance:</p>
+
+  <pre class="c++">
+// Obtain the object model.
+//
+std::unique_ptr&lt;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);
+  </pre>
+
+  <p>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 <code>char</code>, for instance UTF-16 or UCS-4. For
+     example, things will most likely break if you try to serialize
+     to <code>std::ostringstream</code> with UTF-16 or UCS-4 as an
+     encoding. This is due to the special value,
+     <code>'\0'</code>, that will most likely occur as part of such
+     serialization and it won't have the special meaning assumed by
+     <code>std::ostringstream</code>.
+  </p>
+
+
+  <h2><a name="4.6">4.6 Serializing to <code>xercesc::XMLFormatTarget</code></a></h2>
+
+  <p>Serializing to an <code>xercesc::XMLFormatTarget</code> instance
+     is similar the <code>std::ostream</code> case. For instance:
+  </p>
+
+  <pre class="c++">
+using std::unique_ptr;
+
+// Obtain the object model.
+//
+unique_ptr&lt;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&lt;XMLFormatTarget> ft;
+
+  if (argc != 2)
+  {
+    ft = unique_ptr&lt;XMLFormatTarget> (new StdOutFormatTarget ());
+  }
+  else
+  {
+    ft = unique_ptr&lt;XMLFormatTarget> (
+      new LocalFileFormatTarget (argv[1]));
+  }
+
+  // Write it out.
+  //
+  name (*ft, *r, map);
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>Note that we had to initialize the Xerces-C++ runtime before we
+     could call this serialization function.</p>
+
+  <h2><a name="4.7">4.7 Serializing to DOM</a></h2>
+
+  <p>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 <code>std::ostream</code> or <code>xercesc::XMLFormatTarget</code>,
+     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 <code>schemaLocation</code> and/or
+     <code>noNamespaceSchemaLocation</code> attributes. The following
+     listing should give you an idea about what needs to be done:
+  </p>
+
+  <pre class="c++">
+// Obtain the object model.
+//
+std::unique_ptr&lt;type> r = ...
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Create a DOM instance. Set custom namespace mapping and schema
+  // location attributes.
+  //
+  DOMDocument&amp; doc = ...
+
+  // Serialize to DOM.
+  //
+  name (doc, *r);
+
+  // Serialize the DOM document to XML.
+  //
+  ...
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>For more information on how to create and serialize a DOM instance
+     refer to the Xerces-C++ documentation. In addition, the
+     <a href="http://wiki.codesynthesis.com/Tree/FAQ">C++/Tree Mapping
+     FAQ</a> shows how to implement these operations using the XSD
+     runtime utilities.
+  </p>
+
+  <h1><a name="5">5 Additional Functionality</a></h1>
+
+  <p>The C++/Tree mapping provides a number of optional features
+     that can be useful in certain situations. They are described
+     in the following sections.</p>
+
+  <h2><a name="5.1">5.1 DOM Association</a></h2>
+
+  <p>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.</p>
+
+  <p>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.</p>
+
+  <p>To request DOM association you will need to pass the
+     <code>xml_schema::flags::keep_dom</code> flag to one of the
+     parsing functions (see <a href="#3.2">Section 3.2,
+     "Flags and Properties"</a> 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 <code>keep_dom</code> flag and
+     terminate it after the object model is destroyed (see
+     <a href="#3.1">Section 3.1, "Initializing the Xerces-C++ Runtime"</a>).</p>
+
+   <p>If the <code>keep_dom</code> 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:</p>
+
+  <pre class="c++">
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr&lt;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 ();
+  </pre>
+
+
+  <p>To obtain the corresponding DOM node from an object model node
+     you will need to call the <code>_node</code> accessor function
+     which returns a pointer to <code>DOMNode</code>. You can then query
+     this DOM node's type and cast it to either <code>DOMAttr*</code>
+     or <code>DOMElement*</code>. To obtain the corresponding object
+     model node from a DOM node, the DOM user data API is used. The
+     <code>xml_schema::dom::tree_node_key</code> 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="a" type="string"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="object"/>
+  </pre>
+
+  <pre class="c++">
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr&lt;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&lt;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&lt;DOMElement*> (n);
+      break;
+    }
+  }
+
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type&amp; t (
+    *reinterpret_cast&lt;xml_schema::type*> (
+       ae->getUserData (xml_schema::dom::tree_node_key)));
+
+  xml_schema::string&amp; a (dynamic_cast&lt;xml_schema::string&amp;> (t));
+}
+
+XMLPlatformUtils::Terminate ();
+  </pre>
+
+  <p>The 'mixed' example which can be found in the XSD distribution
+     shows how to handle the mixed content using DOM association.</p>
+
+  <h2><a name="5.2">5.2 Binary Serialization</a></h2>
+
+  <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 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.</p>
+
+  <p>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.</p>
+
+  <p>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
+     <code>--generate-insertion</code> and <code>--generate-extraction</code>
+     compiler options. See the
+     <a href="https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml">XSD
+     Compiler Command Line Manual</a> for more information.</p>
+
+  <p>Once the insertion operators and extraction constructors are
+     generated, you can use the <code>xml_schema::istream</code>
+     and <code>xml_schema::ostream</code> 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:</p>
+
+  <pre class="xml">
+&lt;complexType name="object">
+  &lt;sequence>
+    &lt;element name="a" type="string"/>
+    &lt;element name="b" type="int"/>
+  &lt;/sequence>
+&lt;/complexType>
+
+&lt;element name="root" type="object"/>
+  </pre>
+
+  <pre class="c++">
+// Parse XML to object model.
+//
+std::unique_ptr&lt;type> r (root ("root.xml"));
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream&lt;ACE_OutputCDR> ocdr (ace_ocdr);
+
+ocdr &lt;&lt; *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::istream&lt;ACE_InputCDR> icdr (ace_icdr);
+
+std::unique_ptr&lt;object> copy (new object (icdr));
+
+// Serialize to XML.
+//
+root (std::cout, *copy);
+  </pre>
+
+  <p>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.</p>
+
+  <!--  Appendix A -->
+
+
+  <h1><a name="A">Appendix A &mdash; Default and Fixed Values</a></h1>
+
+  <p>The following table summarizes the effect of default and fixed
+     values (specified with the <code>default</code> and <code>fixed</code>
+     attributes, respectively) on attribute and element values. The
+     <code>default</code> and <code>fixed</code> attributes are mutually
+     exclusive. It is also worthwhile to note that the fixed value semantics
+     is a superset of the default value semantics.
+  </p>
+
+  <!-- border="1" is necessary for html2ps -->
+  <table id="default-fixed" border="1">
+    <tr>
+      <th></th>
+      <th></th>
+      <th colspan="2">default</th>
+      <th colspan="2">fixed</th>
+    </tr>
+
+    <!-- element -->
+
+    <tr>
+      <th rowspan="4">element</th>
+      <th rowspan="2">not present</th>
+      <th>optional</th>
+      <th>required</th>
+      <th>optional</th>
+      <th>required</th>
+    </tr>
+    <tr>
+      <td>not present</td>
+      <td>invalid instance</td>
+      <td>not present</td>
+      <td>invalid instance</td>
+    </tr>
+
+
+    <tr>
+      <th>empty</th>
+      <td colspan="2">default value is used</td>
+      <td colspan="2">fixed value is used</td>
+    </tr>
+
+    <tr>
+      <th>value</th>
+      <td colspan="2">value is used</td>
+      <td colspan="2">value is used provided it's the same as fixed</td>
+    </tr>
+
+    <!-- attribute -->
+
+    <!-- element -->
+
+    <tr>
+      <th rowspan="4">attribute</th>
+      <th rowspan="2">not present</th>
+      <th>optional</th>
+      <th>required</th>
+      <th>optional</th>
+      <th>required</th>
+    </tr>
+    <tr>
+      <td>default value is used</td>
+      <td>invalid schema</td>
+      <td>fixed value is used</td>
+      <td>invalid instance</td>
+    </tr>
+
+
+    <tr>
+      <th>empty</th>
+      <td colspan="2">empty value is used</td>
+      <td colspan="2">empty value is used provided it's the same as fixed</td>
+    </tr>
+
+    <tr>
+      <th>value</th>
+      <td colspan="2">value is used</td>
+      <td colspan="2">value is used provided it's the same as fixed</td>
+    </tr>
+
+  </table>
+
+  </div>
+</div>
+
+
+</body>
+</html>
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: "
+<div align=center>
+  <h1><big>C++/Tree Mapping User Manual</big></h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+  <h1>&nbsp;</h1>
+</div>
+  <p>Revision $[revision] &nbsp;&nbsp;&nbsp; $D</p>
+  <p>Copyright &#169; @copyright@.</p>
+
+  <p>Permission is granted to copy, distribute and/or modify this
+     document under the terms of the
+     <a href='https://www.codesynthesis.com/licenses/fdl-1.2.txt'>GNU Free
+     Documentation License, version 1.2</a>; with no Invariant Sections,
+     no Front-Cover Texts and no Back-Cover Texts.
+  </p>
+
+  <p>This document is available in the following formats:
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml'>XHTML</a>,
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf'>PDF</a>, and
+     <a href='https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps'>PostScript</a>.</p>";
+  }
+
+  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
--- /dev/null
+++ b/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.pdf
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{( )}{<A1A1>}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(<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>)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(<?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>)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 <iostream>
+#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(<?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>)RP(
+
+  )0 P(A sample XML instance to go along with this schema is saved
+     in )SM(people.xml)ES(:)EP(
+
+  ) 15 33 PR(<?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>)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(<?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>)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 <string>
+#include <vector>
+
+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<person> 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 <schema-namespace> [<cxx-namespace>]
+{
+  \201include <file-name>;\202*
+  \201[type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];\202*
+})RP(
+
+  )0 P(Both )SM()I(<schema-names)HY(pace)YH(>)ES()ES( and
+     )SM()I(<schema-type>)ES()ES( are regex patterns while
+     )SM()I(<cxx-names)HY(pace)YH(>)ES()ES(,
+     )SM()I(<cxx-ret-type>)ES()ES(, and
+     )SM()I(<cxx-arg-type>)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(<schema-names)HY(pace)YH(>)ES()ES( deter)HY(mines)YH( XML
+     Schema names)HY(pace)YH(. Optional )SM()I(<cxx-names)HY(pace)YH(>)ES()ES(
+     is prefixed to every C++ type name in this names)HY(pace)YH( decla)HY(ra)HY(tion)YH(.
+     )SM()I(<cxx-ret-type>)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(<cxx-arg-type>)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(<cxx-arg-type>)ES()ES( is not
+     spec)HY(i)HY(fied)YH(, it defaults to )SM()I(<cxx-ret-type>)ES()ES(
+     if )SM()I(<cxx-ret-type>)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(<cxx-ret-type>)ES(&)ES(
+     other)HY(wise)YH(.
+     )SM()I(<file-name>)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<xml_schema::buffer>)ES(
+     or )SM(std::auto_ptr<xml_schema::buffer>)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<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;
+})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 <iostream>
+
+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(<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>
+)WR(
+  <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>)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(<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>)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("<name>\240<names)HY(pace)YH(>")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 <map>
+#include <string>
+
+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<std::string, xml_schema::parser_base*> 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<std::string>
+  {
+  public:
+    string_sequence \201\202;
+
+    explicit
+    string_sequence \201std::vector<std::string>::size_type n,
+                     const std::string& x = std::string \201\202\202;
+
+    template <typename I>
+    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<xml_schema::buffer>)ES( \201C++11\202 or
+     )SM(std::auto_ptr<xml_schema::buffer>)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<error>
+  {
+  };
+)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
--- /dev/null
+++ b/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf
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{( )}{<A1A1>}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<nmtoken>)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<idref>)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<entity>)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(<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>)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(<?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>)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(<?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>)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_type> 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_t>
+hello \201const std::string& uri\202;
+
+std::unique_ptr<hello_t>
+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_t>
+hello \201const std::string& uri\202;
+
+std::auto_ptr<hello_t>
+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 <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main \201int argc, char* argv[]\202
+{
+  try
+  {
+    unique_ptr<hello_t> 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 <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main \201int argc, char* argv[]\202
+{
+  try
+  {
+    unique_ptr<hello_t> 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(<?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>)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 <iostream>
+#include <fstream>
+#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(<?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>)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<NameType> 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_t>
+hello \201const std::string& uri\202;
+
+std::unique_ptr<Hello_t>
+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<NameType> 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>
+hello \201const std::string& uri\202;
+
+std::unique_ptr<Hello>
+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(<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>)WR(
+  </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>)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 <xercesc/util/PlatformUtils.hpp>
+
+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(<?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>)RP(
+
+  )0 P(A sample XML instance to go along with this schema is saved
+     in )SM(people.xml)ES(:)EP(
+
+  ) 20 61 PR(<?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>)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_type> 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_type> 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 <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main \201\202
+{
+  unique_ptr<people_t> 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 <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main \201\202
+{
+  unique_ptr<people_t> 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(<?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>)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 <iostream>
+#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<person_t> 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<person_t> 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(<?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>)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_t>
+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_t>
+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_t>
+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<people_t> p1 \201people \201"people.xml"\202\202;
+unique_ptr<people_t> 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<people_t> 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<people_t> 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<people_t> 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(<?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">)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<people_t> 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 <unistd.h> // getcwd
+#include <limits.h> // 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<people_t> 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<people_t> 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<people_t> 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<people_t> 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(<?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">)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
--- /dev/null
+++ b/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.pdf
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{( )}{<A1A1>}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<nmtoken>)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<idref>)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<entity>)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<C>)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(<element name="object">
+  <complexType>
+    ...
+  </complexType>
+</element>)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<C>&
+  operator<< \201std::basic_ostream<C>& os, const exception& e\202
+  {
+    e.print \201os\202;
+    return os;
+  }
+
+protected:
+  virtual void
+  print \201std::basic_ostream<C>&\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<C>& id\202;
+
+  const std::basic_string<C>&
+  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(<import namespace="https://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>)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 -->
+<schema>
+  <complexType name="type">
+  ...
+  </complexType>
+</schema>
+
+<-- test.xsd -->
+<schema targetNamespace="https://www.codesynthesis.com/test">
+  <include schemaLocation="common.xsd"/>
+</schema>)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(<schema targetNamespace="https://www.codesynthesis.com/system/test">
+  ...
+</schema>)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(<simpleType name="my_int">
+  <restriction base="int"/>
+</simpleType>)RP(
+
+  )0 P(is mapped to:)EP(
+
+  ) 4 42 PR(class my_int: public fundamental_base<int>
+{
+  ...
+};)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 <typename X>
+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 <typename Y>
+  operator Y \201\202 const;
+
+  template <typename Y>
+  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<C>&\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<C>&
+  text_content \201\202 const;
+
+  std::basic_string<C>&
+  text_content \201\202;
+
+  void
+  text_content \201const std::basic_string<C>&\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<C>&\202;
+  idref \201const std::basic_string<C>&,
+         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<C>&\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(<!-- 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>)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<object_type&> \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(<!-- test.xsd -->
+<schema
+  xmlns:xse="https://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      <element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+</schema>)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<C>
+  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<C>
+  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(<simpleType name="object">
+  ...
+</simpleType>)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(<simpleType name="object">
+  <restriction base="base">
+    ...
+  </restriction>
+</simpleType>)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<C>&)ES(.
+   For instance:)EP(
+
+  ) 7 32 PR(<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>)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<C>&\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(<simpleType name="int_list">
+  <list itemType="int"/>
+</simpleType>)RP(
+
+  )0 P(is mapped to:)EP(
+
+  ) 19 42 PR(class int_list: public simple_type,
+                public sequence<int>
+{
+public:
+  int_list \201\202;
+  int_list \201size_type n, int x\202;
+
+  template <typename I>
+  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<C>)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<C>&)ES(. For instance:
+  )EP(
+
+  ) 3 47 PR(<simpleType name="int_string_union">
+  <xsd:union memberTypes="xsd:int xsd:string"/>
+</simpleType>)RP(
+
+  )0 P(is mapped to:)EP(
+
+  ) 16 51 PR(class int_string_union: public simple_type,
+                        public std::basic_string<C>
+{
+public:
+  int_string_union \201const C*\202;
+  int_string_union \201const std::basic_string<C>&\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(<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>)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<complex> 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(<complexType name="object">
+  <simpleContent>
+    <extension base="date">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>)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<C>&)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(<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>)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<C>&\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<C>& 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(<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>)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(<complexType name="object">
+  <attribute name="data" type="string" default="test"/>
+</complexType>)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(<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>)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<member_type>\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<member_type>
+  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<string> 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<string> 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(<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="0"/>
+  </sequence>
+</complexType>)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_type> 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<member_type>\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 <typename X>
+class optional
+{
+public:
+  optional \201\202;
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional \201const X&\202;
+
+  // Assumes ownership.
+  //
+  explicit
+  optional \201std::[unique|auto]_ptr<X>\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<X>\202;
+
+  // Detach and return the contained value.
+  //
+  std::[unique|auto]_ptr<X>
+  detach \201\202;
+
+  void
+  reset \201\202;
+};
+
+template <typename X>
+bool
+operator== \201const optional<X>&, const optional<X>&\202;
+
+template <typename X>
+bool
+operator!= \201const optional<X>&, const optional<X>&\202;
+
+template <typename X>
+bool
+operator< \201const optional<X>&, const optional<X>&\202;
+
+template <typename X>
+bool
+operator> \201const optional<X>&, const optional<X>&\202;
+
+template <typename X>)WR(
+bool
+operator<= \201const optional<X>&, const optional<X>&\202;
+
+template <typename X>
+bool
+operator>= \201const optional<X>&, const optional<X>&\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<string> 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<string> 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(<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="unbounded"/>
+  </sequence>
+</complexType>)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_type> 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 <typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back \201std::[unique|auto]_ptr<X>\202
+
+  iterator
+  insert \201iterator position, std::[unique|auto]_ptr<X>\202
+
+  std::[unique|auto]_ptr<X>
+  detach_back \201bool pop = true\202;
+
+  iterator
+  detach \201iterator position,
+          std::[unique|auto]_ptr<X>& 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<string> 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<string> 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(<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>)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_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 \201\202 const;
+
+  withdraw_sequence&
+  withdraw \201\202;
+
+  void
+  withdraw \201const withdraw_sequence&\202;
+
+  // 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&)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_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 \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 <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>
+      >
+    >
+  >;
+)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<by_id>::type id_set;
+typedef id_set::iterator id_iterator;
+
+const id_set& ids \201b.content_order \201\202.get<by_id> \201\202\202;
+
+std::pair<id_iterator, id_iterator> 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<type>
+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<stream type>&, 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(<complexType name="type">
+  <sequence>
+    ...
+  </sequence>
+</complexType>
+
+<element name="root" type="type"/>)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<value_type>\202;
+
+  // Constructors.
+  //
+  root \201const value_type&\202;
+
+  root \201std::[unique|auto]_ptr<value_type>\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<C>&
+    _name \201\202 const = 0;
+
+    virtual const std::basic_string<C>&
+    _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<xml_schema::element_type>
+    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<C>& element_name,
+                   const std::basic_string<C>& element_namespace\202;
+
+  const std::basic_string<C>&
+  element_name \201\202 const;
+
+  const std::basic_string<C>&
+  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<xml_schema::element_type> r \201
+  xml_schema::element_map::parse \201e\202\202;
+
+if \201root1 r1 = dynamic_cast<root1*> \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<root2&> \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(<!-- 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>)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<derived*> \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<base> 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(<!-- 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>)RP(
+
+  ) 18 70 PR(<!-- 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>)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(<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>)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(<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+</complexType>)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(<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="0"/>
+  </sequence>
+</complexType>)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(<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="unbounded"/>
+  </sequence>
+</complexType>)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 <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 \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 <typename I>
+  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 <typename I>
+  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 <typename I>
+  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(<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>)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(<complexType name="object">
+  <sequence>
+    ...
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>)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 <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 \201xercesc::DOMDocument&\202;
+
+  template <typename I>
+  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<iterator, bool>
+  insert \201const xercesc::DOMAttr&\202;
+
+  // Assumes ownership.
+  //
+  std::pair<iterator, bool>
+  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 <typename I>
+  void)WR(
+  insert \201const I& begin, const I& end\202;
+
+public:
+  void
+  erase \201iterator position\202;
+
+  size_type
+  erase \201const std::basic_string<C>& name\202;
+
+  size_type
+  erase \201const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& 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<C>& name\202 const;
+
+  size_type
+  count \201const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& 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<C>& name\202;
+
+  iterator
+  find \201const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name\202;
+
+  iterator
+  find \201const XMLCh* name\202;
+
+  iterator
+  find \201const XMLCh* namespace_, const XMLCh* name\202;
+
+  const_iterator
+  find \201const std::basic_string<C>& name\202 const;
+
+  const_iterator
+  find \201const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& 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(<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>)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_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 \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_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&)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_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 \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(<element name="name" type="type"/>)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<type>
+name \201const std::basic_string<C>& uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+name \201const std::basic_string<C>& uri,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+name \201const std::basic_string<C>& 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<type>
+name \201std::istream&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+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<type>
+name \201std::istream&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+
+std::[unique|auto]_ptr<type>
+name \201std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+name \201std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+name \201std::istream&,
+      const std::basic_string<C>& 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<type>
+name \201xercesc::InputSource&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;
+
+std::[unique|auto]_ptr<type>
+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<type>
+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<type>
+name \201const xercesc::DOMDocument&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties \201\202\202;)WR(
+
+std::[unique|auto]_ptr<type>
+name \201xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>,
+      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<DOMDoc)HY(u)HY(ment)YH(>)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<type> 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<C>& namespace_,
+                   const std::basic_string<C>& location\202;
+  void
+  no_namespace_schema_location \201const std::basic_string<C>& 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<C>& id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string<C>& 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<C>& id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string<C>& message\202;
+
+  severity
+  severity \201\202 const;
+
+  const std::basic_string<C>&
+  id \201\202 const;
+
+  unsigned long
+  line \201\202 const;
+
+  unsigned long
+  column \201\202 const;)WR(
+
+  const std::basic_string<C>&
+  message \201\202 const;
+};
+
+std::basic_ostream<C>&
+operator<< \201std::basic_ostream<C>&, const error&\202;
+
+struct diagnostics: std::vector<error>
+{
+};
+
+std::basic_ostream<C>&
+operator<< \201std::basic_ostream<C>&, 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<C>& name,
+                    const std::basic_string<C>& namespace_\202;
+
+
+  const std::basic_string<C>&
+  name \201\202 const;
+
+  const std::basic_string<C>&
+  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<C>& encountered_name,
+                      const std::basic_string<C>& encountered_namespace,
+                      const std::basic_string<C>& expected_name,
+                      const std::basic_string<C>& expected_namespace\202
+
+
+  const std::basic_string<C>&
+  encountered_name \201\202 const;
+
+  const std::basic_string<C>&
+  encountered_namespace \201\202 const;
+
+
+  const std::basic_string<C>&
+  expected_name \201\202 const;
+
+  const std::basic_string<C>&
+  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<C>& name,
+                      const std::basic_string<C>& namespace_\202;
+
+
+  const std::basic_string<C>&
+  name \201\202 const;
+
+  const std::basic_string<C>&
+  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<C>& enumerator\202;
+
+  const std::basic_string<C>&
+  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<C>& type_name,
+                const std::basic_string<C>& type_namespace\202;
+
+  const std::basic_string<C>&
+  type_name \201\202 const;
+
+  const std::basic_string<C>&
+  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<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\202;
+
+  const std::basic_string<C>&
+  base_type_name \201\202 const;
+
+  const std::basic_string<C>&
+  base_type_namespace \201\202 const;
+
+
+  const std::basic_string<C>&
+  derived_type_name \201\202 const;
+
+  const std::basic_string<C>&
+  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<C>& prefix\202;
+
+  const std::basic_string<C>&
+  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<type> r1 \201name \201"test.xml"\202\202;
+unique_ptr<type> 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<type> r1 \201name \201"test.xml"\202\202;
+auto_ptr<type> 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<type> r \201name \201ifs, "test.xml"\202\202;
+}
+
+{
+  std::string str \201"..."\202; // Some XML fragment.
+  std::istringstream iss \201str\202;
+  unique_ptr<type> 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<type> 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<xercesc::DOMDocument> doc = ...
+
+std::unique_ptr<type> 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<xercesc::DOMDocument> doc = ...
+
+std::auto_ptr<type> 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(<xsd:element name="name" type="type"/>)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<C>& 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<C>& 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<C>& 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<C>& 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<C>& 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<C>& encoding = "UTF-8",
+      xml_schema::flags = 0\202;
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>)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<C>& name,
+                  const std::basic_string<C>& schema\202;
+
+  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>
+{
+};)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(<?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">)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(<?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">)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(<?xml version="1.0" ?>
+<name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">)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(<?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">)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<?xml ... ?>\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<type> 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<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 \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<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 \201\202;
+
+{
+  // Choose a target.
+  //
+  unique_ptr<XMLFormatTarget> ft;
+
+  if \201argc != 2\202
+  {
+    ft = unique_ptr<XMLFormatTarget> \201new StdOutFormatTarget \201\202\202;
+  }
+  else
+  {
+    ft = unique_ptr<XMLFormatTarget> \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<type> 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<type> 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(<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>)RP(
+
+  ) 42 68 PR(using namespace xercesc;
+
+XMLPlatformUtils::Initialize \201\202;
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr<type> 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<DOMElement*> \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<DOMElement*> \201n\202;
+      break;
+    }
+  }
+)WR(
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type& t \201
+    *reinterpret_cast<xml_schema::type*> \201
+       ae->getUserData \201xml_schema::dom::tree_node_key\202\202\202;
+
+  xml_schema::string& a \201dynamic_cast<xml_schema::string&> \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(<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+    <element name="b" type="int"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>)RP(
+
+  ) 21 51 PR(// Parse XML to object model.
+//
+std::unique_ptr<type> r \201root \201"root.xml"\202\202;
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream<ACE_OutputCDR> ocdr \201ace_ocdr\202;
+
+ocdr << *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr \201buf, size\202;
+xml_schema::istream<ACE_InputCDR> icdr \201ace_icdr\202;
+
+std::unique_ptr<object> 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<import namespace="\.\.\." schemaLocation="base\.xsd"/>\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<xml_schema::buffer>
+or
+.B std::auto_ptr<xml_schema::buffer>
+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<xml_schema::buffer>
+.br
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+.br
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+.br
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+.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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>XSD 4.2.0 Compiler Command Line Manual</title>
+
+  <meta name="version" content="4.2.0"/>
+  <meta name="copyright" content="&#169; 2005-2023 Code Synthesis"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,code,generator,manual,man,page"/>
+  <meta name="description" content="XSD Compiler Command Line Manual"/>
+
+  <link rel="stylesheet" type="text/css" href="default.css" />
+
+<style type="text/css">
+
+  #synopsis {
+    list-style-type:  none;
+  }
+
+  #synopsis li {
+    padding-top      : 0.0em;
+    padding-bottom   : 0.0em;
+  }
+
+  #commands dt {
+    padding-top      : 0.4em;
+  }
+
+  #commands dd {
+    padding-bottom   : 0.4em;
+    padding-left     : 2em;
+  }
+
+  .options {
+    margin: 1em 0 1em 0;
+  }
+
+  .options dt {
+    margin: 1em 0 0 0;
+  }
+
+  .options dd {
+    margin: .1em 0 0 4.5em;
+  }
+
+</style>
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <h1>NAME</h1>
+
+  <p>xsd - W3C XML Schema to C++ Compiler</p>
+
+  <h1>SYNOPSIS</h1>
+
+  <dl id="synopsis">
+    <dt><code><b>xsd</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
+    <dt><code><b>xsd help</b> [<i>command</i>]</code></dt>
+    <dt><code><b>xsd version</b></code></dt>
+  </dl>
+
+  <h1>DESCRIPTION</h1>
+
+  <p><code><b>xsd</b></code> generates vocabulary-specific, statically-typed
+  C++ mapping from W3C XML Schema definitions. Particular mapping to
+  produce is selected by a <code><i>command</i></code>. Each mapping has
+  a number of mapping-specific <code><i>options</i></code> that should
+  appear, if any, after the <code><i>command</i></code>. Input files should
+  be W3C XML Schema definitions. The exact set of the generated files depends
+  on the selected mapping and options.</p>
+
+  <h1>COMMANDS</h1>
+
+  <dl id="commands">
+    <dt><code><b>cxx-tree</b></code></dt>
+    <dd>Generate the C++/Tree mapping. For each input file in the form
+        <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name.hxx</b></code> (header file),
+        <code><b>name.ixx</b></code> (inline file, generated only if the
+          <code><b>--generate-inline</b></code> option is specified),
+	<code><b>name.cxx</b></code> (source file), and
+        <code><b>name-fwd.hxx</b></code> (forward declaration file, generated
+          only if the <code><b>--generate-forward</b></code> option is
+          specified).</dd>
+
+    <dt><code><b>cxx-parser</b></code></dt>
+    <dd>Generate the C++/Parser mapping. For each input file in the form
+        <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name-pskel.hxx</b></code> (parser skeleton header file),
+        <code><b>name-pskel.ixx</b></code> (parser skeleton inline file,
+          generated only if the <code><b>--generate-inline</b></code>
+          option is specified), and
+	<code><b>name-pskel.cxx</b></code> (parser skeleton source file).
+        If the <code><b>--generate-noop-impl</b></code> or
+        <code><b>--generate-print-impl</b></code> option is specified,
+        the following additional sample implementation files are generated:
+        <code><b>name-pimpl.hxx</b></code> (parser implementation header
+        file) and
+        <code><b>name-pimpl.cxx</b></code> (parser implementation source
+        file). If the <code><b>--generate-test-driver</b></code> option
+        is specified, the additional <code><b>name-driver.cxx</b></code>
+        test driver file is generated.</dd>
+
+    <dt><code><b>help</b></code></dt>
+    <dd>Print usage information and exit. Use
+      <p><code><b>xsd help</b> <i>command</i></code></p>
+      for command-specific help.
+    </dd>
+
+    <dt><code><b>version</b></code></dt>
+    <dd>Print version and exit.</dd>
+  </dl>
+
+  <h1>OPTIONS</h1>
+
+  <p>Command-specific <code><i>options</i></code>, if any, should appear
+  after the corresponding <code><i>command</i></code>.</p>
+
+  <h2>COMMON OPTIONS</h2>
+  <dl class="options">
+    <dt><code><b>--std</b></code> <code><i>version</i></code></dt>
+    <dd>Specify the C++ standard that the generated code should conform to.
+    Valid values are <code><b>c++98</b></code>, <code><b>c++11</b></code>
+    (default), <code><b>c++14</b></code>, <code><b>c++17</b></code>,
+    <code><b>c++20</b></code>, and <code><b>c++23</b></code>.
+
+    <p>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 <code><b>std::unique_ptr</b></code> instead of
+    deprecated <code><b>std::auto_ptr</b></code>. Currently, there is no
+    difference between the C++11 and the later standards modes.</p>
+
+    <p>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 (<code><b>libxsd</b></code>) 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 <code><b>XSD_CXX11</b></code> macro for your entire
+    project.</p></dd>
+
+    <dt><code><b>--char-type</b></code> <code><i>type</i></code></dt>
+    <dd>Generate code using the provided character <code><i>type</i></code>
+    instead of the default <code><b>char</b></code>. Valid values are
+    <code><b>char</b></code> and <code><b>wchar_t</b></code>.</dd>
+
+    <dt><code><b>--char-encoding</b></code> <code><i>enc</i></code></dt>
+    <dd>Specify the character encoding that should be used in the generated
+    code. Valid values for the <code><b>char</b></code> character type are
+    <code><b>utf8</b></code> (default), <code><b>iso8859-1</b></code>,
+    <code><b>lcp</b></code> (Xerces-C++ local code page), and
+    <code><b>custom</b></code>. If you pass <code><b>custom</b></code> 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
+    <code><b>--hxx-prologue</b></code> option).
+
+    <p>For the <code><b>wchar_t</b></code> character type the only valid value
+    is <code><b>auto</b></code> and the encoding is automatically selected
+    between UTF-16 and UTF-32/UCS-4, depending on the
+    <code><b>wchar_t</b></code> type size.</p></dd>
+
+    <dt><code><b>--output-dir</b></code> <code><i>dir</i></code></dt>
+    <dd>Write generated files to <code><i>dir</i></code> instead of the
+    current directory.</dd>
+
+    <dt><code><b>--generate-inline</b></code></dt>
+    <dd>Generate simple functions inline. This option triggers creation of the
+    inline file.</dd>
+
+    <dt><code><b>--generate-xml-schema</b></code></dt>
+    <dd>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.
+
+    <p>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
+    <code><b>--extern-xml-schema</b></code> option to include this file in the
+    generated files for other schemas.</p></dd>
+
+    <dt><code><b>--extern-xml-schema</b></code> <code><i>file</i></code></dt>
+    <dd>Include a header file derived from <code><i>file</i></code> 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 <code><b>--generate-xml-schema</b></code> option to generate this
+    header file.</dd>
+
+    <dt><code><b>--namespace-map</b></code> <code><i>xns</i></code>=<code><i>cns</i></code></dt>
+    <dd>Map XML Schema namespace <code><i>xns</i></code> to C++ namespace
+    <code><i>cns</i></code>. Repeat this option to specify mapping for more
+    than one XML Schema namespace. For example, the following option:
+
+    <p class="code"><code><b>--namespace-map
+    http://example.com/foo/bar=foo::bar</b></code></p>
+
+    <p>Will map the <code><b>http://example.com/foo/bar</b></code> XML Schema
+    namespace to the <code><b>foo::bar</b></code> C++ namespace.</p></dd>
+
+    <dt><code><b>--namespace-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to translate XML Schema namespace names to C++ namespace names.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> is not supported.
+
+    <p>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</p>
+
+    <p class="code"><code><i>filename</i> <i>namespace</i></code></p>
+
+    <p>For example, if you have file <code><b>hello.xsd</b></code> with
+    namespace <code><b>http://example.com/hello</b></code> and you run
+    <code><b>xsd</b></code> on this file, then the string in question will
+    be:</p>
+
+    <p class="code"><code><b>hello.xsd.
+    http://example.com/hello</b></code></p>
+
+    <p>For the built-in XML Schema namespace the string is:</p>
+
+    <p class="code"><code><b>XMLSchema.xsd
+    http://www.w3.org/2001/XMLSchema</b></code></p>
+
+    <p>The following three steps are performed for each regular expression
+    until the match is found:</p>
+
+    <p>1. The expression is applied and if the result is empty the next
+    expression is considered.</p>
+
+    <p>2. All '<code><b>/</b></code>' are replaced with
+    '<code><b>::</b></code>'.</p>
+
+    <p>3. The result is verified to be a valid C++ scope name (e.g.,
+    <code><b>foo::bar</b></code>). If this test succeeds, the result is used
+    as a C++ namespace name.</p>
+
+    <p>As an example, the following expression maps XML  Schema namespaces in
+    the form <code><b>http://example.com/foo/bar</b></code> to C++ namespaces
+    in the form <code><b>foo::bar</b></code>:</p>
+
+    <p class="code"><code><b>%.* http://example.com/(.+)%$1%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--namespace-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--namespace-regex</b></code> option. Use this option to find out
+    why your regular expressions don't do what you expected them to do.</dd>
+
+    <dt><code><b>--reserved-name</b></code> <code><i>n</i></code>[=<code><i>r</i></code>]</dt>
+    <dd>Add name <code><i>n</i></code> to the list of names that should not be
+    used as identifiers. The name can optionally be followed by
+    <code><b>=</b></code> and the replacement name <code><i>r</i></code> that
+    should be used instead. All the C++ keywords are already in this
+    list.</dd>
+
+    <dt><code><b>--include-with-brackets</b></code></dt>
+    <dd>Use angle brackets (&lt;>) instead of quotes ("") in generated
+    <code><b>#include</b></code> directives.</dd>
+
+    <dt><code><b>--include-prefix</b></code> <code><i>prefix</i></code></dt>
+    <dd>Add <code><i>prefix</i></code> to generated
+    <code><b>#include</b></code> directive paths.
+
+    <p>For example, if you had the following import element in your schema</p>
+
+    <p class="code"><code><b>&lt;import namespace="..."
+    schemaLocation="base.xsd"/></b></code></p>
+
+    <p>and compiled this fragment with <code><b>--include-prefix
+    schemas/</b></code>, then the include directive in the generated code
+    would be:</p>
+
+    <p class="code"><code><b>#include "schemas/base.hxx"</b></code></p></dd>
+
+    <dt><code><b>--include-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to transform <code><b>#include</b></code> directive paths.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> is not supported.
+
+    <p>All the regular expressions are pushed into a stack with the last
+    specified expression considered first. The first match that succeeds is
+    used.</p>
+
+    <p>As an example, the following expression transforms paths in the form
+    <code><b>schemas/foo/bar</b></code> to paths in the form
+    <code><b>generated/foo/bar</b></code>:</p>
+
+    <p class="code"><code><b>%schemas/(.+)%generated/$1%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--include-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--include-regex</b></code> option. Use this option to find out
+    why your regular expressions don't do what you expected them to do.</dd>
+
+    <dt><code><b>--guard-prefix</b></code> <code><i>prefix</i></code></dt>
+    <dd>Add <code><i>prefix</i></code> 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.</dd>
+
+    <dt><code><b>--hxx-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>.hxx</b></code> 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.</dd>
+
+    <dt><code><b>--ixx-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>.ixx</b></code> to construct the name of the inline file.</dd>
+
+    <dt><code><b>--cxx-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>.cxx</b></code> to construct the name of the source file.</dd>
+
+    <dt><code><b>--fwd-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>-fwd.hxx</b></code> to construct the name of the forward
+    declaration file.</dd>
+
+    <dt><code><b>--hxx-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use the provided expression to construct the name of the header file.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
+    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.</dd>
+
+    <dt><code><b>--ixx-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use the provided expression to construct the name of the inline file.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. See
+    also the REGEX AND SHELL QUOTING section below.</dd>
+
+    <dt><code><b>--cxx-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use the provided expression to construct the name of the source file.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. See
+    also the REGEX AND SHELL QUOTING section below.</dd>
+
+    <dt><code><b>--fwd-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use the provided expression to construct the name of the forward
+    declaration file. <code><i>regex</i></code> is a Perl-like regular
+    expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. See
+    also the REGEX AND SHELL QUOTING section below.</dd>
+
+    <dt><code><b>--hxx-prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of the header
+    file.</dd>
+
+    <dt><code><b>--ixx-prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of the inline
+    file.</dd>
+
+    <dt><code><b>--cxx-prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of the source
+    file.</dd>
+
+    <dt><code><b>--fwd-prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of the forward
+    declaration file.</dd>
+
+    <dt><code><b>--prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of each generated
+    file for which there is no file-specific prologue.</dd>
+
+    <dt><code><b>--hxx-epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of the header file.</dd>
+
+    <dt><code><b>--ixx-epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of the inline file.</dd>
+
+    <dt><code><b>--cxx-epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of the source file.</dd>
+
+    <dt><code><b>--fwd-epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of the forward declaration
+    file.</dd>
+
+    <dt><code><b>--epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of each generated file for
+    which there is no file-specific epilogue.</dd>
+
+    <dt><code><b>--hxx-prologue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the beginning of
+    the header file.</dd>
+
+    <dt><code><b>--ixx-prologue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the beginning of
+    the inline file.</dd>
+
+    <dt><code><b>--cxx-prologue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the beginning of
+    the source file.</dd>
+
+    <dt><code><b>--fwd-prologue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the beginning of
+    the forward declaration file.</dd>
+
+    <dt><code><b>--prologue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the beginning of
+    each generated file for which there is no file-specific prologue
+    file.</dd>
+
+    <dt><code><b>--hxx-epilogue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the end of the
+    header file.</dd>
+
+    <dt><code><b>--ixx-epilogue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the end of the
+    inline file.</dd>
+
+    <dt><code><b>--cxx-epilogue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the end of the
+    source file.</dd>
+
+    <dt><code><b>--fwd-epilogue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the end of the
+    forward declaration file.</dd>
+
+    <dt><code><b>--epilogue-file</b></code> <code><i>file</i></code></dt>
+    <dd>Insert the content of the <code><i>file</i></code> at the end of each
+    generated file for which there is no file-specific epilogue file.</dd>
+
+    <dt><code><b>--export-symbol</b></code> <code><i>symbol</i></code></dt>
+    <dd>Insert <code><i>symbol</i></code> in places where DLL export/import
+    control statements (<code><b>__declspec(dllexport/dllimport)</b></code>)
+    are necessary.</dd>
+
+    <dt><code><b>--export-xml-schema</b></code></dt>
+    <dd>Export/import types in the XML Schema namespace using the export
+    symbol provided with the <code><b>--export-symbol</b></code> option. The
+    <code><b>XSD_NO_EXPORT</b></code> 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.</dd>
+
+    <dt><code><b>--export-maps</b></code></dt>
+    <dd>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
+    <code><b>--import-maps</b></code>. This option is only valid together with
+    <code><b>--generate-polymorphic</b></code>. The
+    <code><b>XSD_NO_EXPORT</b></code> 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.</dd>
+
+    <dt><code><b>--import-maps</b></code></dt>
+    <dd>Import polymorphism support maps to a Win32 DLL or executable into
+    which this generated code is linked. See the
+    <code><b>--export-maps</b></code> option documentation for details. This
+    options is only valid together with
+    <code><b>--generate-polymorphic</b></code>. The
+    <code><b>XSD_NO_EXPORT</b></code> 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.</dd>
+
+    <dt><code><b>--generate-dep</b></code></dt>
+    <dd>Generate <code><b>make</b></code> dependency information. This option
+    triggers the creation of the <code><b>.d</b></code> 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 <code><b>makefile</b></code>
+    to implement automatic dependency tracking. See also the
+    <code><b>--dep-*</b></code> options.
+
+    <p>Note also that automatic dependency generation is not supported in the
+    file-per-type mode (<code><b>--file-per-type</b></code>). 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
+    <code><b>--file-list*</b></code> options.</p></dd>
+
+    <dt><code><b>--generate-dep-only</b></code></dt>
+    <dd>Generate <code><b>make</b></code> dependency information only.</dd>
+
+    <dt><code><b>--dep-phony</b></code></dt>
+    <dd>Generate phony targets for included/imported schema files, causing
+    each to depend on nothing. Such dummy rules work around
+    <code><b>make</b></code> errors caused by the removal of schema files
+    without also updating the dependency file to match.</dd>
+
+    <dt><code><b>--dep-target</b></code> <code><i>target</i></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--dep-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use <code><i>suffix</i></code> instead of the default
+    <code><b>.d</b></code> to construct the name of the dependency file. See
+    also <code><b>--dep-file</b></code>.</dd>
+
+    <dt><code><b>--dep-file</b></code> <code><i>path</i></code></dt>
+    <dd>Use <code><i>path</i></code> as the generated dependency file path
+    instead of deriving it from the input file name. Write the dependency
+    information to <code><b>stdout</b></code> if <code><i>path</i></code> is
+    <code><b>-</b></code>. See also <code><b>--dep-regex</b></code>.</dd>
+
+    <dt><code><b>--dep-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use the provided expression to construct the name of the dependency
+    file. <code><i>regex</i></code> is a Perl-like regular expression in the
+    form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. See
+    also the REGEX AND SHELL QUOTING section below.</dd>
+
+    <dt><code><b>--disable-warning</b></code> <code><i>warn</i></code></dt>
+    <dd>Disable printing warning with id <code><i>warn</i></code>. If
+    <code><b>all</b></code> is specified for the warning id then all warnings
+    are disabled.</dd>
+
+    <dt><code><b>--options-file</b></code> <code><i>file</i></code></dt>
+    <dd>Read additional options from <code><i>file</i></code>. Each option
+    should appearing on a separate line optionally followed by space and an
+    option value. Empty lines and lines starting with <code><b>#</b></code>
+    are ignored. Option values can be enclosed in double
+    (<code><b>"</b></code>) or single (<code><b>'</b></code>) 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 <code><b>'"x"'</b></code>.
+    Non-leading and non-trailing quotes are interpreted as being part of the
+    option value.
+
+    <p>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 <code><b>--options-file</b></code> 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.</p></dd>
+
+    <dt><code><b>--show-sloc</b></code></dt>
+    <dd>Show the number of generated physical source lines of code
+    (SLOC).</dd>
+
+    <dt><code><b>--sloc-limit</b></code> <code><i>num</i></code></dt>
+    <dd>Check that the number of generated physical source lines of code
+    (SLOC) does not exceed <code><i>num</i></code>.</dd>
+
+    <dt><code><b>--proprietary-license</b></code></dt>
+    <dd>Indicate that the generated code is licensed under a proprietary
+    license instead of the GPL.</dd>
+
+    <dt><code><b>--custom-literals</b></code> <code><i>file</i></code></dt>
+    <dd>Load custom XML string to C++ literal mappings from
+    <code><i>file</i></code>. 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
+    <code><b>custom-literals.xsd</b></code> XML Schema file that can be found
+    in the documentation directory.</dd>
+
+    <dt><code><b>--preserve-anonymous</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--show-anonymous</b></code></dt>
+    <dd>Show elements and attributes that are of anonymous types. This option
+    only makes sense together with the
+    <code><b>--preserve-anonymous</b></code> option.</dd>
+
+    <dt><code><b>--anonymous-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to derive names for anonymous types from the enclosing
+    attributes/elements. <code><i>regex</i></code> is a Perl-like regular
+    expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> is not supported.
+
+    <p>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</p>
+
+    <p class="code"><code><i>filename</i> <i>namespace</i>
+    <i>xpath</i></code></p>
+
+    <p>For instance:</p>
+
+    <p class="code"><code><b>hello.xsd http://example.com/hello
+    element</b></code></p>
+
+    <p class="code"><code><b>hello.xsd http://example.com/hello
+    type/element</b></code></p>
+
+    <p>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:</p>
+
+    <p class="code"><code><b>%.* .* (.+/)*(.+)%\u$2%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--anonymous-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--anonymous-regex</b></code> option. Use this option to find out
+    why your regular expressions don't do what you expected them to do.</dd>
+
+    <dt><code><b>--location-map</b></code> <code><i>ol</i></code>=<code><i>nl</i></code></dt>
+    <dd>Map the original schema location <code><i>ol</i></code> that is
+    specified in the XML Schema include or import elements to new schema
+    location <code><i>nl</i></code>. Repeat this option to map more than one
+    schema location. For example, the following option maps the
+    <code><b>http://example.com/foo.xsd</b></code> URL to the
+    <code><b>foo.xsd</b></code> local file.
+
+    <p class="code"><code><b>--location-map
+    http://example.com/foo.xsd=foo.xsd</b></code></p></dd>
+
+    <dt><code><b>--location-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to map schema locations that are specified in the XML Schema include or
+    import elements. <code><i>regex</i></code> is a Perl-like regular
+    expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> 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.
+
+    <p>For example, the following expression maps URL locations in the form
+    <code><b>http://example.com/foo/bar.xsd</b></code> to local files in the
+    form <code><b>bar.xsd</b></code>:</p>
+
+    <p class="code"><code><b>%http://.+/(.+)%$1%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--location-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--location-regex</b></code> option. Use this option to find out
+    why your regular expressions don't do what you expected them to do.</dd>
+
+    <dt><code><b>--file-per-type</b></code></dt>
+    <dd>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:
+    <code><b>--type-file-regex</b></code>,
+    <code><b>--schema-file-regex</b></code>,
+    <code><b>--fat-type-file</b></code>, and
+    <code><b>--file-list</b></code>.</dd>
+
+    <dt><code><b>--type-file-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to translate type names to file names when the
+    <code><b>--file-per-type</b></code> option is specified.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> 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
+
+    <p class="code"><code><i>namespace</i> <i>type-name</i></code></p>
+
+    <p>For example, the following expression maps type <code><b>foo</b></code>
+    that is defined in the <code><b>http://example.com/bar</b></code>
+    namespace to file name <code><b>bar-foo</b></code>:</p>
+
+    <p class="code"><code><b>%http://example.com/(.+)
+    (.+)%$1-$2%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--type-file-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--type-file-regex</b></code> option. Use this option to find out
+    why your regular expressions don't do what you expected them to do.</dd>
+
+    <dt><code><b>--schema-file-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> to the list of regular expressions used
+    to translate schema file names when the
+    <code><b>--file-per-type</b></code> option is specified.
+    <code><i>regex</i></code> is a Perl-like regular expression in the form
+    <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>. Any
+    character can be used as a delimiter instead of '<code><b>/</b></code>'.
+    Escaping of the delimiter character in <code><i>pattern</i></code> or
+    <code><i>replacement</i></code> 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 <code><b>#include</b></code> directive paths as well as the generated
+    C++ file paths. This option, along with
+    <code><b>--type-file-regex</b></code> are primarily useful to place the
+    generated files into subdirectories or to resolve file name conflicts.
+
+    <p>For example, the following expression maps schema files in the
+    <code><b>foo/1.0.0/</b></code> subdirectory to the files in the
+    <code><b>foo/</b></code> subdirectory. As a result, the
+    <code><b>#include</b></code> directive paths for such schemas will be in
+    the <code><b>foo/schema.hxx</b></code> form and the generated C++ files
+    will be placed into the <code><b>foo/</b></code> subdirectory:</p>
+
+    <p class="code"><code><b>%.*/foo/1.0.0/(.+)%foo/$1%</b></code></p>
+
+    <p>See also the REGEX AND SHELL QUOTING section below.</p></dd>
+
+    <dt><code><b>--schema-file-regex-trace</b></code></dt>
+    <dd>Trace the process of applying regular expressions specified with the
+    <code><b>--schema-file-regex</b></code> option. Use this option to find
+    out why your regular expressions don't do what you expected them to
+    do.</dd>
+
+    <dt><code><b>--fat-type-file</b></code></dt>
+    <dd>Generate code corresponding to global elements into type files instead
+    of schema files when the <code><b>--type-file-regex</b></code> 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.</dd>
+
+    <dt><code><b>--file-list</b></code> <code><i>file</i></code></dt>
+    <dd>Write a list of generated C++ files to <code><i>file</i></code> or to
+    <code><b>stdout</b></code> if <code><i>file</i></code> is
+    <code><b>-</b></code>. This option is primarily useful in the
+    file-per-type compilation mode (<code><b>--file-per-type</b></code>) to
+    create a list of generated C++ files, for example, as a makefile
+    fragment.</dd>
+
+    <dt><code><b>--file-list-only</b></code></dt>
+    <dd>Only write the list of C++ files that would be generated without
+    actually generating them. This option only makes sense together with
+    <code><b>--file-list</b></code>.</dd>
+
+    <dt><code><b>--file-list-prologue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the beginning of the file list. As
+    a convenience, all occurrences of the <code><b>\n</b></code> character
+    sequence in <code><i>text</i></code> are replaced with new lines. This
+    option can, for example, be used to assign the generated file list to a
+    makefile variable.</dd>
+
+    <dt><code><b>--file-list-epilogue</b></code> <code><i>text</i></code></dt>
+    <dd>Insert <code><i>text</i></code> at the end of the file list. As a
+    convenience, all occurrences of the <code><b>\n</b></code> character
+    sequence in <code><i>text</i></code> are replaced with new lines.</dd>
+
+    <dt><code><b>--file-list-delim</b></code> <code><i>text</i></code></dt>
+    <dd>Delimit file names written to the file list with
+    <code><i>text</i></code> instead of new lines. As a convenience, all
+    occurrences of the <code><b>\n</b></code> character sequence in
+    <code><i>text</i></code> are replaced with new lines.</dd>
+  </dl>
+
+  <h2>CXX-TREE COMMAND OPTIONS</h2>
+  <dl class="options">
+    <dt><code><b>--generate-polymorphic</b></code></dt>
+    <dd>Generate polymorphism-aware code. Specify this option if you use
+    substitution groups or <code><b>xsi:type</b></code>. Use the
+    <code><b>--polymorphic-type</b></code> or
+    <code><b>--polymorphic-type-all</b></code> option to specify which type
+    hierarchies are polymorphic.</dd>
+
+    <dt><code><b>--polymorphic-type</b></code> <code><i>type</i></code></dt>
+    <dd>Indicate that <code><i>type</i></code> 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
+    <code><i>type</i></code>. The <code><i>type</i></code> argument is an XML
+    Schema type name that can be optionally qualified with a namespace in the
+    <code><i>namespace</i><b>#</b><i>name</i></code> form.</dd>
+
+    <dt><code><b>--polymorphic-type-all</b></code></dt>
+    <dd>Indicate that all types should be treated as polymorphic.</dd>
+
+    <dt><code><b>--polymorphic-plate</b></code> <code><i>num</i></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--ordered-type</b></code> <code><i>type</i></code></dt>
+    <dd>Indicate that element order in <code><i>type</i></code> 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.
+
+    <p>The <code><i>type</i></code> argument is an XML Schema type name that
+    can be optionally qualified with a namespace in the
+    <code><i>namespace</i><b>#</b><i>name</i></code> 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.</p></dd>
+
+    <dt><code><b>--ordered-type-derived</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--ordered-type-mixed</b></code></dt>
+    <dd>Automatically treat complex types with mixed content as ordered.</dd>
+
+    <dt><code><b>--ordered-type-all</b></code></dt>
+    <dd>Indicate that element order in all types is significant.</dd>
+
+    <dt><code><b>--order-container</b></code> <code><i>type</i></code></dt>
+    <dd>Specify a custom class template that should be used as a container for
+    the content order in ordered types instead of the default
+    <code><b>std::vector</b></code>. See <code><b>--ordered-type</b></code>
+    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
+    <code><b>--hxx-prologue*</b></code> options.</dd>
+
+    <dt><code><b>--generate-serialization</b></code></dt>
+    <dd>Generate serialization functions. Serialization functions convert the
+    object model back to XML.</dd>
+
+    <dt><code><b>--generate-ostream</b></code></dt>
+    <dd>Generate ostream insertion operators
+    (<code><b>operator&lt;&lt;</b></code>) for generated types. This allows
+    one to easily print a fragment or the whole object model for debugging or
+    logging.</dd>
+
+    <dt><code><b>--generate-doxygen</b></code></dt>
+    <dd>Generate documentation comments suitable for extraction by the Doxygen
+    documentation system. Documentation from annotations is added to the
+    comments if present in the schema.</dd>
+
+    <dt><code><b>--generate-comparison</b></code></dt>
+    <dd>Generate comparison operators (<code><b>operator==</b></code> and
+    <code><b>operator!=</b></code>) for complex types. Comparison is performed
+    member-wise.</dd>
+
+    <dt><code><b>--generate-default-ctor</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--generate-from-base-ctor</b></code></dt>
+    <dd>Generate constructors that expect an instance of a base type followed
+    by all required members.</dd>
+
+    <dt><code><b>--suppress-assignment</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--generate-detach</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--generate-wildcard</b></code></dt>
+    <dd>Generate accessors and modifiers as well as parsing and serialization
+    code for XML Schema wildcards (<code><b>any</b></code> and
+    <code><b>anyAttribute</b></code>). 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.</dd>
+
+    <dt><code><b>--generate-any-type</b></code></dt>
+    <dd>Extract and store content of the XML Schema
+    <code><b>anyType</b></code> type as a DOM fragment. Note that you need to
+    initialize the Xerces-C++ runtime if you are using this option.</dd>
+
+    <dt><code><b>--generate-insertion</b></code> <code><i>os</i></code></dt>
+    <dd>Generate data representation stream insertion operators for the
+    <code><i>os</i></code> output stream type. Repeat this option to specify
+    more than one stream type. The ACE CDR stream
+    (<code><b>ACE_OutputCDR</b></code>) and RPC XDR are recognized by the
+    compiler and the necessary <code><b>#include</b></code> directives are
+    automatically generated. For custom stream types use the
+    <code><b>--hxx-prologue*</b></code> options to provide the necessary
+    declarations.</dd>
+
+    <dt><code><b>--generate-extraction</b></code> <code><i>is</i></code></dt>
+    <dd>Generate data representation stream extraction constructors for the
+    <code><i>is</i></code> input stream type. Repeat this option to specify
+    more than one stream type. The ACE CDR stream
+    (<code><b>ACE_InputCDR</b></code>) and RPC XDR are recognized by the
+    compiler and the necessary <code><b>#include</b></code> directives are
+    automatically generated. For custom stream types use the
+    <code><b>--hxx-prologue*</b></code> options to provide the necessary
+    declarations.</dd>
+
+    <dt><code><b>--generate-forward</b></code></dt>
+    <dd>Generate a separate header file with forward declarations for the
+    types being generated.</dd>
+
+    <dt><code><b>--suppress-parsing</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--generate-element-type</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--generate-element-map</b></code></dt>
+    <dd>Generate a root element map that allows uniform parsing and
+    serialization of multiple root elements. This option is only valid
+    together with <code><b>--generate-element-type</b></code>.</dd>
+
+    <dt><code><b>--generate-intellisense</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--omit-default-attributes</b></code></dt>
+    <dd>Omit attributes with default and fixed values from serialized XML
+    documents.</dd>
+
+    <dt><code><b>--type-naming</b></code> <code><i>style</i></code></dt>
+    <dd>Specify the type naming convention that should be used in the
+    generated code. Valid styles are <code><b>knr</b></code> (default),
+    <code><b>ucc</b></code>, and <code><b>java</b></code>. See the NAMING
+    CONVENTION section below for more information.</dd>
+
+    <dt><code><b>--function-naming</b></code> <code><i>style</i></code></dt>
+    <dd>Specify the function naming convention that should be used in the
+    generated code. Valid styles are <code><b>knr</b></code> (default),
+    <code><b>lcc</b></code>, <code><b>ucc</b></code>, and
+    <code><b>java</b></code>. See the NAMING CONVENTION section below for more
+    information.</dd>
+
+    <dt><code><b>--type-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--accessor-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--one-accessor-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--opt-accessor-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--seq-accessor-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--modifier-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--one-modifier-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--opt-modifier-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--seq-modifier-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--parser-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--serializer-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--const-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--enumerator-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--element-type-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Add <code><i>regex</i></code> 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.</dd>
+
+    <dt><code><b>--name-regex-trace</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--root-element-first</b></code></dt>
+    <dd>Treat only the first global element as a document root. By default all
+    global elements are considered document roots.</dd>
+
+    <dt><code><b>--root-element-last</b></code></dt>
+    <dd>Treat only the last global element as a document root. By default all
+    global elements are considered document roots.</dd>
+
+    <dt><code><b>--root-element-all</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--root-element-none</b></code></dt>
+    <dd>Do not treat any global elements as document roots. By default all
+    global elements are considered document roots.</dd>
+
+    <dt><code><b>--root-element</b></code> <code><i>element</i></code></dt>
+    <dd>Treat only <code><i>element</i></code> as a document root. Repeat this
+    option to specify more than one root element.</dd>
+
+    <dt><code><b>--custom-type</b></code> <code><i>map</i></code></dt>
+    <dd>Use a custom C++ type instead of the generated class. The
+    <code><i>map</i></code> argument is in the form
+    <code><i>name</i>[<b>=</b><i>type</i>[<b>/</b><i>base</i>]]</code>, where
+    <i>name</i> is a type name as defined in XML Schema and <i>type</i> is a
+    C++ type name that should be used instead. If <i>type</i> 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
+    <i>base</i> is specified then the generated class is still generated but
+    with that name.</dd>
+
+    <dt><code><b>--custom-type-regex</b></code> <code><i>regex</i></code></dt>
+    <dd>Use custom C++ types instead of the generated classes. The
+    <code><i>regex</i></code> argument is in the form
+    <code><b>/</b><i>name-pat</i><b>/</b>[<i>type-sub</i><b>/</b>[<i>base-sub</i><b>/</b>]]</code>,
+    where <i>name-pat</i> is a regex pattern that will be matched against type
+    names as defined in XML Schema and <i>type-sub</i> is a C++ type name
+    substitution that should be used instead. If <i>type-sub</i> 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 <i>base-sub</i> 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.</dd>
+
+    <dt><code><b>--parts</b></code> <code><i>num</i></code></dt>
+    <dd>Split generated source code into <code><i>num</i></code> 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).</dd>
+
+    <dt><code><b>--parts-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use <code><i>suffix</i></code> instead of the default
+    '<code><b>-</b></code>' to separate the file name from the part
+    number.</dd>
+  </dl>
+
+  <h2>CXX-PARSER COMMAND OPTIONS</h2>
+  <dl class="options">
+    <dt><code><b>--type-map</b></code> <code><i>mapfile</i></code></dt>
+    <dd>Read XML Schema to C++ type mapping information from
+    <code><i>mapfile</i></code>. 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
+    <code><b>void</b></code>. See the TYPE MAP section below for more
+    information.</dd>
+
+    <dt><code><b>--xml-parser</b></code> <code><i>parser</i></code></dt>
+    <dd>Use <code><i>parser</i></code> as the underlying XML parser. Valid
+    values are <code><b>xerces</b></code> for Xerces-C++ (default) and
+    <code><b>expat</b></code> for Expat.</dd>
+
+    <dt><code><b>--generate-validation</b></code></dt>
+    <dd>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 (<code><b>expat</b></code>).</dd>
+
+    <dt><code><b>--suppress-validation</b></code></dt>
+    <dd>Suppress the generation of validation code. Validation is suppressed
+    by default when the selected underlying XML parser is validating
+    (<code><b>xerces</b></code>).</dd>
+
+    <dt><code><b>--generate-polymorphic</b></code></dt>
+    <dd>Generate polymorphism-aware code. Specify this option if you use
+    substitution groups or <code><b>xsi:type</b></code>.</dd>
+
+    <dt><code><b>--generate-noop-impl</b></code></dt>
+    <dd>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
+    <code><b>name.xsd</b></code> this option triggers the generation of two
+    additional C++ files in the form: <code><b>name-pimpl.hxx</b></code>
+    (parser implementation header file) and <code><b>name-pimpl.cxx</b></code>
+    (parser implementation source file).</dd>
+
+    <dt><code><b>--generate-print-impl</b></code></dt>
+    <dd>Generate a sample parser implementation that prints the XML data to
+    <code>STDOUT</code>. For an input file in the form
+    <code><b>name.xsd</b></code> this option triggers the generation of two
+    additional C++ files in the form: <code><b>name-pimpl.hxx</b></code>
+    (parser implementation header file) and <code><b>name-pimpl.cxx</b></code>
+    (parser implementation source file).</dd>
+
+    <dt><code><b>--generate-test-driver</b></code></dt>
+    <dd>Generate a test driver for the sample parser implementation. For an
+    input file in the form <code><b>name.xsd</b></code> this option triggers
+    the generation of an additional C++ file in the form
+    <code><b>name-driver.cxx</b></code>.</dd>
+
+    <dt><code><b>--force-overwrite</b></code></dt>
+    <dd>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.</dd>
+
+    <dt><code><b>--root-element-first</b></code></dt>
+    <dd>Indicate that the first global element is the document root. This
+    information is used to generate the test driver for the sample
+    implementation.</dd>
+
+    <dt><code><b>--root-element-last</b></code></dt>
+    <dd>Indicate that the last global element is the document root. This
+    information is used to generate the test driver for the sample
+    implementation.</dd>
+
+    <dt><code><b>--root-element</b></code> <code><i>element</i></code></dt>
+    <dd>Indicate that <code><i>element</i></code> is the document root. This
+    information is used to generate the test driver for the sample
+    implementation.</dd>
+
+    <dt><code><b>--skel-type-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>_pskel</b></code> to construct the names of the generated parser
+    skeletons.</dd>
+
+    <dt><code><b>--skel-file-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>-pskel</b></code> to construct the names of the generated parser
+    skeleton files.</dd>
+
+    <dt><code><b>--impl-type-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>_pimpl</b></code> to construct the names of the parser
+    implementations for the built-in XML Schema types as well as sample parser
+    implementations.</dd>
+
+    <dt><code><b>--impl-file-suffix</b></code> <code><i>suffix</i></code></dt>
+    <dd>Use the provided <code><i>suffix</i></code> instead of the default
+    <code><b>-pimpl</b></code> to construct the names of the generated sample
+    parser implementation files.</dd>
+  </dl>
+
+  <h1>NAMING CONVENTION</h1>
+
+  <p>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 <code><b>--type-naming</b></code>
+     and <code><b>--function-naming</b></code> options. A custom
+     naming convention can be achieved using the
+     <code><b>--type-regex</b></code>,
+     <code><b>--accessor-regex</b></code>,
+     <code><b>--one-accessor-regex</b></code>,
+     <code><b>--opt-accessor-regex</b></code>,
+     <code><b>--seq-accessor-regex</b></code>,
+     <code><b>--modifier-regex</b></code>,
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>,
+     <code><b>--seq-modifier-regex</b></code>,
+     <code><b>--parser-regex</b></code>,
+     <code><b>--serializer-regex</b></code>,
+     <code><b>--const-regex</b></code>,
+     <code><b>--enumerator-regex</b></code>, and
+     <code><b>--element-type-regex</b></code> options.
+  </p>
+
+  <p>The <code><b>--type-naming</b></code> option specifies the
+     convention that should be used for naming C++ types. Possible
+     values for this option are <code><b>knr</b></code> (default),
+     <code><b>ucc</b></code>, and <code><b>java</b></code>. The
+     <code><b>knr</b></code> value (stands for K&amp;R) signifies
+     the standard, lower-case naming convention with the underscore
+     used as a word delimiter, for example: <code>foo</code>,
+     <code>foo_bar</code>. The <code><b>ucc</b></code> (stands
+     for upper-camel-case) and
+     <code><b>java</b></code> values a synonyms for the same
+     naming convention where the first letter of each word in the
+     name is capitalized, for example: <code>Foo</code>,
+     <code>FooBar</code>.</p>
+
+  <p>Similarly, the <code><b>--function-naming</b></code> option
+     specifies the convention that should be used for naming C++
+     functions. Possible values for this option are <code><b>knr</b></code>
+     (default), <code><b>lcc</b></code>, <code><b>ucc</b></code>, and
+     <code><b>java</b></code>. The <code><b>knr</b></code> value (stands
+     for K&amp;R) signifies the standard, lower-case naming convention
+     with the underscore used as a word delimiter, for example:
+     <code>foo()</code>, <code>foo_bar()</code>. The <code><b>lcc</b></code>
+     value (stands for lower-camel-case) signifies a naming convention
+     where the first letter of each word except the first is capitalized,
+     for example: <code>foo()</code>, <code>fooBar()</code>. The
+     <code><b>ucc</b></code> value (stands for upper-camel-case) signifies
+     a naming convention where the first letter of each word is capitalized,
+     for example: <code>Foo()</code>, <code>FooBar()</code>.
+     The <code><b>java</b></code> naming convention is similar to
+     the lower-camel-case one except that accessor functions are prefixed
+     with <code>get</code>, modifier functions are prefixed
+     with <code>set</code>, parsing functions are prefixed
+     with <code>parse</code>, and serialization functions are
+     prefixed with <code>serialize</code>, for example:
+     <code>getFoo()</code>, <code>setFooBar()</code>,
+     <code>parseRoot()</code>, <code>serializeRoot()</code>.</p>
+
+  <p>Note that the naming conventions specified with the
+     <code><b>--type-naming</b></code> and
+     <code><b>--function-naming</b></code> 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
+     <code><b>--*-regex</b></code> options (discussed below)
+     to perform further transformations on the names that come from
+     the schema.</p>
+
+  <p>The
+     <code><b>--type-regex</b></code>,
+     <code><b>--accessor-regex</b></code>,
+     <code><b>--one-accessor-regex</b></code>,
+     <code><b>--opt-accessor-regex</b></code>,
+     <code><b>--seq-accessor-regex</b></code>,
+     <code><b>--modifier-regex</b></code>,
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>,
+     <code><b>--seq-modifier-regex</b></code>,
+     <code><b>--parser-regex</b></code>,
+     <code><b>--serializer-regex</b></code>,
+     <code><b>--const-regex</b></code>,
+     <code><b>--enumerator-regex</b></code>, and
+     <code><b>--element-type-regex</b></code> options allow you to
+     specify extra regular expressions for each name category in
+     addition to the predefined set that is added depending on
+     the <code><b>--type-naming</b></code> and
+     <code><b>--function-naming</b></code> options. Expressions
+     that are provided with the <code><b>--*-regex</b></code>
+     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 <code><b>--name-regex-trace</b></code> option allows you
+     to trace the process of applying regular expressions to
+     names.</p>
+
+  <p>The value for the <code><b>--*-regex</b></code> options should be
+     a perl-like regular expression in the form
+     <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
+     Any character can be used as a delimiter instead of <code><b>/</b></code>.
+     Escaping of the delimiter character in <code><i>pattern</i></code> or
+     <code><i>replacement</i></code> 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
+     <code><b>--one-accessor-regex</b></code> (accessors with cardinality one),
+     <code><b>--opt-accessor-regex</b></code> (accessors with cardinality optional), and
+     <code><b>--seq-accessor-regex</b></code> (accessors with cardinality sequence)
+     categories the  <code><b>--accessor-regex</b></code> expressions are
+     used as a fallback. For the
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>, and
+     <code><b>--seq-modifier-regex</b></code>
+     categories the  <code><b>--modifier-regex</b></code> expressions are
+     used as a fallback. For the <code><b>--element-type-regex</b></code>
+     category the <code><b>--type-regex</b></code> expressions are
+     used as a fallback.</p>
+
+  <p>The type name expressions (<code><b>--type-regex</b></code>)
+     are evaluated on the name string that has the following
+     format:</p>
+
+  <p><code>[<i>namespace</i> ]<i>name</i>[,<i>name</i>][,<i>name</i>][,<i>name</i>]</code></p>
+
+  <p>The element type name expressions
+     (<code><b>--element-type-regex</b></code>), effective only when
+     the <code><b>--generate-element-type</b></code> option is specified,
+     are evaluated on the name string that has the following
+     format:</p>
+
+  <p><code><i>namespace</i> <i>name</i></code></p>
+
+  <p>In the type name format the <code><i>namespace</i></code> 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 <code><i>namespace</i></code> part is empty but
+     the space is still present. In the type name format after the
+     initial <code><i>name</i></code> component, up to three additional
+     <code><i>name</i></code> components can be present, separated
+     by commas. For example:</p>
+
+  <p><code><b>http://example.com/hello type</b></code></p>
+  <p><code><b>foo</b></code></p>
+  <p><code><b>foo,iterator</b></code></p>
+  <p><code><b>foo,const,iterator</b></code></p>
+
+  <p>The following set of predefined regular expressions is used to
+     transform type names when the upper-camel-case naming convention
+     is selected:</p>
+
+  <p><code><b>/(?:[^ ]* )?([^,]+)/\u$1/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/</b></code></p>
+
+  <p>The accessor and modifier expressions
+     (<code><b>--*accessor-regex</b></code> and
+     <code><b>--*modifier-regex</b></code>) are evaluated on the name string
+     that has the following format:</p>
+
+  <p><code><i>name</i>[,<i>name</i>][,<i>name</i>]</code></p>
+
+  <p>After the initial <code><i>name</i></code> component, up to two
+     additional <code><i>name</i></code> components can be present,
+     separated by commas. For example:</p>
+
+  <p><code><b>foo</b></code></p>
+  <p><code><b>dom,document</b></code></p>
+  <p><code><b>foo,default,value</b></code></p>
+
+  <p>The following set of predefined regular expressions is used to
+     transform accessor names when the <code><b>java</b></code> naming
+     convention is selected:</p>
+
+  <p><code><b>/([^,]+)/get\u$1/</b></code></p>
+  <p><code><b>/([^,]+),([^,]+)/get\u$1\u$2/</b></code></p>
+  <p><code><b>/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/</b></code></p>
+
+  <p>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 <code><b>java</b></code> naming convention
+     is selected:</p>
+
+  <p><code><b>/(.+)/parse\u$1/</b></code></p>
+
+  <p>The const category is used to create C++ constant names for the
+     element/wildcard/text content ids in ordered types.</p>
+
+  <p>See also the REGEX AND SHELL QUOTING section below.</p>
+
+  <h1>TYPE MAP</h1>
+
+  <p>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 <code><b>post_*</b></code>
+     functions in parser skeletons corresponding to XML Schema
+     types as well as argument types for callbacks corresponding
+     to elements and attributes of these types.</p>
+
+  <p>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 <code><b>void</b></code>.
+     By providing your own type maps you can override these predefined
+     rules. The format of the type map file is presented below:
+  </p>
+
+  <pre>
+namespace &lt;schema-namespace> [&lt;cxx-namespace>]
+{
+  (include &lt;file-name>;)*
+  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
+}
+  </pre>
+
+  <p>Both <code><i>&lt;schema-namespace></i></code> and
+     <code><i>&lt;schema-type></i></code> are regex patterns while
+     <code><i>&lt;cxx-namespace></i></code>,
+     <code><i>&lt;cxx-ret-type></i></code>, and
+     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
+     substitutions. All names can be optionally enclosed in
+     <code><b>" "</b></code>, for example, to include white-spaces.</p>
+
+  <p><code><i>&lt;schema-namespace></i></code> determines XML
+     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
+     is prefixed to every C++ type name in this namespace declaration.
+     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
+     used as a return type for the <code><b>post_*</b></code> functions.
+     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
+     type for callback functions corresponding to elements and attributes
+     of this type. If
+     <code><i>&lt;cxx-arg-type></i></code> is not specified, it defaults
+     to <code><i>&lt;cxx-ret-type></i></code> if <code><i>&lt;cxx-ret-type></i></code>
+     ends with <code><b>*</b></code> or <code><b>&amp;</b></code> (that is,
+     it is a pointer or a reference) and
+     <code><b>const</b>&nbsp;<i>&lt;cxx-ret-type></i><b>&amp;</b></code>
+     otherwise.
+     <code><i>&lt;file-name></i></code> is a file name either in the
+     <code><b>" "</b></code> or <code><b>&lt; ></b></code> format
+     and is added with the <code><b>#include</b></code> directive to
+     the generated code.</p>
+
+  <p>The <code><b>#</b></code> character starts a comment that ends
+     with a new line or end of file. To specify a name that contains
+     <code><b>#</b></code> enclose it in <code><b>" "</b></code>.
+     For example:</p>
+
+  <pre>
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  </pre>
+
+  <p>In the example above, for the
+     <code><b>http://www.example.com/xmlns/my#orange</b></code>
+     XML Schema type, the <code><b>my::orange_t*</b></code> C++ type will
+     be used as both return and argument types.</p>
+
+  <p>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:</p>
+
+  <pre>
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  </pre>
+
+  <p>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 <code><b>std::string</b></code>
+     or <code><b>std::wstring</b></code> depending on the character type
+     selected with the <code><b>--char-type</b></code> option
+     (<code><b>char</b></code> by default). The binary XML Schema types are
+     mapped to either <code>std::unique_ptr&lt;xml_schema::buffer></code>
+     or <code>std::auto_ptr&lt;xml_schema::buffer></code> depending on the C++
+     standard selected with the <code><b>--std</b></code> option
+     (<code><b>c++11</b></code> by default).</p>
+
+  <pre>
+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&lt;xml_schema::buffer>
+               std::[unique|auto]_ptr&lt;xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr&lt;xml_schema::buffer>
+            std::[unique|auto]_ptr&lt;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;
+}
+  </pre>
+
+  <p>The last predefined rule maps anything that wasn't mapped by
+     previous rules to <code><b>void</b></code>:</p>
+
+  <pre>
+namespace .*
+{
+  .* void void;
+}
+  </pre>
+
+
+  <p>When you provide your own type maps with the
+     <code><b>--type-map</b></code> option, they are evaluated first.
+     This allows you to selectively override predefined rules.</p>
+
+  <h1>REGEX AND SHELL QUOTING</h1>
+
+  <p>When entering a regular expression argument in the shell
+     command line it is often necessary to use quoting (enclosing
+     the argument in <code><b>"&nbsp;"</b></code> or
+     <code><b>'&nbsp;'</b></code>) in order to prevent the shell
+     from interpreting certain characters, for example, spaces as
+     argument separators and <code><b>$</b></code> as variable
+     expansions.</p>
+
+  <p>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 <code><b>"&nbsp;"</b></code> for quoting you will get a
+     wrong result with POSIX shells if your expression contains
+     <code><b>$</b></code>. The standard way of dealing with this
+     on POSIX systems is to use <code><b>'&nbsp;'</b></code> instead.
+     Unfortunately, Windows shell does not remove <code><b>'&nbsp;'</b></code>
+     from arguments when they are passed to applications. As a result you
+     may have to use <code><b>'&nbsp;'</b></code> for POSIX and
+     <code><b>"&nbsp;"</b></code> for Windows (<code><b>$</b></code> is
+     not treated as a special character on Windows).</p>
+
+  <p>Alternatively, you can save regular expression options into
+     a file, one option per line, and use this file with the
+     <code><b>--options-file</b></code> option. With this approach
+     you don't need to worry about shell quoting.</p>
+
+  <h1>DIAGNOSTICS</h1>
+
+  <p>If the input file is not a valid W3C XML Schema definition,
+    <code><b>xsd</b></code> will issue diagnostic messages to STDERR
+    and exit with non-zero exit code.</p>
+
+  <h1>BUGS</h1>
+
+  <p>Send bug reports to the
+     <a href="mailto:xsd-users@codesynthesis.com">xsd-users@codesynthesis.com</a> mailing list.</p>
+
+  </div>
+  <div id="footer">
+    Copyright &#169; 2005-2023 Code Synthesis.
+
+    <div id="terms">
+      Permission is granted to copy, distribute and/or modify this
+      document under the terms of the
+      <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+      Documentation License, version 1.2</a>; with no Invariant Sections,
+      no Front-Cover Texts and no Back-Cover Texts.
+    </div>
+  </div>
+</div>
+</body>
+</html>
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<xml_schema::buffer>
+or
+.B std::auto_ptr<xml_schema::buffer>
+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<xml_schema::buffer>
+.br
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+.br
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+.br
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+.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 @@
+  <h1>NAMING CONVENTION</h1>
+
+  <p>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 <code><b>--type-naming</b></code>
+     and <code><b>--function-naming</b></code> options. A custom
+     naming convention can be achieved using the
+     <code><b>--type-regex</b></code>,
+     <code><b>--accessor-regex</b></code>,
+     <code><b>--one-accessor-regex</b></code>,
+     <code><b>--opt-accessor-regex</b></code>,
+     <code><b>--seq-accessor-regex</b></code>,
+     <code><b>--modifier-regex</b></code>,
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>,
+     <code><b>--seq-modifier-regex</b></code>,
+     <code><b>--parser-regex</b></code>,
+     <code><b>--serializer-regex</b></code>,
+     <code><b>--const-regex</b></code>,
+     <code><b>--enumerator-regex</b></code>, and
+     <code><b>--element-type-regex</b></code> options.
+  </p>
+
+  <p>The <code><b>--type-naming</b></code> option specifies the
+     convention that should be used for naming C++ types. Possible
+     values for this option are <code><b>knr</b></code> (default),
+     <code><b>ucc</b></code>, and <code><b>java</b></code>. The
+     <code><b>knr</b></code> value (stands for K&amp;R) signifies
+     the standard, lower-case naming convention with the underscore
+     used as a word delimiter, for example: <code>foo</code>,
+     <code>foo_bar</code>. The <code><b>ucc</b></code> (stands
+     for upper-camel-case) and
+     <code><b>java</b></code> values a synonyms for the same
+     naming convention where the first letter of each word in the
+     name is capitalized, for example: <code>Foo</code>,
+     <code>FooBar</code>.</p>
+
+  <p>Similarly, the <code><b>--function-naming</b></code> option
+     specifies the convention that should be used for naming C++
+     functions. Possible values for this option are <code><b>knr</b></code>
+     (default), <code><b>lcc</b></code>, <code><b>ucc</b></code>, and
+     <code><b>java</b></code>. The <code><b>knr</b></code> value (stands
+     for K&amp;R) signifies the standard, lower-case naming convention
+     with the underscore used as a word delimiter, for example:
+     <code>foo()</code>, <code>foo_bar()</code>. The <code><b>lcc</b></code>
+     value (stands for lower-camel-case) signifies a naming convention
+     where the first letter of each word except the first is capitalized,
+     for example: <code>foo()</code>, <code>fooBar()</code>. The
+     <code><b>ucc</b></code> value (stands for upper-camel-case) signifies
+     a naming convention where the first letter of each word is capitalized,
+     for example: <code>Foo()</code>, <code>FooBar()</code>.
+     The <code><b>java</b></code> naming convention is similar to
+     the lower-camel-case one except that accessor functions are prefixed
+     with <code>get</code>, modifier functions are prefixed
+     with <code>set</code>, parsing functions are prefixed
+     with <code>parse</code>, and serialization functions are
+     prefixed with <code>serialize</code>, for example:
+     <code>getFoo()</code>, <code>setFooBar()</code>,
+     <code>parseRoot()</code>, <code>serializeRoot()</code>.</p>
+
+  <p>Note that the naming conventions specified with the
+     <code><b>--type-naming</b></code> and
+     <code><b>--function-naming</b></code> 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
+     <code><b>--*-regex</b></code> options (discussed below)
+     to perform further transformations on the names that come from
+     the schema.</p>
+
+  <p>The
+     <code><b>--type-regex</b></code>,
+     <code><b>--accessor-regex</b></code>,
+     <code><b>--one-accessor-regex</b></code>,
+     <code><b>--opt-accessor-regex</b></code>,
+     <code><b>--seq-accessor-regex</b></code>,
+     <code><b>--modifier-regex</b></code>,
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>,
+     <code><b>--seq-modifier-regex</b></code>,
+     <code><b>--parser-regex</b></code>,
+     <code><b>--serializer-regex</b></code>,
+     <code><b>--const-regex</b></code>,
+     <code><b>--enumerator-regex</b></code>, and
+     <code><b>--element-type-regex</b></code> options allow you to
+     specify extra regular expressions for each name category in
+     addition to the predefined set that is added depending on
+     the <code><b>--type-naming</b></code> and
+     <code><b>--function-naming</b></code> options. Expressions
+     that are provided with the <code><b>--*-regex</b></code>
+     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 <code><b>--name-regex-trace</b></code> option allows you
+     to trace the process of applying regular expressions to
+     names.</p>
+
+  <p>The value for the <code><b>--*-regex</b></code> options should be
+     a perl-like regular expression in the form
+     <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
+     Any character can be used as a delimiter instead of <code><b>/</b></code>.
+     Escaping of the delimiter character in <code><i>pattern</i></code> or
+     <code><i>replacement</i></code> 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
+     <code><b>--one-accessor-regex</b></code> (accessors with cardinality one),
+     <code><b>--opt-accessor-regex</b></code> (accessors with cardinality optional), and
+     <code><b>--seq-accessor-regex</b></code> (accessors with cardinality sequence)
+     categories the  <code><b>--accessor-regex</b></code> expressions are
+     used as a fallback. For the
+     <code><b>--one-modifier-regex</b></code>,
+     <code><b>--opt-modifier-regex</b></code>, and
+     <code><b>--seq-modifier-regex</b></code>
+     categories the  <code><b>--modifier-regex</b></code> expressions are
+     used as a fallback. For the <code><b>--element-type-regex</b></code>
+     category the <code><b>--type-regex</b></code> expressions are
+     used as a fallback.</p>
+
+  <p>The type name expressions (<code><b>--type-regex</b></code>)
+     are evaluated on the name string that has the following
+     format:</p>
+
+  <p><code>[<i>namespace</i> ]<i>name</i>[,<i>name</i>][,<i>name</i>][,<i>name</i>]</code></p>
+
+  <p>The element type name expressions
+     (<code><b>--element-type-regex</b></code>), effective only when
+     the <code><b>--generate-element-type</b></code> option is specified,
+     are evaluated on the name string that has the following
+     format:</p>
+
+  <p><code><i>namespace</i> <i>name</i></code></p>
+
+  <p>In the type name format the <code><i>namespace</i></code> 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 <code><i>namespace</i></code> part is empty but
+     the space is still present. In the type name format after the
+     initial <code><i>name</i></code> component, up to three additional
+     <code><i>name</i></code> components can be present, separated
+     by commas. For example:</p>
+
+  <p><code><b>http://example.com/hello type</b></code></p>
+  <p><code><b>foo</b></code></p>
+  <p><code><b>foo,iterator</b></code></p>
+  <p><code><b>foo,const,iterator</b></code></p>
+
+  <p>The following set of predefined regular expressions is used to
+     transform type names when the upper-camel-case naming convention
+     is selected:</p>
+
+  <p><code><b>/(?:[^ ]* )?([^,]+)/\u$1/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/</b></code></p>
+  <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/</b></code></p>
+
+  <p>The accessor and modifier expressions
+     (<code><b>--*accessor-regex</b></code> and
+     <code><b>--*modifier-regex</b></code>) are evaluated on the name string
+     that has the following format:</p>
+
+  <p><code><i>name</i>[,<i>name</i>][,<i>name</i>]</code></p>
+
+  <p>After the initial <code><i>name</i></code> component, up to two
+     additional <code><i>name</i></code> components can be present,
+     separated by commas. For example:</p>
+
+  <p><code><b>foo</b></code></p>
+  <p><code><b>dom,document</b></code></p>
+  <p><code><b>foo,default,value</b></code></p>
+
+  <p>The following set of predefined regular expressions is used to
+     transform accessor names when the <code><b>java</b></code> naming
+     convention is selected:</p>
+
+  <p><code><b>/([^,]+)/get\u$1/</b></code></p>
+  <p><code><b>/([^,]+),([^,]+)/get\u$1\u$2/</b></code></p>
+  <p><code><b>/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/</b></code></p>
+
+  <p>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 <code><b>java</b></code> naming convention
+     is selected:</p>
+
+  <p><code><b>/(.+)/parse\u$1/</b></code></p>
+
+  <p>The const category is used to create C++ constant names for the
+     element/wildcard/text content ids in ordered types.</p>
+
+  <p>See also the REGEX AND SHELL QUOTING section below.</p>
+
+  <h1>TYPE MAP</h1>
+
+  <p>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 <code><b>post_*</b></code>
+     functions in parser skeletons corresponding to XML Schema
+     types as well as argument types for callbacks corresponding
+     to elements and attributes of these types.</p>
+
+  <p>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 <code><b>void</b></code>.
+     By providing your own type maps you can override these predefined
+     rules. The format of the type map file is presented below:
+  </p>
+
+  <pre>
+namespace &lt;schema-namespace> [&lt;cxx-namespace>]
+{
+  (include &lt;file-name>;)*
+  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
+}
+  </pre>
+
+  <p>Both <code><i>&lt;schema-namespace></i></code> and
+     <code><i>&lt;schema-type></i></code> are regex patterns while
+     <code><i>&lt;cxx-namespace></i></code>,
+     <code><i>&lt;cxx-ret-type></i></code>, and
+     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
+     substitutions. All names can be optionally enclosed in
+     <code><b>" "</b></code>, for example, to include white-spaces.</p>
+
+  <p><code><i>&lt;schema-namespace></i></code> determines XML
+     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
+     is prefixed to every C++ type name in this namespace declaration.
+     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
+     used as a return type for the <code><b>post_*</b></code> functions.
+     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
+     type for callback functions corresponding to elements and attributes
+     of this type. If
+     <code><i>&lt;cxx-arg-type></i></code> is not specified, it defaults
+     to <code><i>&lt;cxx-ret-type></i></code> if <code><i>&lt;cxx-ret-type></i></code>
+     ends with <code><b>*</b></code> or <code><b>&amp;</b></code> (that is,
+     it is a pointer or a reference) and
+     <code><b>const</b>&nbsp;<i>&lt;cxx-ret-type></i><b>&amp;</b></code>
+     otherwise.
+     <code><i>&lt;file-name></i></code> is a file name either in the
+     <code><b>" "</b></code> or <code><b>&lt; ></b></code> format
+     and is added with the <code><b>#include</b></code> directive to
+     the generated code.</p>
+
+  <p>The <code><b>#</b></code> character starts a comment that ends
+     with a new line or end of file. To specify a name that contains
+     <code><b>#</b></code> enclose it in <code><b>" "</b></code>.
+     For example:</p>
+
+  <pre>
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  </pre>
+
+  <p>In the example above, for the
+     <code><b>http://www.example.com/xmlns/my#orange</b></code>
+     XML Schema type, the <code><b>my::orange_t*</b></code> C++ type will
+     be used as both return and argument types.</p>
+
+  <p>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:</p>
+
+  <pre>
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  </pre>
+
+  <p>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 <code><b>std::string</b></code>
+     or <code><b>std::wstring</b></code> depending on the character type
+     selected with the <code><b>--char-type</b></code> option
+     (<code><b>char</b></code> by default). The binary XML Schema types are
+     mapped to either <code>std::unique_ptr&lt;xml_schema::buffer></code>
+     or <code>std::auto_ptr&lt;xml_schema::buffer></code> depending on the C++
+     standard selected with the <code><b>--std</b></code> option
+     (<code><b>c++11</b></code> by default).</p>
+
+  <pre>
+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&lt;xml_schema::buffer>
+               std::[unique|auto]_ptr&lt;xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr&lt;xml_schema::buffer>
+            std::[unique|auto]_ptr&lt;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;
+}
+  </pre>
+
+  <p>The last predefined rule maps anything that wasn't mapped by
+     previous rules to <code><b>void</b></code>:</p>
+
+  <pre>
+namespace .*
+{
+  .* void void;
+}
+  </pre>
+
+
+  <p>When you provide your own type maps with the
+     <code><b>--type-map</b></code> option, they are evaluated first.
+     This allows you to selectively override predefined rules.</p>
+
+  <h1>REGEX AND SHELL QUOTING</h1>
+
+  <p>When entering a regular expression argument in the shell
+     command line it is often necessary to use quoting (enclosing
+     the argument in <code><b>"&nbsp;"</b></code> or
+     <code><b>'&nbsp;'</b></code>) in order to prevent the shell
+     from interpreting certain characters, for example, spaces as
+     argument separators and <code><b>$</b></code> as variable
+     expansions.</p>
+
+  <p>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 <code><b>"&nbsp;"</b></code> for quoting you will get a
+     wrong result with POSIX shells if your expression contains
+     <code><b>$</b></code>. The standard way of dealing with this
+     on POSIX systems is to use <code><b>'&nbsp;'</b></code> instead.
+     Unfortunately, Windows shell does not remove <code><b>'&nbsp;'</b></code>
+     from arguments when they are passed to applications. As a result you
+     may have to use <code><b>'&nbsp;'</b></code> for POSIX and
+     <code><b>"&nbsp;"</b></code> for Windows (<code><b>$</b></code> is
+     not treated as a special character on Windows).</p>
+
+  <p>Alternatively, you can save regular expression options into
+     a file, one option per line, and use this file with the
+     <code><b>--options-file</b></code> option. With this approach
+     you don't need to worry about shell quoting.</p>
+
+  <h1>DIAGNOSTICS</h1>
+
+  <p>If the input file is not a valid W3C XML Schema definition,
+    <code><b>xsd</b></code> will issue diagnostic messages to STDERR
+    and exit with non-zero exit code.</p>
+
+  <h1>BUGS</h1>
+
+  <p>Send bug reports to the
+     <a href="mailto:xsd-users@codesynthesis.com">xsd-users@codesynthesis.com</a> mailing list.</p>
+
+  </div>
+  <div id="footer">
+    Copyright &#169; $copyright$.
+
+    <div id="terms">
+      Permission is granted to copy, distribute and/or modify this
+      document under the terms of the
+      <a href="https://www.codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+      Documentation License, version 1.2</a>; with no Invariant Sections,
+      no Front-Cover Texts and no Back-Cover Texts.
+    </div>
+  </div>
+</div>
+</body>
+</html>
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 @@
+  <h2>CXX-PARSER COMMAND OPTIONS</h2>
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 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>$project$ $version$ Compiler Command Line Manual</title>
+
+  <meta name="version" content="$version$"/>
+  <meta name="copyright" content="&#169; $copyright$"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,code,generator,manual,man,page"/>
+  <meta name="description" content="XSD Compiler Command Line Manual"/>
+
+  <link rel="stylesheet" type="text/css" href="default.css" />
+
+<style type="text/css">
+
+  #synopsis {
+    list-style-type:  none;
+  }
+
+  #synopsis li {
+    padding-top      : 0.0em;
+    padding-bottom   : 0.0em;
+  }
+
+  #commands dt {
+    padding-top      : 0.4em;
+  }
+
+  #commands dd {
+    padding-bottom   : 0.4em;
+    padding-left     : 2em;
+  }
+
+  .options {
+    margin: 1em 0 1em 0;
+  }
+
+  .options dt {
+    margin: 1em 0 0 0;
+  }
+
+  .options dd {
+    margin: .1em 0 0 4.5em;
+  }
+
+</style>
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <h1>NAME</h1>
+
+  <p>xsd - W3C XML Schema to C++ Compiler</p>
+
+  <h1>SYNOPSIS</h1>
+
+  <dl id="synopsis">
+    <dt><code><b>xsd</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
+    <dt><code><b>xsd help</b> [<i>command</i>]</code></dt>
+    <dt><code><b>xsd version</b></code></dt>
+  </dl>
+
+  <h1>DESCRIPTION</h1>
+
+  <p><code><b>xsd</b></code> generates vocabulary-specific, statically-typed
+  C++ mapping from W3C XML Schema definitions. Particular mapping to
+  produce is selected by a <code><i>command</i></code>. Each mapping has
+  a number of mapping-specific <code><i>options</i></code> that should
+  appear, if any, after the <code><i>command</i></code>. Input files should
+  be W3C XML Schema definitions. The exact set of the generated files depends
+  on the selected mapping and options.</p>
+
+  <h1>COMMANDS</h1>
+
+  <dl id="commands">
+    <dt><code><b>cxx-tree</b></code></dt>
+    <dd>Generate the C++/Tree mapping. For each input file in the form
+        <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name.hxx</b></code> (header file),
+        <code><b>name.ixx</b></code> (inline file, generated only if the
+          <code><b>--generate-inline</b></code> option is specified),
+	<code><b>name.cxx</b></code> (source file), and
+        <code><b>name-fwd.hxx</b></code> (forward declaration file, generated
+          only if the <code><b>--generate-forward</b></code> option is
+          specified).</dd>
+
+    <dt><code><b>cxx-parser</b></code></dt>
+    <dd>Generate the C++/Parser mapping. For each input file in the form
+        <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name-pskel.hxx</b></code> (parser skeleton header file),
+        <code><b>name-pskel.ixx</b></code> (parser skeleton inline file,
+          generated only if the <code><b>--generate-inline</b></code>
+          option is specified), and
+	<code><b>name-pskel.cxx</b></code> (parser skeleton source file).
+        If the <code><b>--generate-noop-impl</b></code> or
+        <code><b>--generate-print-impl</b></code> option is specified,
+        the following additional sample implementation files are generated:
+        <code><b>name-pimpl.hxx</b></code> (parser implementation header
+        file) and
+        <code><b>name-pimpl.cxx</b></code> (parser implementation source
+        file). If the <code><b>--generate-test-driver</b></code> option
+        is specified, the additional <code><b>name-driver.cxx</b></code>
+        test driver file is generated.</dd>
+
+    <dt><code><b>help</b></code></dt>
+    <dd>Print usage information and exit. Use
+      <p><code><b>xsd help</b> <i>command</i></code></p>
+      for command-specific help.
+    </dd>
+
+    <dt><code><b>version</b></code></dt>
+    <dd>Print version and exit.</dd>
+  </dl>
+
+  <h1>OPTIONS</h1>
+
+  <p>Command-specific <code><i>options</i></code>, if any, should appear
+  after the corresponding <code><i>command</i></code>.</p>
+
+  <h2>COMMON OPTIONS</h2>
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 @@
+  <h2>CXX-TREE COMMAND OPTIONS</h2>
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 <<EOI >=test.xsd;
+<?xml version="1.0"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <xsd:complexType name="hello_t">
+    <xsd:sequence>
+      <xsd:element name="greeting" type="xsd:string"/>
+      <xsd:element name="name" type="xsd:string" maxOccurs="unbounded"/>
+    </xsd:sequence>
+  </xsd:complexType>
+  <xsd:element name="hello" type="hello_t"/>
+</xsd:schema>
+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
+  }
+}
+
+<hxx{~'/(.*)/'} ixx{~'/\1/'} cxx{~'/\1/'}>: 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 <xsd/options-parser.hxx>'
+
+  $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 <xsd/cxx/elements.hxx>
+
+#include <cctype>    // std::toupper
+#include <memory>
+#include <sstream>
+#include <fstream>
+#include <cassert>
+#include <iostream>
+
+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<SemanticGraph::Implies> ());
+        n = &u.schema ().names_begin ()->named ();
+      }
+
+      xs_ns_ = dynamic_cast<SemanticGraph::Namespace*> (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<Schema&> (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<SemanticGraph::Namespace*> (&n));
+
+      return ns ? *ns : namespace_ (s);
+    }
+    else
+    {
+      SemanticGraph::Type& t (dynamic_cast<SemanticGraph::Type&> (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<Schema*> (&n))
+    {
+      return L""; // Map to global namespace.
+    }
+    else if (SemanticGraph::Namespace* ns =
+             dynamic_cast<SemanticGraph::Namespace*> (&n))
+    {
+      r = ns_name (*ns);
+    }
+    else
+    {
+      r = fq_name (n.scope ());
+      r += L"::";
+      r += n.context ().get<String> (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<Complex*> (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<wchar_t> (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<wchar_t> (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<wchar_t> (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<wchar_t> (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<wchar_t> (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<wchar_t> (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 <set>
+#include <map>
+#include <vector>
+#include <ostream>
+
+#include <libcutl/re.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/types.hxx>
+#include <xsd/elements.hxx>
+
+#include <xsd/cxx/options.hxx>
+#include <xsd/cxx/literal-map.hxx>
+
+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<Regex> RegexMapping;
+    typedef std::map<String, String> MapMapping;
+    typedef std::map<String, String> MappingCache;
+
+    typedef std::map<String, String> ReservedNameMap;
+    typedef std::set<String> 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<SemanticGraph::Namespace> () &&
+        m.context ().count ("min") == 0;
+    }
+
+    static size_t
+    min (SemanticGraph::Member const& m)
+    {
+      return m.context ().get<size_t> ("min");
+    }
+
+    static size_t
+    min (SemanticGraph::Any const& a)
+    {
+      return a.context ().get<size_t> ("min");
+    }
+
+    static size_t
+    max (SemanticGraph::Member const& m)
+    {
+      return m.context ().get<size_t> ("max");
+    }
+
+    static size_t
+    max (SemanticGraph::Any const& a)
+    {
+      return a.context ().get<size_t> ("max");
+    }
+
+  public:
+    // Get escaped name.
+    //
+    static String const&
+    ename (SemanticGraph::Nameable const& n)
+    {
+      return n.context ().get<String> ("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<SemanticGraph::Schema*> 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 <typename X>
+  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 <typename X, typename Y>
+  bool
+  has (Y& y)
+  {
+    using SemanticGraph::Scope;
+
+    bool result (false);
+    Has<X> 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 <typename X>
+  bool
+  has_particle (SemanticGraph::Compositor& y)
+  {
+    using SemanticGraph::Compositor;
+
+    bool result (false);
+    Has<X> 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<Compositor> ())
+        result = has_particle<X> (dynamic_cast<Compositor&> (p));
+    }
+
+    return result;
+  }
+
+  // Specialization for Complex
+  //
+  template <typename X>
+  bool
+  has_particle (SemanticGraph::Complex& c)
+  {
+    return c.contains_compositor_p () &&
+      has_particle<X> (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 <memory>  // std::unique_ptr
+#include <cstddef> // std::size_t
+#include <fstream>
+#include <iostream>
+
+#include <xercesc/util/XMLUni.hpp>
+
+#include <xercesc/framework/LocalFileInputSource.hpp>
+
+#include <xercesc/sax/Locator.hpp>
+#include <xercesc/sax/SAXParseException.hpp>
+#include <xercesc/sax2/DefaultHandler.hpp>
+#include <xercesc/sax2/SAX2XMLReader.hpp>
+#include <xercesc/sax2/XMLReaderFactory.hpp>
+
+#include <libxsd-frontend/xml.hxx>
+
+#include <xsd/cxx/literal-map.hxx>
+
+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<size_t> (locator_->getLineNumber ())
+        : 0;
+    }
+
+    size_t
+    col () const
+    {
+      return locator_ != 0
+        ? static_cast<size_t> (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<SAX2XMLReader> 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 <map>
+
+#include <xsd/types.hxx>
+
+namespace CXX
+{
+  typedef std::map<String, String> 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 <istream>
+#include <ostream>
+
+#include <xsd/cxx/option-types.hxx>
+
+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 <iosfwd>
+#include <string>
+
+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 <cstddef>; // std::size_t
+
+include <xsd/types.hxx>; // NarrowString, NarrowStrings
+
+include <xsd/cxx/option-types.hxx>;
+
+include <xsd/options.cli>;
+
+namespace CXX
+{
+  class options: ::options = 0
+  {
+    // Language.
+    //
+    cxx_version --std = cxx_version::cxx11
+    {
+      "<version>",
+      "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"
+    {
+      "<type>",
+      "Generate code using the provided character <type> instead of the
+       default \cb{char}. Valid values are \cb{char} and \cb{wchar_t}."
+    };
+
+    NarrowString --char-encoding
+    {
+      "<enc>",
+      "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
+    {
+      "<dir>",
+      "Write generated files to <dir> 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
+    {
+      "<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 \cb{--generate-xml-schema} option to generate this
+       header file."
+     };
+
+    // Namespace mapping.
+    //
+    NarrowStrings --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:
+
+       \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
+    {
+      "<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
+       \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
+    {
+      "<n>[=<r>]",
+      "Add name <n> to the list of names that should not be used as
+       identifiers. The name can optionally be followed by \cb{=} and the
+       replacement name <r> 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
+    {
+      "<prefix>",
+      "Add <prefix> to generated \cb{#include} directive paths.
+
+       For example, if you had the following import element in your schema
+
+       \cb{<import namespace=\"...\" schemaLocation=\"base.xsd\"/>}
+
+       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
+    {
+      "<regex>",
+      "Add <regex> to the list of regular expressions used to transform
+       \cb{#include} directive paths. <regex> 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
+    {
+      "<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."
+    };
+
+    // File suffixes.
+    //
+    NarrowString --hxx-suffix = ".hxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> 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"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.ixx} to
+       construct the name of the inline file."
+    };
+
+    NarrowString --cxx-suffix = ".cxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.cxx} to
+       construct the name of the source file."
+    };
+
+    NarrowString --fwd-suffix = "-fwd.hxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{-fwd.hxx} to
+       construct the name of the forward declaration file."
+    };
+
+    NarrowString --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
+       \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
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the inline file.
+       <regex> 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
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the source file.
+       <regex> 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
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the forward
+       declaration file. <regex> 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
+    {
+      "<text>",
+      "Insert <text> at the beginning of the header file."
+    };
+
+    NarrowStrings --ixx-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the inline file."
+    };
+
+    NarrowStrings --cxx-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the source file."
+    };
+
+    NarrowStrings --fwd-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the forward declaration file."
+    };
+
+    NarrowStrings --prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of each generated file for which
+       there is no file-specific prologue."
+    };
+
+    NarrowStrings --hxx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the header file."
+    };
+
+    NarrowStrings --ixx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the inline file."
+    };
+
+    NarrowStrings --cxx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the source file."
+    };
+
+    NarrowStrings --fwd-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the forward declaration file."
+    };
+
+    NarrowStrings --epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of each generated file for which there
+       is no file-specific epilogue."
+    };
+
+    NarrowString --hxx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the header file."
+    };
+
+    NarrowString --ixx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the inline file."
+    };
+
+    NarrowString --cxx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the source file."
+    };
+
+    NarrowString --fwd-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the forward
+       declaration file."
+    };
+
+    NarrowString --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."
+    };
+
+    NarrowString --hxx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the header file."
+    };
+
+    NarrowString --ixx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the inline file."
+    };
+
+    NarrowString --cxx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the source file."
+    };
+
+    NarrowString --fwd-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the forward declaration
+       file."
+    };
+
+    NarrowString --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 options.
+    //
+    NarrowString --export-symbol
+    {
+      "<symbol>",
+      "Insert <symbol> 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
+    {
+      "<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"
+    {
+      "<suffix>",
+      "Use <suffix> instead of the default \cb{.d} to construct the name of
+       the dependency file. See also \cb{--dep-file}."
+    };
+
+    NarrowString --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
+       \cb{stdout} if <path> is \cb{-}. See also \cb{--dep-regex}."
+    };
+
+    NarrowString --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
+       \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 <xsd/cxx/parser/attribute-validation-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<Traversal::Attribute> (c));
+          bool has_any (has<Traversal::AnyAttribute> (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<SemanticGraph::Restricts> ())
+            {
+              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<SemanticGraph::Restricts> ())
+            {
+              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<SemanticGraph::Restricts> ())
+            {
+              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<SemanticGraph::Restricts> ())
+            {
+              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 <xsd/cxx/parser/elements.hxx>
+
+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 <xsd/cxx/parser/characters-validation-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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 <xsd/cxx/parser/elements.hxx>
+
+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 <set>
+#include <map>
+#include <sstream>
+
+#include <xsd/cxx/parser/driver-source.hxx>
+#include <xsd/cxx/parser/print-impl-common.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    namespace
+    {
+      typedef map<SemanticGraph::Type*, String> TypeInstanceMap;
+      typedef set<String> 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<Traversal::Member> (c))
+            return true;
+
+          if (c.inherits_p ())
+          {
+            SemanticGraph::Type& b (c.inherits ().base ());
+
+            if (Complex* cb = dynamic_cast<Complex*> (&b))
+              return has_members (*cb);
+
+            return b.is_a<SemanticGraph::List> ();
+          }
+
+          return false;
+        }
+
+      private:
+        TypeInstanceMap& map_;
+        set<SemanticGraph::Type*> 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 <iostream>" << 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 <xsd/cxx/parser/elements.hxx>
+
+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 <vector>
+
+#include <xsd/cxx/parser/element-validation-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    namespace
+    {
+      typedef vector<SemanticGraph::Particle*> 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<Particles> ("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<Particles> ("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<Element*> (&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<Element&>(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<size_t> ("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<size_t> ("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<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
+          size_t state (c.context ().get<size_t> ("state"));
+
+          String func (c.is_a<SemanticGraph::Choice> () ?
+                       "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<Compositor> () && !c.context ().count ("comp-number"))
+              continue; // Empty compositor.
+
+            if (!p.context ().count ("prefix"))
+              break;
+
+            size_t state (p.context ().get<size_t> ("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<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
+
+          String func (c.is_a<SemanticGraph::Choice> () ?
+                       "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<Compositor> () && !c.context ().count ("comp-number"))
+              continue; // Empty compositor.
+
+            if (!p.context ().count ("prefix"))
+              break;
+
+            size_t state (p.context ().get<size_t> ("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<Element&> (ci->particle ()));
+            String ns (e.qualified_p () ? e.namespace_ ().name () : String ());
+            size_t state (e.context ().get<size_t> ("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<size_t> ("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<Compositor> () && !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<size_t> ("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<Compositor> () && !p.context().count ("comp-number"))
+            {
+              // Empty compositor.
+              //
+              ++ci;
+              continue;
+            }
+
+            // Find the next state.
+            //
+            do
+              ++ci;
+            while (ci != ce &&
+                   ci->particle ().is_a<Compositor> () &&
+                   !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<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
+
+          String func (c.is_a<SemanticGraph::Choice> () ?
+                       "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<Compositor> () && !c.context ().count ("comp-number"))
+              continue; // Empty compositor.
+
+            if (!p.context ().count ("prefix"))
+              break;
+
+            size_t state (p.context ().get<size_t> ("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<size_t> ("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<size_t> ("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<Traversal::Element> (c) &&
+              !has_particle<Traversal::Any> (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<SemanticGraph::Restricts> ());
+
+          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<SemanticGraph::All> ())
+          {
+            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<SemanticGraph::All> ())
+          {
+            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<SemanticGraph::All> ())
+          {
+            // 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<SemanticGraph::All> ())
+          {
+            // 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 <cassert>" << 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 <xsd/cxx/parser/elements.hxx>
+
+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 <xsd/cxx/parser/elements.hxx>
+
+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<Complex*> (&base))
+          return content (*cb);
+
+        if (base.is_a<AnyType> ())
+          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<String> ("ret-type");
+    }
+
+    String const& Context::
+    arg_type (SemanticGraph::Type& t)
+    {
+      return t.context ().get<String> ("arg-type");
+    }
+
+    String const& Context::
+    post_name (SemanticGraph::Type& t)
+    {
+      return t.context ().get<String> ("post");
+    }
+
+    String const& Context::
+    eparser (SemanticGraph::Member& m)
+    {
+      return m.context ().get<String> ("parser");
+    }
+
+    String const& Context::
+    emember (SemanticGraph::Member& m)
+    {
+      return m.context ().get<String> ("member");
+    }
+
+    String const& Context::
+    emember_map (SemanticGraph::Member& m)
+    {
+      return m.context ().get<String> ("member-map");
+    }
+
+    String const& Context::
+    eimpl (SemanticGraph::Type& t)
+    {
+      return t.context ().get<String> ("impl");
+    }
+
+    // Includes
+    //
+    void TypeForward::
+    traverse (SemanticGraph::Type& t)
+    {
+      os << "class " << t.context ().get<String> (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<SemanticGraph::Path> ("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 <sstream>
+
+#include <libcutl/re.hxx>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/elements.hxx>
+
+#include <xsd/cxx/parser/options.hxx>
+
+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<SemanticGraph::Restricts> ())
+        {
+          // Restriction of anyType is a special case.
+          //
+          return !c.inherits ().base ().is_a<SemanticGraph::AnyType> ();
+        }
+
+        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 <algorithm>
+#include <iostream>
+#include <fstream>
+
+#include <libcutl/re.hxx>
+
+#include <libcutl/compiler/code-stream.hxx>
+#include <libcutl/compiler/cxx-indenter.hxx>
+#include <libcutl/compiler/sloc-counter.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/version.hxx>
+
+#include <xsd/type-map/lexer.hxx>
+#include <xsd/type-map/parser.hxx>
+#include <xsd/type-map/type-map.hxx>
+
+#include <xsd/cxx/parser/elements.hxx>
+#include <xsd/cxx/parser/generator.hxx>
+
+#include <xsd/cxx/parser/validator.hxx>
+#include <xsd/cxx/parser/name-processor.hxx>
+#include <xsd/cxx/parser/state-processor.hxx>
+#include <xsd/cxx/parser/type-processor.hxx>
+
+#include <xsd/cxx/parser/parser-header.hxx>
+#include <xsd/cxx/parser/parser-inline.hxx>
+#include <xsd/cxx/parser/parser-source.hxx>
+#include <xsd/cxx/parser/parser-forward.hxx>
+
+#include <xsd/cxx/parser/impl-header.hxx>
+#include <xsd/cxx/parser/impl-source.hxx>
+#include <xsd/cxx/parser/driver-source.hxx>
+
+#include <xsd/cxx/parser/element-validation-source.hxx>
+#include <xsd/cxx/parser/attribute-validation-source.hxx>
+#include <xsd/cxx/parser/characters-validation-source.hxx>
+
+#include <xsd/cxx/parser/options.hxx>
+
+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 <typename S>
+    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<compiler::cxx_indenter, wchar_t>
+      ind_filter;
+
+      typedef
+      compiler::ostream_filter<compiler::sloc_counter, wchar_t>
+      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 <xsd/cxx/config.hxx>" << endl
+            << endl
+            << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl
+            << "#error XSD runtime version mismatch" << endl
+            << "#endif" << endl
+            << endl;
+
+        hxx << "#include <xsd/cxx/pre.hxx>" << 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 <xsd/cxx/post.hxx>" << 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 <xsd/cxx/pre.hxx>" << 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 <xsd/cxx/post.hxx>" << 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 <libxsd-frontend/semantic-graph/elements.hxx> // Path
+#include <libxsd-frontend/semantic-graph/schema.hxx>
+
+#include <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/literal-map.hxx>
+#include <xsd/cxx/parser/options.hxx>
+
+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 <xsd/cxx/parser/impl-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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 <xsd/cxx/parser/elements.hxx>
+
+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 <xsd/cxx/parser/impl-source.hxx>
+#include <xsd/cxx/parser/print-impl-common.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<SemanticGraph::Complex&> (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 <iostream>" << 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 <xsd/cxx/parser/elements.hxx>
+
+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 <set>
+#include <map>
+#include <sstream>
+#include <iostream>
+
+#include <xsd/cxx/parser/name-processor.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    namespace
+    {
+      //
+      //
+      typedef set<String> 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<String, NameSet> global_type_names_;
+
+      public:
+        bool const impl;
+        String const& skel_suffix;
+        String const& impl_suffix;
+
+        map<String, NameSet>& 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<String> ("name"));
+          m.context ().set ("member", find_name (base + L"_parser_", set_));
+
+          if (polymorphic &&
+              m.is_a<SemanticGraph::Element> () &&
+              !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> ())
+            {
+              Type& bm (dynamic_cast<Type&> (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<Complex> ())
+              return find_member (dynamic_cast<Complex&> (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<String> ("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<SemanticGraph::Element> () &&
+                        !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<String> ("parser");
+            member = bm.context ().get<String> ("member");
+
+            if (poly)
+            {
+              member_map = bm.context ().get<String> ("member-map");
+              member_map_impl = bm.context ().get<String> ("member-map-impl");
+            }
+          }
+          catch (NotFound const&)
+          {
+            // Fall back to the standard name assignment.
+            //
+            String const& base (m.context ().get<String> ("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<String> ("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<NameSet> ("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<SemanticGraph::Complex> ())
+            {
+              if (!base.context ().count (
+                    "cxx-parser-name-processor-member-set"))
+              {
+                dispatch (base);
+              }
+
+              NameSet const& base_set (
+                base.context ().get<NameSet> (
+                  "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<SemanticGraph::Restricts> () &&
+	        !c.inherits ().base ().is_a<SemanticGraph::AnyType> ();
+            }
+          }
+
+          if (restriction)
+          {
+            // First assign the "primary" names.
+            //
+            {
+              PrimaryMemberInRestriction member (
+                *this,
+                member_set,
+                dynamic_cast<SemanticGraph::Complex&> (
+                  c.inherits ().base ()));
+
+              Traversal::Names names (member);
+
+              Complex::names (c, names);
+            }
+
+            // Assign "derived" names.
+            //
+            {
+              DerivedMemberInRestriction member (
+                *this,
+                member_set,
+                dynamic_cast<SemanticGraph::Complex&> (
+                  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<Complex*> (&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<String> ("post"));
+              else
+                set.insert (find_post_name (*b));
+
+              Complex* cb (dynamic_cast<Complex*> (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 <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/elements.hxx>
+#include <xsd/cxx/parser/options.hxx>
+
+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 <cstddef>; // std::size_t
+
+include <xsd/types.hxx>; // NarrowString, NarrowStrings
+
+include <xsd/cxx/options.cli>;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    class options: CXX::options
+    {
+      NarrowStrings --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 \cb{void}. See the
+         TYPE MAP section below for more information."
+      };
+
+      NarrowString --xml-parser = "xerces"
+      {
+        "<parser>",
+        "Use <parser> 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
+      {
+        "<element>",
+        "Indicate that <element> is the document root. This information is
+         used to generate the test driver for the sample implementation."
+      };
+
+      // Suffixes.
+      //
+      NarrowString --skel-type-suffix = "_pskel"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{_pskel} to
+         construct the names of the generated parser skeletons."
+      };
+
+      NarrowString --skel-file-suffix = "-pskel"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{-pskel} to
+         construct the names of the generated parser skeleton files."
+      };
+
+      NarrowString --impl-type-suffix = "_pimpl"
+      {
+        "<suffix>",
+        "Use the provided <suffix> 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"
+      {
+        "<suffix>",
+        "Use the provided <suffix> 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 <xsd/cxx/parser/parser-forward.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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 <xsd/cxx/parser/elements.hxx>
+
+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 <set>
+
+#include <xsd/cxx/parser/parser-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<SemanticGraph::Element> () &&
+              !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<SemanticGraph::Element> () &&
+              !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<size_t> ("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<size_t> ("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<size_t> ("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<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (c));
+
+          bool hae (has_particle<Traversal::Any> (c));
+          bool haa (has<Traversal::AnyAttribute> (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<size_t> ("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<String> ("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<String> Includes;
+
+          Includes const& is (
+            ctx.schema_root.context ().get<Includes> ("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 <xsd/cxx/xml/char-" << ctx.char_encoding << ".hxx>" << endl;
+        }
+
+        ctx.os << "#include <xsd/cxx/xml/error-handler.hxx>" << endl
+               << "#include <xsd/cxx/parser/exceptions.hxx>" << endl
+               << "#include <xsd/cxx/parser/elements.hxx>" << endl
+               << "#include <xsd/cxx/parser/xml-schema.hxx>" << endl;
+
+        if (ctx.polymorphic)
+          ctx.os << "#include <xsd/cxx/parser/map.hxx>" << endl;
+
+        if (ctx.validation)
+          ctx.os << "#include <xsd/cxx/parser/validating/parser.hxx>" << endl
+                 << "#include <xsd/cxx/parser/validating/exceptions.hxx>" << endl
+                 << "#include <xsd/cxx/parser/validating/xml-schema-pskel.hxx>" << endl
+                 << "#include <xsd/cxx/parser/validating/xml-schema-pimpl.hxx>" << endl;
+        else
+          ctx.os << "#include <xsd/cxx/parser/non-validating/parser.hxx>" << endl
+                 << "#include <xsd/cxx/parser/non-validating/xml-schema-pskel.hxx>" << endl
+                 << "#include <xsd/cxx/parser/non-validating/xml-schema-pimpl.hxx>" << endl;
+
+        ctx.os << "#include <xsd/cxx/parser/" << ctx.xml_parser <<
+          "/elements.hxx>" << endl
+               << endl;
+
+        // Generate includes that came from the type map.
+        //
+        if (ctx.schema_root.context ().count ("includes"))
+        {
+          typedef set<String> Includes;
+
+          Includes const& is (
+            ctx.schema_root.context ().get<Includes> ("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 <xsd/cxx/parser/elements.hxx>
+
+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 <xsd/cxx/parser/parser-inline.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<SemanticGraph::Element> () &&
+                        !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<SemanticGraph::Element> () &&
+              !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<size_t> ("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<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (c));
+
+          bool hae (has_particle<Traversal::Any> (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))
+          {
+            // <name>_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 <xsd/cxx/parser/elements.hxx>
+
+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 <xsd/cxx/parser/parser-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<SemanticGraph::Element*> (&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<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (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<SemanticGraph::Element*> (&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<SemanticGraph::Restricts> ());
+
+          // _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 <xsd/cxx/parser/substitution-map.hxx>" << endl;
+
+        if (ctx.validation)
+          ctx.os << "#include <xsd/cxx/parser/validating/inheritance-map.hxx>" << 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 <xsd/cxx/parser/elements.hxx>
+
+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 <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/parser/elements.hxx>
+
+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<short> (" << 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<unsigned short> (" << 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 <vector>
+#include <iostream>
+
+#include <xsd/cxx/parser/state-processor.hxx>
+
+#include <xsd/cxx/parser/elements.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    namespace
+    {
+      typedef vector<SemanticGraph::Particle*> 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<SemanticGraph::Element*> (*i))
+          {
+            wcerr << e->name () << endl;
+          }
+          else
+          {
+            wcerr << "<any>" << 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<SemanticGraph::Element> () ||
+                p.is_a<SemanticGraph::Any> ())
+            {
+              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<size_t> ("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<SemanticGraph::Element> () ||
+                p.is_a<SemanticGraph::Any> ())
+            {
+              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<size_t> ("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 <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/types.hxx>
+
+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 <set>
+
+#include <xsd/cxx/parser/elements.hxx>
+#include <xsd/cxx/parser/type-processor.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+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<SemanticGraph::Schema*> ("root-schema"));
+
+            if (&schema_ == s)
+              return;
+
+            set = false;
+          }
+
+          SemanticGraph::Namespace& ns (
+            dynamic_cast<SemanticGraph::Namespace&> (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<String> Includes;
+
+                      if (!schema_.context ().count ("includes"))
+                        schema_.context ().set ("includes", Includes ());
+
+                      Includes& is (
+                        schema_.context ().get<Includes> ("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 <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/types.hxx>
+
+#include <xsd/type-map/type-map.hxx>
+
+#include <xsd/cxx/parser/options.hxx>
+
+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 <set>
+#include <iostream>
+
+#include <xsd/cxx/parser/validator.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/parser/elements.hxx>
+
+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<SemanticGraph::Namespace> ())
+            return L"<namespace-level>"; // There is a bug if you see this.
+
+          assert (n.named_p ());
+
+          SemanticGraph::Scope& scope (n.scope ());
+
+          if (scope.is_a<SemanticGraph::Namespace> ())
+            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<SemanticGraph::Complex&> (
+              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<SemanticGraph::Type&> (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<Schema&> (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<Sources> ())
+            {
+              if (&i->schema () == &s || sources_p (i->schema (), s))
+                return true;
+            }
+          }
+
+          return false;
+        }
+
+      private:
+        set<String> 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<SemanticGraph::Fundamental::IdRef> ()
+              && !t.is_a<SemanticGraph::Fundamental::IdRefs> ())
+          {
+            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<String> 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 <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/parser/elements.hxx>
+#include <xsd/cxx/parser/options.hxx>
+
+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 <xsd/cxx/tree/counter.hxx>
+
+#include <iostream>
+
+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 <xsd/cxx/tree/elements.hxx>
+#include <xsd/cxx/tree/options.hxx>
+
+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 <xsd/cxx/tree/default-value.hxx>
+
+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<SemanticGraph::Type&> (
+          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<SemanticGraph::Type&> (
+          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<unsigned char> (c - 'A');
+      else if (c >= 'a' && c <= 'z')
+        r = static_cast<unsigned char> (c - 'a' + 26);
+      else if (c >= '0' && c <= '9')
+        r = static_cast<unsigned char> (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<unsigned char> ((b1 << 2) | (b2 >> 4));
+            os.width (2);
+            os << "0x" << v;
+
+            v = static_cast<unsigned char> ((b2 << 4) | (b3 >> 2));
+            os.width (2);
+            os << ", 0x" << v;
+
+            v = static_cast<unsigned char> ((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<unsigned char> ((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<unsigned char> ((b1 << 2) | (b2 >> 4));
+              os.width (2);
+              os << "0x" << v;
+
+              v = static_cast<unsigned char> ((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<unsigned char> ((b1 << 2) | (b2 >> 4));
+            os.width (2);
+            os << "0x" << v;
+
+            v = static_cast<unsigned char> ((b2 << 4) | (b3 >> 2));
+            os.width (2);
+            os << ", 0x" << v;
+
+            v = static_cast<unsigned char> ((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<unsigned char> (c - '0');
+      else if (c >= 'A' && c <= 'F')
+        r = static_cast<unsigned char> (10 + (c - 'A'));
+      else if (c >= 'a' && c <= 'f')
+        r = static_cast<unsigned char> (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<unsigned char> ((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<SemanticGraph::Type&> (
+          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 <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/elements.hxx>
+
+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 <xsd/cxx/tree/elements.hxx>
+
+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<String> ("container");
+        flags_type = xs_name + L"::" + xsc.get<String> ("flags");
+
+        if (ops.generate_element_type ())
+          element_type = xs_name + L"::" + xsc.get<String> ("element-type");
+
+        properties_type = xs_name + L"::" + xsc.get<String> ("properties");
+
+        if (!ops.suppress_parsing () || ops.generate_serialization ())
+        {
+          error_handler_type = xs_name + L"::" +
+            xsc.get<String> ("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<String> ("tree-node-key");
+
+        if (ops.generate_serialization ())
+        {
+          as_double_type_ = xs_name + L"::" +
+            xsc.get<String> ("as-double");
+
+          as_decimal_type_ = xs_name + L"::" +
+            xsc.get<String> ("as-decimal");
+
+          list_stream_type  = xs_name + L"::" +
+            xsc.get<String> ("list-stream");
+
+          namespace_infomap_type  = xs_name + L"::" +
+            xsc.get<String> ("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<wchar_t> (u));
+        }
+      }
+    }
+
+    bool Context::
+    polymorphic_p (SemanticGraph::Type& t)
+    {
+      // IDREF templates cannot be polymorphic.
+      //
+      if (!t.named_p () &&
+          (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+           t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+        return false;
+
+      if (polymorphic_all)
+      {
+        bool fund (false);
+        IsFundamentalType test (fund);
+        test.dispatch (t);
+        return !fund;
+      }
+      else
+        return t.context ().get<bool> ("polymorphic");
+    }
+
+    bool Context::
+    anonymous_substitutes_p (SemanticGraph::Type& t)
+    {
+      // IDREF templates cannot match.
+      //
+      if (!t.named_p () &&
+          (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+           t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+        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<SemanticGraph::Element*> (&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<SemanticGraph::Complex> () &&
+          !b.is_a<SemanticGraph::Enumeration> ();
+      }
+    }
+
+    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<SemanticGraph::Type&> (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<SemanticGraph::Type> () ||
+              (n.is_a<Element> () && generate_p (dynamic_cast<Element&> (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<SemanticGraph::Path> ("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 <map>
+#include <set>
+#include <deque>
+#include <vector>
+#include <sstream>
+
+#include <libcutl/re.hxx>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/elements.hxx>
+
+#include <xsd/cxx/tree/options.hxx>
+
+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<size_t> 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 <typename I>
+      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<String> 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<RegexCustomTypeMapInfo> RegexCustomTypeMap;
+      typedef std::map<String, DirectCustomTypeMapInfo> 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<bool> ("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<String> ("aname");
+      }
+
+      static String const&
+      eaname (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("aname");
+      }
+
+      static String const&
+      eaname (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("aname");
+      }
+
+      // Modifier name.
+      //
+      static String const&
+      emname (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("mname");
+      }
+
+      static String const&
+      emname (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("mname");
+      }
+
+      static String const&
+      emname (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("mname");
+      }
+
+      // Detach name.
+      //
+      static String const&
+      edname (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("dname");
+      }
+
+      //
+      //
+      static String const&
+      etype (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("type");
+      }
+
+      static String const&
+      etraits (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("traits");
+      }
+
+      static String const&
+      econtainer (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("container");
+      }
+
+      static String const&
+      econtainer (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("container");
+      }
+
+      static String const&
+      econtainer (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("container");
+      }
+
+      static String const&
+      eiterator (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("iterator");
+      }
+
+      static String const&
+      eiterator (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("iterator");
+      }
+
+      static String const&
+      eiterator (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("iterator");
+      }
+
+      static String const&
+      econst_iterator (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("const-iterator");
+      }
+
+      static String const&
+      econst_iterator (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("const-iterator");
+      }
+
+      static String const&
+      econst_iterator (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("const-iterator");
+      }
+
+      static String const&
+      emember (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("member");
+      }
+
+      static String const&
+      emember (SemanticGraph::Any const& a)
+      {
+        return a.context ().get<String> ("member");
+      }
+
+      static String const&
+      emember (SemanticGraph::AnyAttribute const& a)
+      {
+        return a.context ().get<String> ("member");
+      }
+
+      static String const&
+      edefault_value (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("default-value");
+      }
+
+      static String const&
+      edefault_value_member (SemanticGraph::Member const& m)
+      {
+        return m.context ().get<String> ("default-value-member");
+      }
+
+      // Underlying enum value type.
+      //
+      static String const&
+      evalue (SemanticGraph::Enumeration const& e)
+      {
+        return e.context ().get<String> ("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<String> ("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<String> ("dom-document-member");
+      }
+
+      // Parsing and serialization function names.
+      //
+      static String const&
+      eparser (SemanticGraph::Element const& e)
+      {
+        return e.context ().get<String> ("parser");
+      }
+
+      static String const&
+      eserializer (SemanticGraph::Element const& e)
+      {
+        return e.context ().get<String> ("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<String> NamespaceStack;
+      typedef std::deque<String> 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<anyType>
+          //
+          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<anyType>
+          //
+          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 <xsd/cxx/tree/" << prefix_ << "/" << file << ">"
+           << 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 <set>
+#include <vector>
+#include <algorithm>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/elements.hxx>
+
+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<String> ("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
+           << "//" <<endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (t, "long long");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::UnsignedLong& t)
+      {
+        built_in_type (t, "unsigned long long");
+        os << endl;
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Integer& t)
+      {
+        os << "// Supposed to be arbitrary-length integral types." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (t, "long long");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
+      {
+        built_in_type (t, "long long");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
+      {
+        built_in_type (t, "unsigned long long");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::PositiveInteger& t)
+      {
+        built_in_type (t, "unsigned long long");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NegativeInteger& t)
+      {
+        built_in_type (t, "long long");
+        os << endl;
+      }
+
+      // Boolean.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::Boolean& t)
+      {
+        os << "// Boolean." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (t, "bool");
+
+        os << endl;
+      }
+
+      // Floats.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::Float& t)
+      {
+        os << "// Floating-point types." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (t, "float");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Double& t)
+      {
+        double_ = built_in_type (t, "double");
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Decimal& t)
+      {
+        decimal_ = built_in_type (t, "double");
+        os << endl;
+      }
+
+
+      // Strings.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::String& t)
+      {
+        os << "// String types." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        string_ = built_in_type (
+          t, L"::xsd::cxx::tree::string< " + char_type + L", ", simple_type_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NormalizedString& t)
+      {
+        norm_string_ = built_in_type (
+          t,
+          L"::xsd::cxx::tree::normalized_string< " + char_type + L", ",
+          string_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Token& t)
+      {
+        token_ = built_in_type (
+          t, L"::xsd::cxx::tree::token< " + char_type + L", ", norm_string_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NameToken& t)
+      {
+        nmtoken_ = built_in_type (
+          t, L"::xsd::cxx::tree::nmtoken< " + char_type + L", ", token_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NameTokens& t)
+      {
+        built_in_type (
+          t,
+          L"::xsd::cxx::tree::nmtokens< " + char_type + L", ",
+          simple_type_,
+          nmtoken_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Name& t)
+      {
+        name_ = built_in_type (
+          t, L"::xsd::cxx::tree::name< " + char_type + L", ", token_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::NCName& t)
+      {
+        ncname_ = built_in_type (
+          t, L"::xsd::cxx::tree::ncname< " + char_type + L", ", name_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::Language& t)
+      {
+        built_in_type (
+          t, L"::xsd::cxx::tree::language< " + char_type + L", ", token_);
+
+        os << endl;
+      }
+
+      // ID/IDREF.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::Id& t)
+      {
+        os << "// ID/IDREF." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (
+          t, L"::xsd::cxx::tree::id< " + char_type + L", ", ncname_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::IdRef& t)
+      {
+        idref_ = built_in_type (
+          t, L"::xsd::cxx::tree::idref< " + char_type + L", ", ncname_, type_);
+      }
+
+      virtual void
+      traverse (SemanticGraph::Fundamental::IdRefs& t)
+      {
+        built_in_type (
+          t,
+          L"::xsd::cxx::tree::idrefs< " + char_type + L", ",
+          simple_type_,
+          idref_);
+
+        os << endl;
+      }
+
+
+      // URI.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::AnyURI& t)
+      {
+        os << "// URI." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        uri_ = built_in_type (
+          t, L"::xsd::cxx::tree::uri< " + char_type + L", ", simple_type_);
+
+        os << endl;
+      }
+
+      // Qualified name.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::QName& t)
+      {
+        os << "// Qualified name." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl;
+
+        built_in_type (
+          t,
+          L"::xsd::cxx::tree::qname< " + char_type + L", ",
+          simple_type_,
+          uri_,
+          ncname_);
+
+        os << endl;
+      }
+
+      // Binary.
+      //
+      virtual void
+      traverse (SemanticGraph::Fundamental::Base64Binary& t)
+      {
+        os << "// Binary." << endl
+           << "//" << endl;
+
+        if (doxygen)
+          os << endl
+             << "/**" << endl
+             << " * @brief Binary buffer type." << endl
+             << " */" << endl;
+
+        gen_typedef (xs_ns ().context().get<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("flags"), "::xsd::cxx::tree::flags");
+
+        if (doxygen)
+          os << endl
+             << "/**" << endl
+             << " * @brief Parsing properties." << endl
+             << " */" << endl;
+
+        gen_typedef (c.get<String> ("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<String> ("severity"),
+                       "::xsd::cxx::tree::severity");
+
+          if (doxygen)
+            os << endl
+               << "/**" << endl
+               << " * @brief Error condition." << endl
+               << " */" << endl;
+
+          gen_typedef (c.get<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> ("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<String> StringSet;
+      typedef std::vector<String> 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 <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+
+#include <libcutl/re.hxx>
+#include <libcutl/shared-ptr.hxx>
+
+#include <libcutl/compiler/code-stream.hxx>
+#include <libcutl/compiler/cxx-indenter.hxx>
+#include <libcutl/compiler/sloc-counter.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/generators/dependencies.hxx>
+
+#include <xsd/version.hxx>
+
+#include <xsd/cxx/tree/generator.hxx>
+
+#include <xsd/cxx/tree/elements.hxx>
+
+#include <xsd/cxx/tree/counter.hxx>
+#include <xsd/cxx/tree/validator.hxx>
+#include <xsd/cxx/tree/name-processor.hxx>
+#include <xsd/cxx/tree/order-processor.hxx>
+#include <xsd/cxx/tree/polymorphism-processor.hxx>
+
+#include <xsd/cxx/tree/tree-forward.hxx>
+#include <xsd/cxx/tree/tree-header.hxx>
+#include <xsd/cxx/tree/tree-inline.hxx>
+#include <xsd/cxx/tree/tree-source.hxx>
+
+#include <xsd/cxx/tree/parser-header.hxx>
+#include <xsd/cxx/tree/parser-source.hxx>
+
+#include <xsd/cxx/tree/stream-header.hxx>
+#include <xsd/cxx/tree/stream-source.hxx>
+
+#include <xsd/cxx/tree/serialization-header.hxx>
+#include <xsd/cxx/tree/serialization-source.hxx>
+
+#include <xsd/cxx/tree/stream-insertion-header.hxx>
+#include <xsd/cxx/tree/stream-insertion-source.hxx>
+#include <xsd/cxx/tree/stream-extraction-source.hxx>
+
+#include <xsd/cxx/tree/options.hxx>
+
+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<Path> Paths;
+    typedef vector<shared_ptr<WideOutputFileStream> > 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<WideOutputFileStream> 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<compiler::cxx_indenter, wchar_t>
+      ind_filter;
+
+      typedef
+      compiler::ostream_filter<compiler::sloc_counter, wchar_t>
+      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 <xsd/cxx/version.hxx>" << endl
+            << endl
+            << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl
+            << "#error XSD runtime version mismatch" << endl
+            << "#endif" << endl
+            << endl;
+
+        fwd << "#include <xsd/cxx/pre.hxx>" << endl
+              << endl;
+
+        // Generate.
+        //
+        {
+          ind_filter ind (fwd); // We don't want to indent prologues/epilogues.
+          generate_forward (ctx);
+        }
+
+        fwd << "#include <xsd/cxx/post.hxx>" << 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 <xsd/cxx/config.hxx>" << endl
+            << endl
+            << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl
+            << "#error XSD runtime version mismatch" << endl
+            << "#endif" << endl
+            << endl;
+
+        hxx << "#include <xsd/cxx/pre.hxx>" << 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 <xsd/cxx/post.hxx>" << 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 <xsd/cxx/pre.hxx>" << endl
+            << endl;
+
+        // Generate.
+        //
+        {
+          ind_filter ind (ixx); // We don't want to indent prologues/epilogues.
+          generate_tree_inline (ctx, 1, 0);
+        }
+
+        ixx << "#include <xsd/cxx/post.hxx>" << 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 <xsd/cxx/pre.hxx>" << 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 <xsd/cxx/post.hxx>" << 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 <libxsd-frontend/semantic-graph/elements.hxx> // Path
+#include <libxsd-frontend/semantic-graph/schema.hxx>
+
+#include <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/literal-map.hxx>
+#include <xsd/cxx/tree/options.hxx>
+
+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 <set>
+#include <map>
+#include <vector>
+#include <sstream>
+#include <iostream>
+
+#include <libcutl/re.hxx>
+
+#include <xsd/cxx/tree/default-value.hxx>
+#include <xsd/cxx/tree/name-processor.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      //
+      //
+      typedef set<String> 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 (<name>,type), three components
+            // (<name>,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 (<name>,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<Regex>
+        {
+          void
+          push_back (String const& r)
+          {
+            vector<Regex>::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<String, NameSet> global_type_names_;
+        map<String, NameSet> 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<String, NameSet>& global_type_names;
+        map<String, NameSet>& 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<String> ("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<SemanticGraph::Complex&> (m.scope ()));
+
+          size_t max (Tree::Context::max (m));
+          size_t min (Tree::Context::min (m));
+
+          String const& s (m.context ().get<String> ("stem"));
+          String const& b (m.context ().get<String> ("name"));
+
+          bool def_attr (m.default_p () &&
+                         m.is_a<SemanticGraph::Attribute> ());
+
+          // 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<SemanticGraph::Element> ())
+            {
+              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<SemanticGraph::Element> () && 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<SemanticGraph::Complex&> (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<String> ("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<NameSet> ("cxx-tree-name-processor-stem-set"));
+
+          NameSet& member_set (
+            ctx.get<NameSet> ("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<SemanticGraph::Complex> () &&
+                !base.is_a<SemanticGraph::Enumeration> ())
+            {
+              if (!base.context ().count (
+                    "cxx-tree-name-processor-member-set"))
+              {
+                dispatch (base);
+              }
+
+              NameSet const& base_stem_set (
+                base.context ().get<NameSet> (
+                  "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<NameSet> (
+                  "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<Complex*> (
+                    &p->inherits ().base ()))
+              {
+                if (mixed_p (*b))
+                {
+                  SemanticGraph::Context& bctx (b->context ());
+                  ctx.set ("mixed-type", bctx.get<String> ("mixed-type"));
+                  ctx.set ("mixed-const-iterator",
+                           bctx.get<String> ("mixed-const-iterator"));
+                  ctx.set ("mixed-ordered-id-name",
+                           bctx.get<String> ("mixed-ordered-id-name"));
+                  ctx.set ("mixed-aname", bctx.get<String> ("mixed-aname"));
+                  ctx.set ("mixed-member", bctx.get<String> ("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<SemanticGraph::Complex*> (
+                      &p->inherits ().base ()))
+                {
+                  if (base->context ().count ("dom-document"))
+                  {
+                    c.context ().set (
+                      "dom-document",
+                      base->context ().get<String> ("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<Complex*> (
+                    &p->inherits ().base ()))
+              {
+                if (ordered_p (*b))
+                {
+                  SemanticGraph::Context& bctx (b->context ());
+                  ctx.set ("order-type", bctx.get<String> ("order-type"));
+                  ctx.set ("order-const-iterator",
+                           bctx.get<String> ("order-const-iterator"));
+                  ctx.set ("order-aname", bctx.get<String> ("order-aname"));
+                  ctx.set ("order-member", bctx.get<String> ("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 <xsd/types.hxx>
+
+#include <xsd/cxx/tree/elements.hxx>
+#include <xsd/cxx/tree/options.hxx>
+
+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 <cstddef>; // std::size_t
+
+include <xsd/types.hxx>; // NarrowString, NarrowStrings
+
+include <xsd/cxx/options.cli>;
+
+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
+      {
+        "<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
+         \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
+      {
+        "<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 content.
+      //
+      NarrowStrings --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 \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
+      {
+        "<type>",
+        "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
+      {
+        "<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 (\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
+      {
+        "<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 (\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"
+      {
+        "<style>",
+        "Specify the type naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{ucc},
+         and \cb{java}. See the NAMING CONVENTION section below for more
+         information."
+      };
+
+      NarrowString --function-naming = "knr"
+      {
+        "<style>",
+        "Specify the function naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{lcc},
+         \cb{ucc}, and \cb{java}. See the NAMING CONVENTION section below
+         for more information."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      NarrowStrings --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."
+      };
+
+      bool --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.
+      //
+      bool --root-element-first
+      {
+        "Treat only the first global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --root-element-last
+      {
+        "Treat only the last global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --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."
+      };
+
+      bool --root-element-none
+      {
+        "Do not treat any global elements as document roots. By default all
+         global elements are considered document roots."
+      };
+
+      NarrowStrings --root-element
+      {
+        "<element>",
+        "Treat only <element> as a document root. Repeat this option to
+         specify more than one root element."
+      };
+
+      // Custom type.
+      //
+      NarrowStrings --custom-type
+      {
+        "<map>",
+        "Use a custom C++ type instead of the generated class. The <map>
+         argument is in the form \c{\i{name}[\b{=}\i{type}[\b{/}\i{base}]]},
+         where \i{name} is a type name as defined in XML Schema and \i{type}
+         is a C++ type name that should be used instead. If \i{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 \i{base} is specified then the generated class is
+         still generated but with that name."
+      };
+
+      NarrowStrings --custom-type-regex
+      {
+        "<regex>",
+        "Use custom C++ types instead of the generated classes. The <regex>
+         argument is in the form
+         \c{\b{/}\i{name-pat}\b{/}[\i{type-sub}\b{/}[\i{base-sub}\b{/}]]},
+         where \i{name-pat} is a regex pattern that will be matched against
+         type names as defined in XML Schema and \i{type-sub} is a C++ type
+         name substitution that should be used instead. If \i{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
+         \i{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.
+      //
+      std::size_t --parts = 1
+      {
+        "<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)."
+      };
+
+      NarrowString --parts-suffix = "-"
+      {
+        "<suffix>",
+        "Use <suffix> instead of the default '\cb{-}' to separate the file
+         name from the part number."
+      };
+    };
+  }
+}
diff --git a/xsd/cxx/tree/order-processor.cxx b/xsd/cxx/tree/order-processor.cxx
new file mode 100644
index 0000000..ccc3dc5
--- /dev/null
+++ b/xsd/cxx/tree/order-processor.cxx
@@ -0,0 +1,243 @@
+// file      : xsde/cxx/tree/order-processor.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <iostream>
+
+#include <xsd/cxx/tree/elements.hxx>
+#include <xsd/cxx/tree/order-processor.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct Member: Traversal::Element, Traversal::Any
+      {
+        Member (size_t count): count_ (count) {}
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (Context::skip (e))
+            return;
+
+          e.context ().set ("ordered-id", count_++);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          a.context ().set ("ordered-id", count_++);
+        }
+
+        size_t count_;
+      };
+
+      //
+      //
+      struct Type: Traversal::Complex
+      {
+        Type (TypeNameSet& ordered_types, bool derived, bool mixed, bool all)
+            : ordered_types_ (ordered_types),
+              derived_ (derived),
+              mixed_ (mixed),
+              all_ (all)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          if (!ctx.count ("ordered"))
+          {
+            // First process our base.
+            //
+            if (c.inherits_p ())
+            {
+              SemanticGraph::Type& b (c.inherits ().base ());
+
+              if (!b.context ().count ("ordered"))
+                dispatch (b);
+            }
+
+            // See if our base (not necessarily immediate) is ordered.
+            //
+            using SemanticGraph::Complex;
+
+            Complex* b (0);
+
+            for (Complex* p (&c); p->inherits_p ();)
+            {
+              if ((b = dynamic_cast<Complex*> (&p->inherits ().base ())))
+              {
+                if (Context::ordered_p (*b))
+                  break;
+
+                p = b;
+              }
+              else
+                break;
+            }
+
+            bool o (all_ ||
+                    (derived_ && b != 0 && Context::ordered_p (*b)) ||
+                    (mixed_ && c.mixed_p ()) ||
+                    ordered_types_.find (c));
+            ctx.set ("ordered", o);
+
+            // Assign ids to elements and wildcards, calculate total count.
+            //
+            if (o)
+            {
+              size_t count (
+                b != 0 && Context::ordered_p (*b)
+                ? b->context ().get<size_t> ("ordered-count")
+                : 1);
+
+              ctx.set ("ordered-start", count);
+
+              Member m (count);
+              Traversal::Names n (m);
+              names (c, n);
+
+              // Assign content id for mixed text.
+              //
+              if (Context::mixed_p (c) && count == 1)
+                ctx.set ("mixed-ordered-id", m.count_++);
+
+              ctx.set ("ordered-count", m.count_);
+            }
+          }
+        }
+
+      private:
+        TypeNameSet& ordered_types_;
+        bool derived_;
+        bool mixed_;
+        bool all_;
+      };
+
+      // 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
+      {
+        Uses (char const* seen_key)
+            : seen_key_ (seen_key)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Sources& sr)
+        {
+          SemanticGraph::Schema& s (sr.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Sources::traverse (sr);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Includes& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Includes::traverse (i);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Imports& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Imports::traverse (i);
+          }
+        }
+
+      private:
+        char const* seen_key_;
+      };
+
+      char const* seen_key = "cxx-tree-order-processor-seen";
+
+      bool
+      process_impl (options const& ops,
+                    SemanticGraph::Schema& tu,
+                    SemanticGraph::Path const&)
+      {
+        // Prepare a set of ordered types.
+        //
+        TypeNameSet ordered_types (ops.ordered_type ().begin (),
+                                   ops.ordered_type ().end ());
+
+        // Root schema in the file-per-type mode is just a bunch
+        // of includes without a namespace.
+        //
+        SemanticGraph::Schema::NamesIterator i (tu.names_begin ());
+
+        // Nothing to do if this is the XML Schema namespace.
+        //
+        if (i == tu.names_end () ||
+            i->named ().name () != L"http://www.w3.org/2001/XMLSchema")
+        {
+          // 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 (seen_key))
+          {
+            Traversal::Schema schema;
+            Uses uses (seen_key);
+
+            schema >> uses >> schema;
+
+            Traversal::Names schema_names;
+            Traversal::Namespace ns;
+            Traversal::Names ns_names;
+            Type type (ordered_types,
+                       ops.ordered_type_derived (),
+                       ops.ordered_type_mixed (),
+                       ops.ordered_type_all ());
+
+            schema >> schema_names >> ns >> ns_names >> type;
+
+            // Some twisted schemas do recusive self-inclusion.
+            //
+            tu.context ().set (seen_key, true);
+
+            schema.dispatch (tu);
+          }
+        }
+
+        return true;
+      }
+    }
+
+    bool OrderProcessor::
+    process (options const& ops,
+             SemanticGraph::Schema& tu,
+             SemanticGraph::Path const& file)
+    {
+      return process_impl (ops, tu, file);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/order-processor.hxx b/xsd/cxx/tree/order-processor.hxx
new file mode 100644
index 0000000..868547d
--- /dev/null
+++ b/xsd/cxx/tree/order-processor.hxx
@@ -0,0 +1,29 @@
+// file      : xsde/cxx/tree/order-processor.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_ORDER_PROCESSOR_HXX
+#define XSD_CXX_TREE_ORDER_PROCESSOR_HXX
+
+#include <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/tree/options.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class OrderProcessor
+    {
+    public:
+      bool
+      process (options const&,
+               XSDFrontend::SemanticGraph::Schema&,
+               XSDFrontend::SemanticGraph::Path const& file);
+    };
+  }
+}
+
+#endif // XSD_CXX_TREE_ORDER_PROCESSOR_HXX
diff --git a/xsd/cxx/tree/parser-header.cxx b/xsd/cxx/tree/parser-header.cxx
new file mode 100644
index 0000000..9ef9e89
--- /dev/null
+++ b/xsd/cxx/tree/parser-header.cxx
@@ -0,0 +1,472 @@
+// file      : xsd/cxx/tree/parser-header.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/parser-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct ElementFunction: Traversal::Element,
+                              GlobalElementBase,
+                              Context
+      {
+        ElementFunction (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          String const& name (eparser (e));
+          String const& error_handler (error_handler_type);
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Parsing functions for the %" <<
+	       comment (e.name ()) << " document root." << endl;
+
+            if (e.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (e.annotation ());
+            }
+
+            os << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+
+          if (!doxygen)
+          {
+            os << "// Parse a URI or a local file." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a URI or a local file." << endl
+               << " *" << endl
+               << " * @param uri A URI or a local file name." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report parsing errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (const " << string_type << "& uri," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a URI or a local file with an error handler." << endl
+               << " *" << endl
+               << " * @param uri A URI or a local file name." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (const " << string_type << "& uri," << endl
+             << error_handler << "& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a URI or a local file with a Xerces-C++ " <<
+              "DOM error" << endl
+               << " * handler." << endl
+               << " *" << endl
+               << " * @param uri A URI or a local file name." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (const " << string_type << "& uri," << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Parse std::istream." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report parsing errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream with an error handler." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << error_handler << "& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream with a " <<
+              "Xerces-C++ DOM error" << endl
+               << " * handler." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream with a resource id." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param id A resource id." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * The resource id is used to identify the document " <<
+              "being parsed in" << endl
+               << " * diagnostics as well as to resolve relative paths." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report parsing errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& id," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream with a resource " <<
+              "id and an" << endl
+               << " * error handler." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param id A resource id." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * The resource id is used to identify the document " <<
+              "being parsed in" << endl
+               << " * diagnostics as well as to resolve relative paths." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& id," << endl
+             << error_handler << "& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a standard input stream with a resource " <<
+              "id and a" << endl
+               << " * Xerces-C++ DOM error handler." << endl
+               << " *" << endl
+               << " * @param is A standrad input stream." << endl
+               << " * @param id A resource id." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * The resource id is used to identify the document " <<
+              "being parsed in" << endl
+               << " * diagnostics as well as to resolve relative paths." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& id," << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Parse xercesc::InputSource." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a Xerces-C++ input source." << endl
+               << " *" << endl
+               << " * @param is A Xerces-C++ input source." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report parsing errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& is," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a Xerces-C++ input source with an " <<
+              "error handler." << endl
+               << " *" << endl
+               << " * @param is A Xerces-C++ input source." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& is," << endl
+             << error_handler << "& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a Xerces-C++ input source with a " <<
+              "Xerces-C++ DOM" << endl
+               << " * error handler." << endl
+               << " *" << endl
+               << " * @param is A Xerces-C++ input source." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function reports parsing errors by calling the " <<
+              "error handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& is," << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Parse xercesc::DOMDocument." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a Xerces-C++ DOM document." << endl
+               << " *" << endl
+               << " * @param d A Xerces-C++ DOM document." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (const " << xerces_ns << "::DOMDocument& d," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Parse a Xerces-C++ DOM document." << endl
+               << " *" << endl
+               << " * @param d A pointer to the Xerces-C++ DOM document." << endl
+               << " * @param f Parsing flags." << endl
+               << " * @param p Parsing properties. " << endl
+               << " * @return A pointer to the root of the object model." << endl
+               << " *" << endl
+               << " * This function is normally used together with the " <<
+              "keep_dom and" << endl
+               << " * own_dom parsing flags to assign ownership of the DOM " <<
+              "document" << endl
+               << " * to the object model." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << auto_ptr << "< " << type_name (e) << " >" << endl
+             << name << " (" << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d," << endl
+             << flags_type << " f = 0," << endl
+             << "const " << properties_type << "& p = " << properties_type << " ());"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+        }
+
+      private:
+        String
+        type_name (Type& e)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (e.type ());
+
+          return o.str ();
+        }
+      };
+    }
+
+
+    void
+    generate_parser_header (Context& ctx)
+    {
+      ctx.os << "#include <iosfwd>" << endl
+             << endl
+             << "#include <xercesc/sax/InputSource.hpp>" << endl
+               << "#include <xercesc/dom/DOMDocument.hpp>" << endl
+             << "#include <xercesc/dom/DOMErrorHandler.hpp>" << endl
+             << endl;
+
+      Traversal::Schema schema;
+      Sources sources;
+      Traversal::Names names_ns, names;
+      Namespace ns (ctx);
+      ElementFunction element (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names >> element;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/parser-header.hxx b/xsd/cxx/tree/parser-header.hxx
new file mode 100644
index 0000000..b7860c4
--- /dev/null
+++ b/xsd/cxx/tree/parser-header.hxx
@@ -0,0 +1,19 @@
+// file      : xsd/cxx/tree/parser-header.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_PARSER_HEADER_HXX
+#define XSD_CXX_TREE_PARSER_HEADER_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_parser_header (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_PARSER_HEADER_HXX
diff --git a/xsd/cxx/tree/parser-source.cxx b/xsd/cxx/tree/parser-source.cxx
new file mode 100644
index 0000000..cee5ea6
--- /dev/null
+++ b/xsd/cxx/tree/parser-source.cxx
@@ -0,0 +1,541 @@
+// file      : xsd/cxx/tree/parser-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/parser-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct ElementFunction: Traversal::Element,
+                              GlobalElementBase,
+                              Context
+      {
+        ElementFunction (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          SemanticGraph::Type& t (e.type ());
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything.
+          //
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          // Check if this element is abstract.
+          //
+          bool abst;
+          {
+            SemanticGraph::Complex* tc;
+            abst = (tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+              tc->abstract_p ();
+          }
+
+          // Nothing to do if we are abstract and not polymorphic.
+          //
+          if (abst && !polymorphic)
+            return;
+
+          String const& name (eparser (e));
+          String type (type_name (e));
+          String const& error_handler (error_handler_type);
+
+          // Note that I am using fq-name in function calls because g++ gets
+          // confused if the name is 'type'. (see tests/schema/anonymous)
+          //
+
+          char const* d (std >= cxx_version::cxx11 ? "std::move (d)" : "d");
+
+          // URI.
+          //
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (const " << string_type << "& u," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << "::xsd::cxx::tree::error_handler< " << char_type << " > h;"
+             << endl
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "u, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "h.throw_if_failed< ::xsd::cxx::tree::parsing< " <<
+            char_type << " > > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (const " << string_type << "& u," << endl
+             << error_handler << "& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "u, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "if (!d.get ())" << endl
+             << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (const " << string_type << "& u," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "u, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "if (!d.get ())" << endl
+             << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+
+          // istream
+          //
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is);"
+             << "return " << fq_name (e, "parser") << " (isrc, f, p);"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << error_handler << "& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is);"
+             << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is);"
+             << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& sid," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is, sid);"
+             << "return " << fq_name (e, "parser") << " (isrc, f, p);"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& sid," << endl
+             << error_handler << "& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0," << endl
+             << "(f & " << flags_type << "::keep_dom) == 0);"
+             << endl
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is, sid);"
+             << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (::std::istream& is," << endl
+             << "const " << string_type << "& sid," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::xml::sax::std_input_source isrc (is, sid);"
+             << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
+             << "}";
+
+
+          // InputSource.
+          //
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& i," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "::xsd::cxx::tree::error_handler< " << char_type << " > h;"
+             << endl
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "i, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "h.throw_if_failed< ::xsd::cxx::tree::parsing< " <<
+            char_type << " > > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& i," << endl
+             << error_handler << "& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "i, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "if (!d.get ())" << endl
+             << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (" << xerces_ns << "::InputSource& i," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
+             << "i, h, p, f";
+
+          if (options.disable_multi_import ())
+            os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
+
+          os << "));"
+             << endl
+             << "if (!d.get ())" << endl
+             << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}";
+
+
+          // DOM.
+          //
+
+          bool fund (false);
+          {
+            IsFundamentalType test (fund);
+            test.dispatch (t);
+          }
+
+          // const DOMDocument&
+          //
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (const " << xerces_ns << "::DOMDocument& doc," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "& p)"
+             << "{"
+             << "if (f & " << flags_type << "::keep_dom)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << "static_cast< " << xerces_ns <<
+            "::DOMDocument* > (doc.cloneNode (true)));"
+             << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
+             << fq_name (e, "parser") << " (" << endl
+             << d << ", f | " << flags_type << "::own_dom, p));"
+             << "}"
+             << "const " << xerces_ns << "::DOMElement& e (*doc.getDocumentElement ());"
+             << "const " << qname_type << " n (" << endl
+             << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
+             << endl;
+
+          if (poly)
+          {
+            os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_().name ()) << "," << endl;
+
+            if (abst)
+              os << "0,";
+            else
+              os << "&::xsd::cxx::tree::factory_impl< " << type << " >,";
+
+            os << endl
+               << "true, true, e, n, f, 0));"
+               << endl
+               << "if (tmp.get () != 0)"
+               << "{"
+               << auto_ptr << "< " << type << " > r (" << endl
+               << "dynamic_cast< " << type << "* > (tmp.get ()));"
+               << endl
+               << "if (r.get ())" << endl
+               << "tmp.release ();"
+               << "else" << endl
+               << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+              " > ();"
+               << endl;
+          }
+          else
+          {
+            os << "if (n.name () == " << strlit (e.name ()) << " &&" << endl
+               << "n.namespace_ () == " << strlit (e.namespace_().name ()) << ")"
+               << "{";
+
+            if (fund)
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << "new " << type << " (" << endl
+                 << "::xsd::cxx::tree::traits< " << type << ", " <<
+                char_type;
+
+              if (t.is_a<SemanticGraph::Fundamental::Double> ())
+                os << ", ::xsd::cxx::tree::schema_type::double_";
+              else if (t.is_a<SemanticGraph::Fundamental::Decimal> ())
+                os << ", ::xsd::cxx::tree::schema_type::decimal";
+
+              os << " >::create (" << endl
+                 << "e, f, 0)));";
+            }
+            else
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << "::xsd::cxx::tree::traits< " << type << ", " <<
+                char_type << " >::create (" << endl
+                 << "e, f, 0));";
+            }
+          }
+
+          os << "return r;"
+             << "}"
+             << "throw ::xsd::cxx::tree::unexpected_element < " <<
+            char_type << " > (" << endl
+             << "n.name ()," << endl
+             << "n.namespace_ ()," << endl
+             << strlit (e.name ()) << "," << endl
+             << strlit (e.namespace_().name ()) << ");"
+             << "}";
+
+
+          // dom::auto_ptr/unique_ptr<DOMDocument>
+          //
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (" << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d," << endl
+             << flags_type << " f," << endl
+             << "const " << properties_type << "&)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > c (" << endl
+             << "((f & " << flags_type << "::keep_dom) &&" << endl
+             << "!(f & " << flags_type << "::own_dom))" << endl
+             << "? static_cast< " << xerces_ns << "::DOMDocument* > (" <<
+            "d->cloneNode (true))" << endl
+             << ": 0);"
+             << endl
+             << xerces_ns << "::DOMDocument& doc (c.get () ? *c : *d);"
+             << "const " << xerces_ns << "::DOMElement& e (" <<
+            "*doc.getDocumentElement ());"
+             << endl
+             << "const " << qname_type << " n (" << endl
+             << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
+             << endl
+             << "if (f & " << flags_type << "::keep_dom)" << endl
+             << "doc.setUserData (" << dom_node_key << "," << endl
+             << "(c.get () ? &c : &d)," << endl
+             << "0);"
+             << endl;
+
+          if (poly)
+          {
+            os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_().name ()) << "," << endl;
+
+            if (abst)
+              os << "0,";
+            else
+              os << "&::xsd::cxx::tree::factory_impl< " << type << " >,";
+
+            os << endl
+               << "true, true, e, n, f, 0));"
+               << endl
+               << "if (tmp.get () != 0)"
+               << "{";
+          }
+          else
+          {
+            os << "if (n.name () == " << strlit (e.name ()) << " &&" << endl
+               << "n.namespace_ () == " << strlit (e.namespace_().name ()) << ")"
+               << "{";
+
+            if (fund)
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << "new " << type << " (" << endl
+                 << "::xsd::cxx::tree::traits< " << type << ", " <<
+                char_type;
+
+              if (t.is_a<SemanticGraph::Fundamental::Double> ())
+                os << ", ::xsd::cxx::tree::schema_type::double_";
+              else if (t.is_a<SemanticGraph::Fundamental::Decimal> ())
+                os << ", ::xsd::cxx::tree::schema_type::decimal";
+
+              os << " >::create (" << endl
+                 << "e, f, 0)));";
+            }
+            else
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << "::xsd::cxx::tree::traits< " << type << ", " <<
+                char_type << " >::create (" << endl
+                 << "e, f, 0));";
+            }
+          }
+
+          if (poly)
+          {
+            os << endl
+               << auto_ptr << "< " << type << " > r (" << endl
+               << "dynamic_cast< " << type << "* > (tmp.get ()));"
+               << endl
+               << "if (r.get ())" << endl
+               << "tmp.release ();"
+               << "else" << endl
+               << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+              " > ();"
+               << endl;
+          }
+
+          os << "return r;"
+             << "}"
+             << "throw ::xsd::cxx::tree::unexpected_element < " <<
+            char_type << " > (" << endl
+             << "n.name ()," << endl
+             << "n.namespace_ ()," << endl
+             << strlit (e.name ()) << "," << endl
+             << strlit (e.namespace_().name ()) << ");"
+             << "}";
+        }
+
+      private:
+        String
+        type_name (Type& e)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (e.type ());
+
+          return o.str ();
+        }
+      };
+    }
+
+    void
+    generate_parser_source (Context& ctx, size_t first, size_t last)
+    {
+      ctx.os << "#include <istream>" << endl
+             << "#include <xsd/cxx/xml/sax/std-input-source.hxx>" << endl
+             << "#include <xsd/cxx/tree/error-handler.hxx>" << endl
+             << endl;
+
+      Traversal::Schema schema;
+      Sources sources;
+      Traversal::Names names_ns, names;
+      Namespace ns (ctx, first, last);
+      ElementFunction element (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names >> element;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/parser-source.hxx b/xsd/cxx/tree/parser-source.hxx
new file mode 100644
index 0000000..1bb70d9
--- /dev/null
+++ b/xsd/cxx/tree/parser-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/parser-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_PARSER_SOURCE_HXX
+#define XSD_CXX_TREE_PARSER_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_parser_source (Context&, size_t first, size_t last);
+  }
+}
+
+#endif  // XSD_CXX_TREE_PARSER_SOURCE_HXX
diff --git a/xsd/cxx/tree/polymorphism-processor.cxx b/xsd/cxx/tree/polymorphism-processor.cxx
new file mode 100644
index 0000000..4d07c69
--- /dev/null
+++ b/xsd/cxx/tree/polymorphism-processor.cxx
@@ -0,0 +1,740 @@
+// file      : xsde/cxx/tree/polymorphism-processor.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <iostream>
+
+#include <xsd/cxx/tree/elements.hxx>
+#include <xsd/cxx/tree/polymorphism-processor.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      //
+      //
+      struct Type: Traversal::Type,
+                   Traversal::Complex
+      {
+        Type (TypeNameSet& poly_types)
+            : poly_types_ (poly_types)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Type& t)
+        {
+          SemanticGraph::Context& ctx (t.context ());
+
+          if (!ctx.count ("polymorphic"))
+            ctx.set ("polymorphic", poly_types_.find (t));
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          if (!ctx.count ("polymorphic"))
+          {
+            // First check our base.
+            //
+            bool pb (false);
+            if (c.inherits_p ())
+            {
+              SemanticGraph::Type& b (c.inherits ().base ());
+
+              if (!b.context ().count ("polymorphic"))
+                dispatch (b);
+
+              pb = b.context ().get<bool> ("polymorphic");
+            }
+
+            ctx.set ("polymorphic", pb || poly_types_.find (c));
+          }
+        }
+
+      private:
+        TypeNameSet& poly_types_;
+      };
+
+      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
+      {
+        FundType (TypeNameSet& poly_types, bool& valid)
+            : poly_types_ (poly_types), valid_ (valid)
+        {
+        }
+
+        void
+        check (SemanticGraph::Type& t, bool fund)
+        {
+          SemanticGraph::Context& ctx (t.context ());
+
+          if (poly_types_.find (t))
+          {
+            if (!fund)
+              ctx.set ("polymorphic", true);
+            else
+            {
+              wcerr << "error: built-in type '" << t.name () << "' cannot "
+                    << "be polymorphic because it is mapped to a fundamental "
+                    << "C++ type"
+                    << endl;
+
+              valid_ = false;
+            }
+          }
+          else
+            ctx.set ("polymorphic", false);
+        }
+
+        // anyType & anySimpleType.
+        //
+        virtual void
+        traverse (SemanticGraph::AnyType& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnySimpleType& t)
+        {
+          check (t, false);
+        }
+
+        // Boolean.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Boolean& t)
+        {
+          check (t, true);
+        }
+
+        // Integral types.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Byte& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::UnsignedByte& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Short& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::UnsignedShort& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Int& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::UnsignedInt& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Long& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::UnsignedLong& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Integer& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::PositiveInteger& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NegativeInteger& t)
+        {
+          check (t, true);
+        }
+
+        // Floats.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Float& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Double& t)
+        {
+          check (t, true);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Decimal& t)
+        {
+          check (t, true);
+        }
+
+        // Strings.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::String& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NormalizedString& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Token& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NameToken& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NameTokens& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Name& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::NCName& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Language& t)
+        {
+          check (t, false);
+        }
+
+
+        // Qualified name.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::QName& t)
+        {
+          check (t, false);
+        }
+
+
+        // ID/IDREF.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Id& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::IdRef& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::IdRefs& t)
+        {
+          check (t, false);
+        }
+
+        // URI.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::AnyURI& t)
+        {
+          check (t, false);
+        }
+
+        // Binary.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Base64Binary& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::HexBinary& t)
+        {
+          check (t, false);
+        }
+
+
+        // Date/time.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Date& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::DateTime& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Duration& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Day& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Month& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::MonthDay& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Year& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::YearMonth& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Time& t)
+        {
+          check (t, false);
+        }
+
+        // Entity.
+        //
+        virtual void
+        traverse (SemanticGraph::Fundamental::Entity& t)
+        {
+          check (t, false);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Entities& t)
+        {
+          check (t, false);
+        }
+
+      private:
+        TypeNameSet& poly_types_;
+        bool& valid_;
+      };
+
+      struct GlobalElement: Traversal::Element
+      {
+        GlobalElement (TypeNameSet& poly_types,
+                       bool& valid,
+                       const WarningSet& disabled_warnings)
+            : poly_types_ (poly_types), valid_ (valid), warning_ (true)
+        {
+          if (disabled_warnings.find ("all") != disabled_warnings.end () ||
+              disabled_warnings.find ("T005") != disabled_warnings.end ())
+            warning_ = false;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          using SemanticGraph::Schema;
+
+          if (!e.substitutes_p ())
+            return;
+
+          // If we are a substitution for some element, then mark
+          // that element's type as polymorphic.
+          //
+          Type& r (e.substitutes ().root ());
+          SemanticGraph::Type& rt (r.type ());
+          SemanticGraph::Context& ctx (rt.context ());
+
+          // We may need to override the previous value.
+          //
+          if (ctx.count ("polymorphic") && ctx.get<bool> ("polymorphic"))
+            return;
+
+          // Built-in types that are mapped to fundamental types cannot
+          // be declared polymorphic.
+          //
+          bool fund (false);
+          IsFundamentalType test (fund);
+          test.dispatch (rt);
+
+          if (fund)
+          {
+            wcerr << r.file () << ":" << r.line () << ":" << r.column ()
+                  << ": error: built-in type '" << rt.name () << "' "
+                  << "is mapped to a fundamental C++ type and is expected "
+                  << "to be polymorphic" << endl;
+
+            wcerr << e.file () << ":" << e.line () << ":" << e.column ()
+                  << ": info: because type '" << rt.name () << "' is "
+                  << "used in a substitution group declared here" << endl;
+
+            valid_ = false;
+            return;
+          }
+
+          ctx.set ("polymorphic", true);
+
+          if (!warning_)
+            return;
+
+          Schema& es (dynamic_cast<Schema&> (e.scope ().scope ()));
+          Schema& rts (dynamic_cast<Schema&> (rt.scope ().scope ()));
+
+          // If the root type and this element are in different schemas
+          // and the root type is not explicitly marked as polymorphic,
+          // then issue a warning.
+          //
+          if (&es != &rts && !sources_p (es, rts) && !poly_types_.find (rt))
+          {
+            wcerr << rt.file () << ":" << rt.line () << ":" << rt.column ()
+                  << ": warning T005: assuming type '" << rt.name () << "' "
+                  << "is polymorphic" << endl;
+
+            wcerr << e.file () << ":" << e.line () << ":" << e.column ()
+                  << ": info: because type '" << rt.name () << "' is "
+                  << "used in a substitution group declared here" << endl;
+
+            wcerr << rt.file () << ":" << rt.line () << ":" << rt.column ()
+                  << ": info: use --polymorphic-type to indicate this type "
+                  << "is polymorphic when compiling schemas that "
+                  << "reference it" << endl;
+          }
+        }
+
+      private:
+        // 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<Sources> ())
+            {
+              if (&i->schema () == &s || sources_p (i->schema (), s))
+                return true;
+            }
+          }
+
+          return false;
+        }
+
+      private:
+        TypeNameSet& poly_types_;
+        bool& valid_;
+        bool warning_;
+      };
+
+      // 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
+      {
+        Uses (char const* seen_key)
+            : seen_key_ (seen_key)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Sources& sr)
+        {
+          SemanticGraph::Schema& s (sr.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Sources::traverse (sr);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Includes& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Includes::traverse (i);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Imports& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Imports::traverse (i);
+          }
+        }
+
+      private:
+        char const* seen_key_;
+      };
+
+      char const* pass_one_key = "cxx-tree-polymorphism-processor-seen-one";
+      char const* pass_two_key = "cxx-tree-polymorphism-processor-seen-two";
+
+      bool
+      process_impl (options const& ops,
+                    SemanticGraph::Schema& tu,
+                    SemanticGraph::Path const&,
+                    const WarningSet& disabled_warnings)
+      {
+        bool valid (true);
+
+        // Prepare a set of polymorphic types.
+        //
+
+        TypeNameSet poly_types (ops.polymorphic_type ().begin (),
+                                ops.polymorphic_type ().end ());
+
+        // Root schema in the file-per-type mode is just a bunch
+        // of includes without a namespace.
+        //
+        SemanticGraph::Schema::NamesIterator i (tu.names_begin ());
+
+        if (i != tu.names_end () &&
+            i->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 (poly_types, valid);
+
+          schema >> schema_names >> ns >> ns_names >> fund_type;
+
+          schema.dispatch (tu);
+        }
+        else
+        {
+          // First handle fundamental types.
+          //
+          {
+            Traversal::Schema schema;
+            Traversal::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 (poly_types, valid);
+
+            xs_schema >> xs_schema_names >> ns >> ns_names >> fund_type;
+
+            schema.dispatch (tu);
+          }
+
+          // 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 (pass_two_key))
+          {
+            // Pass one - check substitution groups.
+            //
+            if (valid)
+            {
+              Traversal::Schema schema;
+              Uses uses (pass_one_key);
+
+              schema >> uses >> schema;
+
+              Traversal::Names schema_names;
+              Traversal::Namespace ns;
+              Traversal::Names ns_names;
+              GlobalElement element (poly_types, valid, disabled_warnings);
+
+              schema >> schema_names >> ns >> ns_names >> element;
+
+              // Some twisted schemas do recusive self-inclusion.
+              //
+              tu.context ().set (pass_one_key, true);
+
+              schema.dispatch (tu);
+            }
+
+            // Pass two - process types.
+            //
+            if (valid)
+            {
+              Traversal::Schema schema;
+              Uses uses (pass_two_key);
+
+              schema >> uses >> schema;
+
+              Traversal::Names schema_names;
+              Traversal::Namespace ns;
+              Traversal::Names ns_names;
+              Type type (poly_types);
+
+              schema >> schema_names >> ns >> ns_names >> type;
+
+              // Some twisted schemas do recusive self-inclusion.
+              //
+              tu.context ().set (pass_two_key, true);
+
+              schema.dispatch (tu);
+            }
+          }
+        }
+
+        return valid;
+      }
+    }
+
+    bool PolymorphismProcessor::
+    process (options const& ops,
+             SemanticGraph::Schema& tu,
+             SemanticGraph::Path const& file,
+             const WarningSet& disabled_warnings)
+    {
+      return process_impl (ops, tu, file, disabled_warnings);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/polymorphism-processor.hxx b/xsd/cxx/tree/polymorphism-processor.hxx
new file mode 100644
index 0000000..88019a8
--- /dev/null
+++ b/xsd/cxx/tree/polymorphism-processor.hxx
@@ -0,0 +1,30 @@
+// file      : xsde/cxx/tree/polymorphism-processor.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_POLYMORPHISM_PROCESSOR_HXX
+#define XSD_CXX_TREE_POLYMORPHISM_PROCESSOR_HXX
+
+#include <libxsd-frontend/semantic-graph.hxx>
+
+#include <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/tree/options.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class PolymorphismProcessor
+    {
+    public:
+      bool
+      process (options const&,
+               XSDFrontend::SemanticGraph::Schema&,
+               XSDFrontend::SemanticGraph::Path const& file,
+               const WarningSet& disabled_warnings);
+    };
+  }
+}
+
+#endif // XSD_CXX_TREE_POLYMORPHISM_PROCESSOR_HXX
diff --git a/xsd/cxx/tree/serialization-header.cxx b/xsd/cxx/tree/serialization-header.cxx
new file mode 100644
index 0000000..5434441
--- /dev/null
+++ b/xsd/cxx/tree/serialization-header.cxx
@@ -0,0 +1,579 @@
+// file      : xsd/cxx/tree/serialization-header.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/serialization-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (list_stream)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << list_stream_type << "&," << endl
+             << "const " << name << "&);"
+             << endl;
+
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (list_stream)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << list_stream_type << "&," << endl
+             << "const " << name << "&);"
+             << endl;
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          // operator<< (list_stream)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << list_stream_type << "&," << endl
+             << "const " << name << "&);"
+             << endl;
+        }
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << inst_exp
+             << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement&, " <<
+            "const " << name << "&);"
+             << endl;
+
+          bool simple (true);
+          {
+            IsSimpleType t (simple);
+            t.dispatch (c);
+          }
+
+          if (simple)
+          {
+            // operator<< (xercesc::DOMAttr)
+            //
+            os << inst_exp
+               << "void" << endl
+               << "operator<< (" << xerces_ns << "::DOMAttr&, " <<
+              "const " << name << "&);"
+               << endl;
+
+            // operator<< (list_stream)
+            //
+            os << inst_exp
+               << "void" << endl
+               << "operator<< (" << list_stream_type << "&," << endl
+               << "const " << name << "&);"
+               << endl;
+          }
+        }
+      };
+
+      struct ElementType: Traversal::Element,
+                          GlobalElementBase,
+                          Context
+      {
+        ElementType (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (doc_root_p (e))
+          {
+            // operator<< (xercesc::DOMElement)
+            //
+            os << inst_exp
+               << "void" << endl
+               << "operator<< (" << xerces_ns << "::DOMElement&, " <<
+              "const " << ename (e) << "&);"
+               << endl;
+          }
+        }
+      };
+
+      struct ElementFunction: Traversal::Element,
+                              GlobalElementBase,
+                              Context
+      {
+        ElementFunction (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          String const& name (eserializer (e));
+          String const& error_handler (error_handler_type);
+          String const& namespace_infomap (namespace_infomap_type);
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Serialization functions for the %" <<
+	       comment (e.name ()) << " document root." << endl;
+
+            if (e.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (e.annotation ());
+            }
+
+            os << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+
+          if (!doxygen)
+          {
+            os << "// Serialize to std::ostream." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a standard output stream." << endl
+               << " *" << endl
+               << " * @param os A standrad output stream." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report " <<
+              "serialization errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (::std::ostream& os," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a standard output stream with an " <<
+              "error handler." << endl
+               << " *" << endl
+               << " * @param os A standrad output stream." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function reports serialization errors by " <<
+              "calling the error" << endl
+               << " * handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (::std::ostream& os," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << error_handler << "& eh," << endl
+             << "const " << namespace_infomap << "& m = "  <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a standard output stream with a " <<
+              "Xerces-C++ DOM" << endl
+               << " * error handler." << endl
+               << " *" << endl
+               << " * @param os A standrad output stream." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function reports serialization errors by " <<
+              "calling the error" << endl
+               << " * handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (::std::ostream& os," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Serialize to xercesc::XMLFormatTarget." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a Xerces-C++ XML format target." << endl
+               << " *" << endl
+               << " * @param ft A Xerces-C++ XML format target." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function uses exceptions to report " <<
+              "serialization errors." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& ft," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a Xerces-C++ XML format target " <<
+              "with an error" << endl
+               << " * handler." << endl
+               << " *" << endl
+               << " * @param ft A Xerces-C++ XML format target." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param eh An error handler." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function reports serialization errors by " <<
+              "calling the error" << endl
+               << " * handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& ft," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << error_handler << "& eh," << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a Xerces-C++ XML format target " <<
+              "with a" << endl
+               << " * Xerces-C++ DOM error handler." << endl
+               << " *" << endl
+               << " * @param ft A Xerces-C++ XML format target." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param eh A Xerces-C++ DOM error handler." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param e A character encoding to produce XML in." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * This function reports serialization errors by " <<
+              "calling the error" << endl
+               << " * handler." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& ft," << endl
+             << "const " << type_name (e) << "& x, " << endl
+             << xerces_ns << "::DOMErrorHandler& eh," << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << "const " << string_type << "& e = " << L << "\"UTF-8\"," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Serialize to an existing xercesc::DOMDocument." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to an existing Xerces-C++ DOM document." << endl
+               << " *" << endl
+               << " * @param d A Xerces-C++ DOM document." << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param f Serialization flags." << endl
+               << " *" << endl
+               << " * Note that it is your responsibility to create the " <<
+              "DOM document" << endl
+               << " * with the correct root element as well as set the " <<
+              "necessary" << endl
+               << " * namespace mapping attributes." << endl
+               << " */" << endl;
+          }
+          os << inst_exp
+             << "void" << endl
+             << name << " (" << xerces_ns << "::DOMDocument& d," << endl
+             << "const " << type_name (e) << "& x," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (!doxygen)
+          {
+            os << "// Serialize to a new xercesc::DOMDocument." << endl
+               << "//" << endl
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Serialize to a new Xerces-C++ DOM document." << endl
+               << " *" << endl
+               << " * @param x An object model to serialize." << endl
+               << " * @param m A namespace information map." << endl
+               << " * @param f Serialization flags." << endl
+               << " * @return A pointer to the new Xerces-C++ DOM document." << endl
+               << " */" << endl;
+          }
+
+          os << inst_exp
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument >" << endl
+             << name << " (const " << type_name (e) << "& x, " << endl
+             << "const " << namespace_infomap << "& m = " <<
+            namespace_infomap << " ()," << endl
+             << flags_type << " f = 0);"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+        }
+
+      private:
+        String
+        type_name (Type& e)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (e.type ());
+
+          return o.str ();
+        }
+      };
+
+    }
+
+    void
+    generate_serialization_header (Context& ctx)
+    {
+      bool elemen_type (ctx.options.generate_element_type ());
+
+      if (!elemen_type)
+        ctx.os << "#include <iosfwd>" << endl
+               << endl
+               << "#include <xercesc/dom/DOMDocument.hpp>" << endl
+               << "#include <xercesc/dom/DOMErrorHandler.hpp>" << endl
+               << "#include <xercesc/framework/XMLFormatter.hpp>" << endl
+               << endl
+               << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl
+               << endl;
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+      ElementType element_type (ctx);
+      ElementFunction element_function (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      if (elemen_type)
+        names >> element_type;
+      else
+        names >> element_function;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/serialization-header.hxx b/xsd/cxx/tree/serialization-header.hxx
new file mode 100644
index 0000000..08c58ab
--- /dev/null
+++ b/xsd/cxx/tree/serialization-header.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/serialization-header.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_SERIALIZATION_HEADER_HXX
+#define XSD_CXX_TREE_SERIALIZATION_HEADER_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_serialization_header (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_SERIALIZATION_HEADER_HXX
diff --git a/xsd/cxx/tree/serialization-source.cxx b/xsd/cxx/tree/serialization-source.cxx
new file mode 100644
index 0000000..08b81d6
--- /dev/null
+++ b/xsd/cxx/tree/serialization-source.cxx
@@ -0,0 +1,1499 @@
+// file      : xsd/cxx/tree/serialization-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/serialization-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      enum schema_type
+      {
+        st_other,
+        st_double,
+        st_decimal
+      };
+
+      enum schema_type
+      schema_type (SemanticGraph::Type& t)
+      {
+        if (t.is_a<SemanticGraph::Fundamental::Double> ())
+          return st_double;
+        else if (t.is_a<SemanticGraph::Fundamental::Decimal> ())
+          return st_decimal;
+        else
+          return st_other;
+      }
+
+
+      //
+      //
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String base (L"::xsd::cxx::tree::list< " +
+                       item_type_name (item_type) + L", " + char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base += L" >";
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement& e, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "e << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr& a, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "a << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // operator<< (list_stream)
+          //
+          os << "void" << endl
+             << "operator<< (" << list_stream_type << "& l," << endl
+             << "const " << name << "& i)"
+             << "{"
+             << "l << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
+          //
+          if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (l));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_type_serializer_init (" << endl
+               << strlit (l.name ()) << "," << endl
+               << strlit (xml_ns_name (l)) << ");"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          String const& base (xs_string_type);
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement& e, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "e << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr& a, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "a << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // operator<< (list_stream)
+          //
+          os << "void" << endl
+             << "operator<< (" << list_stream_type << "& l," << endl
+             << "const " << name << "& i)"
+             << "{"
+             << "l << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
+          //
+          if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (u));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_type_serializer_init (" << endl
+               << strlit (u.name ()) << "," << endl
+               << strlit (xml_ns_name (u)) << ");"
+               << endl
+               << endl;
+          }
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_base_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement& e, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "e << static_cast< const ";
+
+          inherits (e, inherits_base_);
+
+          os << "& > (i);"
+             << "}";
+
+
+          // operator<< (xercesc::DOMAttr)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMAttr& a, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "a << static_cast< const ";
+
+          inherits (e, inherits_base_);
+
+          os << "& > (i);"
+             << "}";
+
+
+          // operator<< (list_stream)
+          //
+          os << "void" << endl
+             << "operator<< (" << list_stream_type << "& l," << endl
+             << "const " << name << "& i)"
+             << "{"
+             << "l << static_cast< const ";
+
+          inherits (e, inherits_base_);
+
+          os << "& > (i);"
+             << "}";
+
+
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
+          //
+          if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (e));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_type_serializer_init (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (xml_ns_name (e)) << ");"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_;
+      };
+
+      struct Element: Traversal::Element, Context
+      {
+        Element (Context& c, String const& scope_)
+            : Context (c), scope (scope_)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e))
+            return;
+
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (e.scope ()));
+
+          bool ordered (ordered_p (c));
+
+          String const& aname (eaname (e));
+          String ns (e.qualified_p () ? e.namespace_ ().name () : "");
+          String type (scope + L"::" + etype (e));
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything. Note that if the type is anonymous then it can't be
+          // derived from which makes it impossible to substitute or
+          // dynamically-type with xsi:type.
+          //
+          SemanticGraph::Type& t (e.type ());
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          os << "// " << comment (e.name ()) << endl
+             << "//" << endl;
+
+          if (ordered)
+            os << "case " << scope << "::" <<
+              e.context ().get<String> ("ordered-id-name") << ":"
+               << "{";
+
+          if (poly)
+          {
+            os << (ordered ? "" : "{")
+               << "::xsd::cxx::tree::type_serializer_map< " << char_type
+               << " >& tsm (" << endl
+               << "::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
+               << endl;
+          }
+
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+            // Always pass the sequence element reference to typeid() to
+            // suppress the Clang's 'expression with side effects will be
+            // evaluated despite being used as an operand to typeid' warning.
+            //
+            if (ordered)
+              os << "const " << type << "& x (i." << aname <<
+                " ()[b->index]);"
+                 << endl;
+            else
+              os << "for (" << scope << "::" << econst_iterator (e) << endl
+                 << "b (i." << aname << " ().begin ()), " <<
+                "n (i." << aname << " ().end ());" << endl
+                 << "b != n; ++b)"
+                 << "{"
+                 << "const " << type << "& x (*b);" << endl;
+
+            if (poly)
+            {
+              os << "if (typeid (" << type << ") == typeid (x))"
+                 << "{"
+                 << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl
+                 << "s << x;"
+                 << "}"
+                 << "else" << endl
+                 << "tsm.serialize (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (ns) << "," << endl
+                 << (e.global_p () ? "true" : "false") << ", " <<
+                (e.qualified_p () ? "true" : "false") << ", e, x);";
+            }
+            else
+            {
+              os << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl;
+
+              switch (schema_type (t))
+              {
+              case st_other:
+                {
+                  os << "s << x;";
+                  break;
+                }
+              case st_double:
+                {
+                  os << "s << " << as_double_type << " (x);";
+                  break;
+                }
+              case st_decimal:
+                {
+                  os << "s << " << as_decimal_type << " (x);";
+                  break;
+                }
+              }
+            }
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            if (!ordered)
+              os << "if (i." << aname << " ())"
+                 << "{";
+
+            if (poly)
+            {
+              os << "const " << type << "& x (*i." << aname << " ());"
+                 << "if (typeid (" << type << ") == typeid (x))"
+                 << "{"
+                 << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl
+                 << "s << x;"
+                 << "}"
+                 << "else" << endl
+                 << "tsm.serialize (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (ns) << "," << endl
+                 << (e.global_p () ? "true" : "false") << ", " <<
+                (e.qualified_p () ? "true" : "false") << ", e, x);";
+            }
+            else
+            {
+              os << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl;
+
+              switch (schema_type (t))
+              {
+              case st_other:
+                {
+                  os << "s << *i." << aname << " ();";
+                  break;
+                }
+              case st_double:
+                {
+                  os << "s << " << as_double_type << "(*i." << aname << " ());";
+                  break;
+                }
+              case st_decimal:
+                {
+                  os << "s << " << as_decimal_type << "(*i." << aname << " ());";
+                  break;
+                }
+              }
+            }
+          }
+          else
+          {
+            // one
+            //
+            if (poly)
+            {
+              os << "const " << type << "& x (i." << aname << " ());"
+                 << "if (typeid (" << type << ") == typeid (x))"
+                 << "{"
+                 << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl
+                 << "s << x;"
+                 << "}"
+                 << "else" << endl
+                 << "tsm.serialize (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (ns) << "," << endl
+                 << (e.global_p () ? "true" : "false") << ", " <<
+                (e.qualified_p () ? "true" : "false") << ", e, x);";
+            }
+            else
+            {
+              if (!ordered)
+                os << "{";
+
+              os << xerces_ns << "::DOMElement& s (" << endl
+                 << "::xsd::cxx::xml::dom::create_element (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << (ns ? strlit (ns) + L",\n" : L"")
+                 << "e));"
+                 << endl;
+
+              switch (schema_type (t))
+              {
+              case st_other:
+                {
+                  os << "s << i." << aname << " ();";
+                  break;
+                }
+              case st_double:
+                {
+                  os << "s << " << as_double_type << "(i." << aname << " ());";
+                  break;
+                }
+              case st_decimal:
+                {
+                  os << "s << " << as_decimal_type << "(i." << aname << " ());";
+                  break;
+                }
+              }
+            }
+          }
+
+          if (ordered)
+          {
+            // See comment for bool text (false); below.
+            //
+            if (mixed_p (c) && c.context ().get<size_t> ("ordered-start") != 1)
+              os << "text = true;";
+
+            os << "continue;"
+               << "}";
+          }
+          else
+          {
+            os << "}";
+
+            if (poly && (max (e) != 1 || min (e) == 0))
+              os << "}"; // There is no extra block for poly one.
+          }
+        }
+
+      private:
+        String scope;
+      };
+
+      struct Any: Traversal::Any, Context
+      {
+        Any (Context& c, String const& scope_)
+            : Context (c), scope (scope_)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          bool ordered (ordered_p (c));
+
+          String const& aname (eaname (a));
+
+          os << "// " << ename (a) << endl
+             << "//" << endl;
+
+          if (ordered)
+            os << "case " << scope << "::" <<
+              a.context ().get<String> ("ordered-id-name") << ":";
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            if (!ordered)
+              os << "for (" << scope << "::" << econst_iterator (a) << endl
+                 << "b (i." << aname << " ().begin ()), " <<
+                "n (i." << aname << " ().end ());" << endl
+                 << "b != n; ++b)";
+
+            os << "{"
+               << "e.appendChild (" << endl
+               << "e.getOwnerDocument ()->importNode (" << endl
+               << "const_cast< " << xerces_ns <<
+              "::DOMElement* > (&(" <<
+              (ordered ? (L"i." + aname + L" ()[b->index]") : L"*b") <<
+              ")), true));";
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            if (!ordered)
+              os << "if (i." << aname << " ())";
+
+            os << "{"
+               << "e.appendChild (" << endl
+               << "e.getOwnerDocument ()->importNode (" << endl
+               << "const_cast< " << xerces_ns << "::DOMElement* > (&(*i." <<
+              aname << " ())), true));";
+          }
+          else
+          {
+            // one
+            //
+            if (ordered)
+              os << "{";
+
+            os << "e.appendChild (" << endl
+               << "e.getOwnerDocument ()->importNode (" << endl
+               << "const_cast< " << xerces_ns << "::DOMElement* > (&(i." <<
+              aname << " ())), true));"
+               << endl;
+          }
+
+          if (ordered)
+          {
+            // See comment for bool text (false); below.
+            //
+            if (mixed_p (c) && c.context ().get<size_t> ("ordered-start") != 1)
+              os << "text = true;";
+
+            os << "continue;";
+          }
+
+          if (ordered || max (a) != 1 || min (a) == 0)
+            os << "}";
+        }
+
+      private:
+        String scope;
+      };
+
+      struct Attribute: Traversal::Attribute, Context
+      {
+        Attribute (Context& c, String const& scope_)
+            : Context (c), scope (scope_)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& aname (eaname (a));
+          String ns (a.qualified_p () ? a.namespace_ ().name () : "");
+
+          os << "// " << comment (a.name ()) << endl
+             << "//" << endl;
+
+          if (a.optional_p () && !a.default_p ())
+          {
+            os << "if (i." << aname << " ())"
+               << "{"
+               << xerces_ns << "::DOMAttr& a (" << endl
+               << "::xsd::cxx::xml::dom::create_attribute (" << endl
+               << strlit (a.name ()) << "," << endl
+               << (ns ? strlit (ns) + L",\n" : L"")
+               << "e));"
+               << endl;
+
+            switch (schema_type (a.type ()))
+            {
+            case st_other:
+              {
+                os << "a << *i." << aname << " ();";
+                break;
+              }
+            case st_double:
+              {
+                os << "a << " << as_double_type << "(*i." << aname << " ());";
+                break;
+              }
+            case st_decimal:
+              {
+                os << "a << " << as_decimal_type << "(*i." << aname << " ());";
+                break;
+              }
+            }
+
+            os << "}";
+          }
+          else
+          {
+            // Make sure we serialize required fixed attributes.
+            //
+            if (a.optional_p () && options.omit_default_attributes ())
+            {
+              os << "if (i." << aname << " () != " << scope <<
+                "::" << edefault_value (a) << " ())";
+            }
+
+            os << "{"
+               << xerces_ns << "::DOMAttr& a (" << endl
+               << "::xsd::cxx::xml::dom::create_attribute (" << endl
+               << strlit (a.name ()) << "," << endl
+               << (ns ? strlit (ns) + L",\n" : L"")
+               << "e));"
+               << endl;
+
+            switch (schema_type (a.type ()))
+            {
+            case st_other:
+              {
+                os << "a << i." << aname << " ();";
+                break;
+              }
+            case st_double:
+              {
+                os << "a << " << as_double_type << "(i." << aname << " ());";
+                break;
+              }
+            case st_decimal:
+              {
+                os << "a << " << as_decimal_type << "(i." << aname << " ());";
+                break;
+              }
+            }
+
+            os << "}";
+          }
+        }
+
+      private:
+        String scope;
+      };
+
+      struct AnyAttribute: Traversal::AnyAttribute, Context
+      {
+        AnyAttribute (Context& c, String const& scope_)
+            : Context (c), scope (scope_)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& aname (eaname (a));
+
+          os << "// " << ename (a) << endl
+             << "//" << endl;
+
+          os << "for (" << scope << "::" << econst_iterator (a) << endl
+             << "b (i." << aname << " ().begin ()), " <<
+            "n (i." << aname << " ().end ());" << endl
+             << "b != n; ++b)"
+             << "{"
+             << xerces_ns << "::DOMAttr* a (" << endl
+             << "static_cast< " << xerces_ns << "::DOMAttr* > (" << endl
+             << "e.getOwnerDocument ()->importNode (" << endl
+             << "const_cast< " << xerces_ns << "::DOMAttr* > (&(*b)), true)));"
+             << endl
+             << "if (a->getLocalName () == 0)" << endl
+             << "e.setAttributeNode (a);"
+             << "else" << endl
+             << "e.setAttributeNodeNS (a);"
+             << "}";
+        }
+
+      private:
+        String scope;
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          // operator<< (xercesc::DOMElement)
+          //
+          os << "void" << endl
+             << "operator<< (" << xerces_ns << "::DOMElement& e, " <<
+            "const " << name << "& i)"
+             << "{";
+
+          if (c.inherits_p ())
+          {
+            os << "e << static_cast< const ";
+            inherits (c, inherits_);
+            os << "& > (i);"
+               << endl;
+          }
+          else
+            os << "e << static_cast< const " << any_type << "& > (i);"
+               << endl;
+
+          // Serialize anyAttribute content first so that is gets
+          // overriden by schema-defined attributes.
+          //
+          if (options.generate_wildcard ())
+          {
+            AnyAttribute any_attribute (*this, name);
+            Traversal::Names names (any_attribute);
+
+            Complex::names (c, names);
+          }
+
+          {
+            bool o (ordered_p (c));
+            size_t start (0), count (0);
+
+            if (o)
+            {
+              start = ctx.get<size_t> ("ordered-start");
+              count = ctx.get<size_t> ("ordered-count");
+
+              if (start != count)
+              {
+                String const& ci (ctx.get<String> ("order-const-iterator"));
+                String const& an (ctx.get<String> ("order-aname"));
+
+                // If we have mixed content and a base, then we have to
+                // skip the text content until we serialize one of "our"
+                // elements.
+                //
+                if (mixed_p (c) && start != 1)
+                  os << "bool text (false);"
+                     << endl;
+
+                os << "for (" << name << "::" << ci << endl
+                   << "b (i." << an << " ().begin ()), n (i." << an <<
+                  " ().end ());" << endl
+                   << "b != n; ++b)"
+                   << "{"
+                   << "switch (b->id)"
+                   << "{";
+              }
+            }
+
+            Traversal::Names names;
+            Any any (*this, name);
+            Element element (*this, name);
+
+            names >> element;
+
+            if (options.generate_wildcard ())
+              names >> any;
+
+            Complex::names (c, names);
+
+            if (o)
+            {
+              if (start != count)
+              {
+                if (mixed_p (c))
+                {
+                  //@@ propagate mixed-ordered-id to derived
+
+                  os << "// text_content" << endl
+                     << "//" << endl
+                     << "case " << name << "::" <<
+                    ctx.get<String> ("mixed-ordered-id-name") << ":"
+                     << "{";
+
+                  // See the comment above.
+                  //
+                  if (start != 1)
+                    os << "if (text)" << endl;
+
+                  os << "e.appendChild (" << endl
+                     << "e.getOwnerDocument ()->createTextNode (" << endl
+                     << "::xsd::cxx::xml::string (" << endl
+                     << "i." << ctx.get<String> ("mixed-aname") <<
+                    " ()[b->index].c_str ()).c_str ()));";
+
+                  // os << "e << i." << ctx.get<String> ("mixed-aname") <<
+                  //  " ()[b->index];";
+
+                  os << "continue;"
+                     << "}";
+                }
+
+                // Ignore content before our id range and stop serializing
+                // if we see anything past. This handles inheritance.
+                //
+                os << "default:"
+                   << "{";
+
+                if (start != 1)
+                  os << "if (b->id < " << start << "UL)" << endl
+                     << "continue;";
+
+                os << "break;" // Stop (see break below).
+                   << "}";
+
+                os << "}"      // switch
+                   << "break;" // Unknown element past our elements.
+                   << "}";     // for
+              }
+            }
+          }
+
+          {
+            Attribute attribute (*this, name);
+            Traversal::Names names (attribute);
+            Complex::names (c, names);
+          }
+
+          os << "}";
+
+          bool simple (true);
+          {
+            IsSimpleType t (simple);
+            t.dispatch (c);
+          }
+
+          if (simple)
+          {
+            bool hb (c.inherits_p ());
+
+            // operator<< (xercesc::DOMAttr)
+            //
+            os << "void" << endl
+               << "operator<< (" << xerces_ns << "::DOMAttr&" <<
+              (hb ? " a" : "") << ", " <<
+              "const " << name << "&" << (hb ? " i" : "") << ")"
+               << "{";
+
+            if (hb)
+            {
+              os << "a << static_cast< const ";
+
+              inherits (c, inherits_);
+
+              os << "& > (i);";
+            }
+
+            os << "}";
+
+
+            // operator<< (list_stream)
+            //
+            os << "void" << endl
+               << "operator<< (" << list_stream_type << "&" <<
+              (hb ? " l" : "") << "," << endl
+               << "const " << name << "&" << (hb ? " i" : "") << ")"
+               << "{";
+
+            if (hb)
+            {
+              os << "l << static_cast< const ";
+
+              inherits (c, inherits_);
+
+              os << "& > (i);";
+            }
+
+            os << "}";
+          }
+
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
+          //
+          if (polymorphic &&
+              polymorphic_p (c) &&
+              !c.abstract_p () &&
+              !anonymous_p (c))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (c));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_type_serializer_init (" << endl
+               << strlit (c.name ()) << "," << endl
+               << strlit (xml_ns_name (c)) << ");"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_;
+        BaseTypeName base_;
+      };
+
+
+      // Generate substitution group map entry.
+      //
+      struct GlobalElement: Traversal::Element,
+                            GlobalElementBase,
+                            Context
+      {
+        GlobalElement (Context& c)
+            : GlobalElementBase (c), Context (c), type_name_ (c)
+        {
+          belongs_ >> type_name_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          // Similar to parsing, we cannot just omit this element if it's
+          // abstract because it may serve as a "link" between the root of the
+          // substitution group and a non-abstract element that uses this
+          // element as its root (see
+          // element_serializer_map::find_substitution() for details).
+          //
+          if (polymorphic && e.substitutes_p ())
+          {
+            SemanticGraph::Type& t (e.type ());
+
+            // Check if this element is abstract.
+            //
+            bool abst;
+            {
+              SemanticGraph::Complex* tc;
+              abst = (tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+                tc->abstract_p ();
+            }
+
+            Type& r (e.substitutes ().root ());
+
+            String const& name (ename (e));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::element_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", ";
+
+            belongs (e, belongs_);
+
+            os << " >" << endl
+               << "_xsd_" << name << "_element_serializer_init (" << endl
+               << strlit (r.name ()) << "," << endl
+               << strlit (r.namespace_ ().name ()) << "," << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_ ().name ()) << "," << endl;
+
+            if (abst)
+              os << "0";
+            else
+            {
+              os << "&::xsd::cxx::tree::serializer_impl< ";
+              belongs (e, belongs_);
+              os << " >";
+            }
+
+            os << ");"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Belongs belongs_;
+        MemberTypeName type_name_;
+
+      };
+
+      struct ElementType: Traversal::Element,
+                          GlobalElementBase,
+                          Context
+      {
+        ElementType (Context& c)
+            : GlobalElementBase (c),
+              Context (c),
+              element_map_ (c.options.generate_element_map ())
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (doc_root_p (e))
+          {
+            String const& name (ename (e));
+
+            // operator<< (xercesc::DOMElement)
+            //
+            os << "void" << endl
+               << "operator<< (" << xerces_ns << "::DOMElement& e, " <<
+              "const " << name << "& i)"
+               << "{"
+               << "e << i." << eaname (e) << " ();"
+               << "}";
+
+            // Element map registration.
+            //
+            if (element_map_)
+            {
+              SemanticGraph::Context& ec (e.context ());
+              String const& aname (ec.get<String> ("element-name"));
+              String const& ans (ec.get<String> ("element-ns"));
+
+              os << "static " << endl
+                 << "const ::xsd::cxx::tree::serializer_init< " <<
+                name << ", " << char_type << ", " << any_type << " >" << endl
+                 << "_xsd_" << name << "_serializer_init (" <<
+                name << "::" << aname << " (), " <<
+                name << "::" << ans << " ());"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        bool element_map_;
+      };
+
+      struct ElementFunction: Traversal::Element,
+                              GlobalElementBase,
+                              Context
+      {
+        ElementFunction (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          String const& name (eserializer (e));
+          String ns (e.namespace_ ().name ());
+          String const& error_handler (error_handler_type);
+          String const& namespace_infomap (namespace_infomap_type);
+
+          SemanticGraph::Type& type (e.type ());
+
+          // Note that I am using fq-name in function calls because g++ gets
+          // confused if the name is 'type'. (see tests/schema/anonymous)
+          //
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything.
+          //
+          bool poly (polymorphic &&
+                        polymorphic_p (type) &&
+                        !anonymous_p (type));
+
+          // To std::ostream.
+          //
+          os << "void" << endl
+             << name << " (::std::ostream& o," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0);"
+             << endl
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << endl
+             << "::xsd::cxx::tree::error_handler< " << char_type << " > h;"
+             << endl
+             << "::xsd::cxx::xml::dom::ostream_format_target t (o);"
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "h.throw_if_failed< ::xsd::cxx::tree::serialization< " <<
+            char_type << " > > ();"
+             << "}"
+             << "}";
+
+          os << "void" << endl
+             << name << " (::std::ostream& o," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << error_handler << "& h," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << "::xsd::cxx::xml::auto_initializer i (" << endl
+             << "(f & " << flags_type << "::dont_initialize) == 0);"
+             << endl
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << "::xsd::cxx::xml::dom::ostream_format_target t (o);"
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "throw ::xsd::cxx::tree::serialization< " <<
+            char_type << " > ();"
+             << "}"
+             << "}";
+
+          os << "void" << endl
+             << name << " (::std::ostream& o," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << "::xsd::cxx::xml::dom::ostream_format_target t (o);"
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "throw ::xsd::cxx::tree::serialization< " <<
+            char_type << " > ();"
+             << "}"
+             << "}";
+
+          // To XMLFormatTarget.
+          //
+          os << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& t," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << endl
+             << "::xsd::cxx::tree::error_handler< " << char_type << " > h;"
+             << endl
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "h.throw_if_failed< ::xsd::cxx::tree::serialization< " <<
+            char_type << " > > ();"
+             << "}"
+             << "}";
+
+          os << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& t," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << error_handler << "& h," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "throw ::xsd::cxx::tree::serialization< " <<
+            char_type << " > ();"
+             << "}"
+             << "}";
+
+          os << "void" << endl
+             << name << " (" << xerces_ns << "::XMLFormatTarget& t," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << xerces_ns << "::DOMErrorHandler& h," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << "const " << string_type << "& e," << endl
+             << flags_type << " f)"
+             << "{"
+             << dom_auto_ptr << "< " << xerces_ns <<
+            "::DOMDocument > d (" << endl
+             << fq_name (e, "serializer") << " (s, m, f));"
+             << "if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))"
+             << "{"
+             << "throw ::xsd::cxx::tree::serialization< " <<
+            char_type << " > ();"
+             << "}"
+             << "}";
+
+          // To an existing DOM instance.
+          //
+          os << "void" << endl
+             << name << " (" << xerces_ns << "::DOMDocument& d," << endl
+             << "const " << type_name (e) << "& s," << endl
+             << flags_type << ")"
+             << "{"
+             << xerces_ns << "::DOMElement& e (*d.getDocumentElement ());"
+             << "const " << qname_type << " n (" << endl
+             << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
+             << endl;
+
+          if (poly)
+          {
+            os << "if (typeid (" << type_name (e) << ") == typeid (s))"
+               << "{";
+          }
+
+          os << "if (n.name () == " << strlit (e.name ()) << " &&" << endl
+             << "n.namespace_ () == " << strlit (ns) << ")"
+             << "{";
+
+          switch (schema_type (type))
+          {
+          case st_other:
+            {
+              os << "e << s;";
+              break;
+            }
+          case st_double:
+            {
+              os << "e << " << as_double_type << "(s);";
+              break;
+            }
+          case st_decimal:
+            {
+              os << "e << " << as_decimal_type << "(s);";
+              break;
+            }
+          }
+
+          os << "}"
+             << "else"
+             << "{"
+             << "throw ::xsd::cxx::tree::unexpected_element < " <<
+            char_type << " > (" << endl
+             << "n.name ()," << endl
+             << "n.namespace_ ()," << endl
+             << strlit (e.name ()) << "," << endl
+             << strlit (ns) << ");"
+             << "}";
+
+          if (poly)
+          {
+            os << "}"
+               << "else"
+               << "{"
+               << "::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().serialize (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_().name ()) << "," << endl
+               << "e, n, s);"
+               << "}";
+          }
+
+          os << "}";
+
+
+          // To a new DOM instance.
+          //
+          os << dom_auto_ptr << "< " << xerces_ns << "::DOMDocument >" << endl
+             << name << " (const " << type_name (e) << "& s," << endl
+             << "const " << namespace_infomap << "& m," << endl
+             << flags_type << " f)"
+             << "{";
+
+          if (poly)
+          {
+            os << dom_auto_ptr << "< " << xerces_ns << "::DOMDocument > d;"
+               << endl
+               << "if (typeid (" << type_name (e) << ") == typeid (s))"
+               << "{"
+               << "d = ::xsd::cxx::xml::dom::serialize< " <<
+              char_type << " > (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (ns) << "," << endl
+               << "m, f);"
+               << "}"
+               << "else"
+               << "{"
+               << "d = ::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().serialize (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_().name ()) << "," << endl
+               << "m, s, f);"
+               << "}";
+          }
+          else
+          {
+            os << dom_auto_ptr << "< " << xerces_ns <<
+              "::DOMDocument > d (" << endl
+               << "::xsd::cxx::xml::dom::serialize< " <<
+              char_type << " > (" << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (ns) << "," << endl
+               << "m, f));"
+               << endl;
+          }
+
+          os << fq_name (e, "serializer") << " (*d, s, f);"
+             << "return d;"
+             << "}";
+
+        }
+
+      private:
+        String
+        type_name (Type& e)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (e.type ());
+
+          return o.str ();
+        }
+      };
+    }
+
+    void
+    generate_serialization_source (Context& ctx, size_t first, size_t last)
+    {
+      bool elemen_type (ctx.options.generate_element_type ());
+
+      if (!elemen_type)
+        ctx.os << "#include <ostream>" << endl
+               << "#include <xsd/cxx/tree/error-handler.hxx>" << endl;
+
+      ctx.os << "#include <xsd/cxx/xml/dom/serialization-source.hxx>" << endl
+             << endl;
+
+      if (ctx.polymorphic)
+      {
+        ctx.os << "#include <xsd/cxx/tree/type-serializer-map.hxx>" << endl
+               << 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 tree"
+                 << "{"
+                 << "#ifdef _MSC_VER" << endl;
+
+          if (export_maps)
+            ctx.os << "template struct __declspec (dllexport) " <<
+              "type_serializer_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
+
+          if (import_maps)
+            ctx.os << "template struct __declspec (dllimport) " <<
+              "type_serializer_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
+
+          ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
+                 << "template struct __attribute__ ((visibility(\"default\"))) " <<
+            "type_serializer_plate< " << ctx.poly_plate << ", " <<
+            ctx.char_type << " >;";
+
+          ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl
+                 << "template struct XSD_MAP_VISIBILITY " <<
+            "type_serializer_plate< " << ctx.poly_plate << ", " <<
+            ctx.char_type << " >;";
+
+          ctx.os << "#endif" << endl
+                 << "}"  // tree
+                 << "}"  // cxx
+                 << "}"  // xsd
+                 << "#endif // XSD_NO_EXPORT" << endl
+                 << endl;
+        }
+
+        ctx.os << "namespace _xsd"
+               << "{"
+               << "static" << endl
+               << "const ::xsd::cxx::tree::type_serializer_plate< " <<
+                ctx.poly_plate << ", " << ctx.char_type << " >" << endl
+               << "type_serializer_plate_init;"
+               << "}";
+      }
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx, first, last);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+      GlobalElement element (ctx);
+      ElementType element_type (ctx);
+      ElementFunction element_function (ctx);
+
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+      names >> element;
+
+      if (elemen_type)
+        names >> element_type;
+      else
+        names >> element_function;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/serialization-source.hxx b/xsd/cxx/tree/serialization-source.hxx
new file mode 100644
index 0000000..75e57f3
--- /dev/null
+++ b/xsd/cxx/tree/serialization-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/serialization-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_SERIALIZATION_SOURCE_HXX
+#define XSD_CXX_TREE_SERIALIZATION_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_serialization_source (Context&, size_t first, size_t last);
+  }
+}
+
+#endif  // XSD_CXX_TREE_SERIALIZATION_SOURCE_HXX
diff --git a/xsd/cxx/tree/stream-extraction-source.cxx b/xsd/cxx/tree/stream-extraction-source.cxx
new file mode 100644
index 0000000..5a5ed66
--- /dev/null
+++ b/xsd/cxx/tree/stream-extraction-source.cxx
@@ -0,0 +1,864 @@
+// file      : xsd/cxx/tree/stream-extraction-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/stream-extraction-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String base (L"::xsd::cxx::tree::list< " +
+                       item_type_name (item_type) + L", " + char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base += L" >";
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ());
+               i != st.end (); ++i)
+          {
+            os << name << "::" << endl
+               << name << " (" << istream_type << "< " <<
+              i->c_str () << " >& s," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << any_simple_type << " (s, f, c)," << endl
+               << "  " << base <<  " (s, f, this)"
+               << "{"
+               << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (l) &&
+                (!anonymous_p (l) || anonymous_substitutes_p (l)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (l));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_extraction_init_" <<
+                n++ << " (" << endl
+                 << strlit (l.name ()) << "," << endl
+                 << strlit (xml_ns_name (l)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          String const& base (xs_string_type);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            os << name << "::" << endl
+               << name << " (" << istream_type << "< " <<
+              i->c_str () << " >& s," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (s, f, c)"
+               << "{"
+               << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (u) &&
+                (!anonymous_p (u) || anonymous_substitutes_p (u)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (u));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_extraction_init_" <<
+                n++ << " (" << endl
+                 << strlit (u.name ()) << "," << endl
+                 << strlit (xml_ns_name (u)) << ");"
+                 << endl;
+            }
+          }
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_base_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* base_enum (0);
+            IsEnumBasedType t (base_enum);
+            t.dispatch (e);
+
+            enum_based = (base_enum != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            os << name << "::" << endl
+               << name << " (" << istream_type << "< " <<
+              i->c_str () << " >& s," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": ";
+
+            inherits (e, inherits_base_);
+
+            if (string_based && !enum_based)
+            {
+              // Use copy c-tor to pass the flags and container.
+              //
+              os << " (" << endl;
+              inherits (e, inherits_base_);
+              os << " (_xsd_" << name << "_literals_[s.read_uint ()]), f, c)";
+            }
+            else
+              os << " (s, f, c)";
+
+            os << "{";
+
+            if (string_based)
+              os << "_xsd_" << name << "_convert ();";
+
+            os << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (e) &&
+                (!anonymous_p (e) || anonymous_substitutes_p (e)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (e));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_extraction_init_" <<
+                n++ << " (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (xml_ns_name (e)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_;
+      };
+
+      struct CtorMember: Traversal::Member, Context
+      {
+        CtorMember (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          if (skip (m))
+            return;
+
+          os << "," << endl
+             << "  " << emember (m) << " (this)";
+        }
+      };
+
+      struct CtorAny: Traversal::Any,
+                      Traversal::AnyAttribute,
+                      Context
+      {
+        CtorAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+      };
+
+      struct Element: Traversal::Element, Context
+      {
+        Element (Context& c, String const& stream_)
+            : Context (c), stream (stream_)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e))
+            return;
+
+          String const& member (emember (e));
+
+          SemanticGraph::Type& t (e.type ());
+          String type (etype (e));
+          String tr (etraits (e)); // traits type name
+
+          bool fund (false);
+          {
+            IsFundamentalType traverser (fund);
+            traverser.dispatch (t);
+          }
+
+          // Figure out if we need to generate polymorphic code. If this
+          // elemen's type is anonymous then we don't need to do anything.
+          // Note that if the type is anonymous then it can't be derived
+          // from which makes it impossible to substitute or dynamically-
+          // type with xsi:type.
+          //
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          // Check if this element is abstract.
+          //
+          bool abst (false);
+          if (poly)
+          {
+            SemanticGraph::Complex* tc;
+            abst = (tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+              tc->abstract_p ();
+          }
+
+          char const* r (
+            (poly || !fund) && std >= cxx_version::cxx11
+            ? "::std::move (r)"
+            : "r");
+
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+            String container (econtainer (e));
+
+            os << "{"
+               << "::std::size_t n;"
+               << "::xsd::cxx::tree::istream_common::as_size< " <<
+              "::std::size_t > as (n);"
+               << "s >> as;"
+               << "if (n > 0)"
+               << "{"
+               << container << "& c (this->" << member << ");"
+               << "c.reserve (n);"
+               << "while (n--)"
+               << "{";
+
+            if (poly)
+            {
+              os << auto_ptr << "< " << type << " > r;";
+
+              if (!abst)
+                os << "bool d;"
+                   << "s >> d;"
+                   << endl
+                   << "if (!d)" << endl
+                   << "r.reset (new " << type << " (s, f, this));"
+                   << "else"
+                   << "{";
+
+              os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
+                 << "s, f, this));"
+                 << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
+                 << "if (r.get ())" << endl
+                 << "tmp.release ();"
+                 << "else" << endl
+                 << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+                " > ();";
+
+              if (!abst)
+                os << "}";
+            }
+            else if (fund)
+            {
+              os << type << " r;"
+                 << "s >> r;";
+            }
+            else
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
+            }
+
+            os << "c.push_back (" << r << ");"
+               << "}" // while
+               << "}" // if
+               << "}";
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            os << "{"
+               << "bool p;"
+               << "s >> p;"
+               << "if (p)"
+               << "{";
+
+            if (poly)
+            {
+              os << auto_ptr << "< " << type << " > r;";
+
+              if (!abst)
+                os << "bool d;"
+                   << "s >> d;"
+                   << endl
+                   << "if (!d)" << endl
+                   << "r.reset (new " << type << " (s, f, this));"
+                   << "else"
+                   << "{";
+
+              os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
+                 << "s, f, this));"
+                 << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
+                 << "if (r.get ())" << endl
+                 << "tmp.release ();"
+                 << "else" << endl
+                 << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+                " > ();";
+
+              if (!abst)
+                os << "}";
+            }
+            else if (fund)
+            {
+              os << type << " r;"
+                 << "s >> r;";
+            }
+            else
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
+            }
+
+            os << "this->" << member << ".set (" << r << ");"
+               << "}" // if (p)
+               << "}";
+          }
+          else
+          {
+            // one
+            //
+            os << "{";
+
+            if (poly)
+            {
+              os << auto_ptr << "< " << type << " > r;";
+
+              if (!abst)
+                os << "bool d;"
+                   << "s >> d;"
+                   << endl
+                   << "if (!d)" << endl
+                   << "r.reset (new " << type << " (s, f, this));"
+                   << "else"
+                   << "{";
+
+              os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
+                 << "s, f, this));"
+                 << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
+                 << "if (r.get ())" << endl
+                 << "tmp.release ();"
+                 << "else" << endl
+                 << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+                " > ();";
+
+              if (!abst)
+                os << "}";
+            }
+            else if (fund)
+            {
+              os << type << " r;"
+                 << "s >> r;";
+            }
+            else
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
+            }
+
+            os << "this->" << member << ".set (" << r << ");"
+               << "}";
+          }
+        }
+
+      private:
+        String stream;
+      };
+
+      struct Attribute: Traversal::Attribute, Context
+      {
+        Attribute (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& member (emember (a));
+          String type (etype (a));
+          String tr (etraits (a)); // traits type name
+
+          bool fund (false);
+          {
+            IsFundamentalType traverser (fund);
+            traverser.dispatch (a.type ());
+          }
+
+          if (a.optional_p () && !a.default_p ())
+          {
+            os << "{"
+               << "bool p;"
+               << "s >> p;"
+               << "if (p)"
+               << "{";
+
+            if (fund)
+            {
+              os << type << " r;"
+                 << "s >> r;"
+                 << "this->" << member << ".set (r);";
+            }
+            else
+            {
+              os << "this->" << member << ".set (" << tr <<
+                "::create (s, f, this));";
+            }
+
+            os << "}" // if (p)
+               << "}";
+          }
+          else
+          {
+            os << "{";
+
+            if (fund)
+            {
+              os << type << " r;"
+                 << "s >> r;"
+                 << "this->" << member << ".set (r);";
+            }
+            else
+            {
+              os << "this->" << member << ".set (" << tr <<
+                "::create (s, f, this));";
+            }
+
+            os << "}";
+          }
+        }
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c), base_ (c), ctor_any_ (c), ctor_member_ (c)
+        {
+          inherits_ >> base_;
+          names_ctor_member_ >> ctor_member_;
+
+          if (options.generate_wildcard ())
+            names_ctor_member_ >> ctor_any_;
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+          bool has_members (has<Traversal::Member> (c));
+
+          bool facets (false);
+          if (c.inherits_p ())
+          {
+            // See if we have any facets that we need to handle.
+            //
+            using SemanticGraph::Restricts;
+            using SemanticGraph::Fundamental::Decimal;
+
+            if (Restricts* r = dynamic_cast<Restricts*> (&c.inherits ()))
+            {
+              if (!r->facet_empty () &&
+                  (r->facet_find ("fractionDigits") != r->facet_end () ||
+                   r->facet_find ("totalDigits") != r->facet_end ()) &&
+                  ultimate_base (c).is_a<Decimal> ())
+                facets = true;
+            }
+          }
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            os << name << "::" << endl
+               << name << " (" << istream_type << "< " <<
+              i->c_str () << " >& s," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": ";
+
+            if (c.inherits_p ())
+              inherits (c, inherits_);
+            else
+              os << any_type;
+
+            os << " (s, f, c)";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            names (c, names_ctor_member_);
+
+            os << "{";
+
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);"
+                 << endl;
+
+            if (has_members)
+              os << "this->" << unclash (name, "parse") << " (s, f);";
+
+            os << "}";
+
+            // Parse
+            //
+            if (ordered || has_members)
+            {
+              os << "void " << name << "::" << endl
+                 << unclash (name, "parse") << " (" <<
+                istream_type << "< " << i->c_str () << " >& s," << endl
+                 << flags_type << " f)"
+                 << "{"
+                 << "XSD_UNUSED (f);"; // Can be unused.
+
+              // Read the order sequence.
+              //
+              if (ordered)
+              {
+                String const& t (ctx.get<String> ("order-type"));
+                String const& m (ctx.get<String> ("order-member"));
+
+                os << "{"
+                   << "::std::size_t n;"
+                   << "::xsd::cxx::tree::istream_common::as_size< " <<
+                  "::std::size_t > na (n);"
+                   << "s >> na;"
+                   << "if (n > 0)"
+                   << "{"
+                   << "this->" << m << ".reserve (n);"
+                   << "while (n--)"
+                   << "{"
+                   << "::std::size_t id, in;"
+                   << "::xsd::cxx::tree::istream_common::as_size< " <<
+                  "::std::size_t > ida (id), ina (in);"
+                   << "s >> ida;"
+                   << "s >> ina;"
+                   << "this->" << m << ".push_back (" << t << " (id, in));"
+                   << "}" // while
+                   << "}" // if
+                   << "}";
+              }
+
+              {
+                Element element (*this, *i);
+                Attribute attribute (*this);
+                Traversal::Names names_;
+
+                names_ >> element;
+                names_ >> attribute;
+
+                names (c, names_);
+              }
+
+              os << "}";
+            }
+
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (c) &&
+                !c.abstract_p () &&
+                (!anonymous_p (c) || anonymous_substitutes_p (c)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (c));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_extraction_init_" <<
+                n++ << " (" << endl
+                 << strlit (c.name ()) << "," << endl
+                 << strlit (xml_ns_name (c)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_;
+        BaseTypeName base_;
+
+        CtorAny ctor_any_;
+        CtorMember ctor_member_;
+
+        Traversal::Names names_ctor_member_;
+      };
+    }
+
+    void
+    generate_stream_extraction_source (Context& ctx)
+    {
+      if (ctx.polymorphic)
+      {
+        NarrowStrings const& st (ctx.options.generate_extraction ());
+
+        ctx.os << "#include <xsd/cxx/tree/stream-extraction-map.hxx>" << endl
+               << 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 tree"
+                 << "{";
+
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream (*i);
+
+            ctx.os << "#ifdef _MSC_VER" << endl;
+
+            if (export_maps)
+              ctx.os << "template struct __declspec (dllexport) " <<
+                "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
+
+            if (import_maps)
+              ctx.os << "template struct __declspec (dllimport) " <<
+                "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
+
+            ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
+                   << "template struct __attribute__ ((visibility(\"default\"))) " <<
+              "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
+                   << "#elif defined(XSD_MAP_VISIBILITY)" << endl
+                   << "template struct XSD_MAP_VISIBILITY " <<
+              "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
+                   << "#endif" << endl;
+          }
+
+          ctx.os << "}"  // tree
+                 << "}"  // cxx
+                 << "}"  // xsd
+                 << "#endif // XSD_NO_EXPORT" << endl
+                 << endl;
+
+        }
+
+        ctx.os << "namespace _xsd"
+               << "{";
+
+        size_t n (0);
+        for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+             ++i)
+        {
+          String stream (*i);
+
+          ctx.os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_plate< " <<
+            ctx.poly_plate << ", " << stream << ", " << ctx.char_type <<
+            " >" << endl
+                 << "stream_extraction_plate_init_" << n++ << ";";
+        }
+
+        ctx.os << "}";
+      }
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/stream-extraction-source.hxx b/xsd/cxx/tree/stream-extraction-source.hxx
new file mode 100644
index 0000000..8b58491
--- /dev/null
+++ b/xsd/cxx/tree/stream-extraction-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/stream-extraction-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_EXTRACTION_SOURCE_HXX
+#define XSD_CXX_TREE_EXTRACTION_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_stream_extraction_source (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_EXTRACTION_SOURCE_HXX
diff --git a/xsd/cxx/tree/stream-header.cxx b/xsd/cxx/tree/stream-header.cxx
new file mode 100644
index 0000000..c8243c9
--- /dev/null
+++ b/xsd/cxx/tree/stream-header.cxx
@@ -0,0 +1,181 @@
+// file      : xsd/cxx/tree/stream-header.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/stream-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          os << inst_exp
+             << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "&, const " <<
+            name << "&);"
+             << endl;
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          os << inst_exp
+             << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "&, const " <<
+            name << "&);"
+             << endl;
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* be (0);
+            IsEnumBasedType t (be);
+            t.dispatch (e);
+
+            enum_based = (be != 0);
+          }
+
+          // If we are based on an enum then the value type is just an
+          // alias and we don't need to generate this operator again.
+          //
+          if (string_based && !enum_based)
+          {
+            os << inst_exp
+               << std_ostream_type << "&" << endl
+               << "operator<< (" << std_ostream_type << "&, " <<
+              name << "::" << evalue (e) << ");"
+               << endl;
+          }
+
+          os << inst_exp
+             << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "&, const " <<
+            name << "&);"
+             << endl;
+        }
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          os << inst_exp
+             << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "&, const " <<
+            name << "&);"
+             << endl;
+        }
+      };
+    }
+
+    void
+    generate_stream_header (Context& ctx)
+    {
+      String c (ctx.char_type);
+
+      ctx.os << "#include <iosfwd>" << endl
+             << endl;
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/stream-header.hxx b/xsd/cxx/tree/stream-header.hxx
new file mode 100644
index 0000000..58481c2
--- /dev/null
+++ b/xsd/cxx/tree/stream-header.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/stream-header.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_STREAM_HEADER_HXX
+#define XSD_CXX_TREE_STREAM_HEADER_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_stream_header (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_STREAM_HEADER_HXX
diff --git a/xsd/cxx/tree/stream-insertion-header.cxx b/xsd/cxx/tree/stream-insertion-header.cxx
new file mode 100644
index 0000000..9eb4bc4
--- /dev/null
+++ b/xsd/cxx/tree/stream-insertion-header.cxx
@@ -0,0 +1,178 @@
+// file      : xsd/cxx/tree/stream-insertion-header.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/stream-insertion-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type (ostream_type + L"< " + String (*i) + L" >");
+
+            os << inst_exp
+               << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "&," << endl
+               << "const " << name << "&);"
+               << endl;
+          }
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type (ostream_type + L"< " + String (*i) + L" >");
+
+            os << inst_exp
+               << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "&," << endl
+               << "const " << name << "&);"
+               << endl;
+          }
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type (ostream_type + L"< " + String (*i) + L" >");
+
+            os << inst_exp
+               << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "&," << endl
+               << "const " << name << "&);"
+               << endl;
+          }
+        }
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type (ostream_type + L"< " + String (*i) + L" >");
+
+            os << inst_exp
+               << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "&," << endl
+               << "const " << name << "&);"
+               << endl;
+          }
+        }
+      };
+    }
+
+    void
+    generate_stream_insertion_header (Context& ctx)
+    {
+      String c (ctx.char_type);
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/stream-insertion-header.hxx b/xsd/cxx/tree/stream-insertion-header.hxx
new file mode 100644
index 0000000..597bea0
--- /dev/null
+++ b/xsd/cxx/tree/stream-insertion-header.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/stream-insertion-header.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_STREAM_INSERTION_HEADER_HXX
+#define XSD_CXX_TREE_STREAM_INSERTION_HEADER_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_stream_insertion_header (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_STREAM_INSERTION_HEADER_HXX
diff --git a/xsd/cxx/tree/stream-insertion-source.cxx b/xsd/cxx/tree/stream-insertion-source.cxx
new file mode 100644
index 0000000..08391ef
--- /dev/null
+++ b/xsd/cxx/tree/stream-insertion-source.cxx
@@ -0,0 +1,623 @@
+// file      : xsd/cxx/tree/stream-insertion-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/stream-insertion-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String base (L"::xsd::cxx::tree::list< " +
+                       item_type_name (item_type) + L", " + char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base += L" >";
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
+
+            os << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "& s," << endl
+               << "const " << name << "& x)"
+               << "{"
+               << "return s << static_cast< const " << base << "& > (x);"
+               << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (l) &&
+                (!anonymous_p (l) || anonymous_substitutes_p (l)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (l));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_insertion_init_" <<
+                n++ << " (" << endl
+                 << strlit (l.name ()) << "," << endl
+                 << strlit (xml_ns_name (l)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          String const& base (xs_string_type);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
+
+            os << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "& s," << endl
+               << "const " << name << "& x)"
+               << "{"
+               << "return s << static_cast< const " << base << "& > (x);"
+               << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (u) &&
+                (!anonymous_p (u) || anonymous_substitutes_p (u)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (u));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_insertion_init_" <<
+                n++ << " (" << endl
+                 << strlit (u.name ()) << "," << endl
+                 << strlit (xml_ns_name (u)) << ");"
+                 << endl;
+            }
+          }
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_base_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* base_enum (0);
+            IsEnumBasedType t (base_enum);
+            t.dispatch (e);
+
+            enum_based = (base_enum != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
+
+            os << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "& s," << endl
+               << "const " << name << "& x)"
+               << "{";
+
+            if (!string_based || enum_based)
+            {
+              os << "return s << static_cast< const ";
+              inherits (e, inherits_base_);
+              os << "& > (x);";
+            }
+            else
+            {
+              os << name << "::" << value << " v (x);"
+                 << "return s << static_cast< unsigned int > (v);";
+            }
+
+            os << "}";
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (e) &&
+                (!anonymous_p (e) || anonymous_substitutes_p (e)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (e));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_insertion_init_" <<
+                n++ << " (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (xml_ns_name (e)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_;
+      };
+
+      struct Element: Traversal::Element, Context
+      {
+        Element (Context& c, String const& scope_, String const& stream_)
+            : Context (c), scope (scope_), stream (stream_)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e)) return;
+
+          String const& aname (eaname (e));
+          SemanticGraph::Type& t (e.type ());
+          String type (scope + L"::" + etype (e));
+
+          // Figure out if we need to generate polymorphic code. If this
+          // elemen's type is anonymous then we don't need to do anything.
+          // Note that if the type is anonymous then it can't be derived
+          // from which makes it impossible to substitute or dynamically-
+          // type with xsi:type.
+          //
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          // Check if this element is abstract.
+          //
+          bool abst (false);
+          if (poly)
+          {
+            SemanticGraph::Complex* tc;
+            abst = (tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+              tc->abstract_p ();
+          }
+
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+            os << "{"
+               << "const " << scope << "::" << econtainer (e) << "& c (" <<
+              "x." << aname << " ());"
+               << "s << ::xsd::cxx::tree::ostream_common::as_size< " <<
+              "::std::size_t > (c.size ());";
+
+            os << "for (" << scope << "::" << econst_iterator (e) << endl
+               << "i (c.begin ()), e (c.end ());" << endl
+               << "i != e; ++i)"
+               << "{";
+
+            if (poly)
+            {
+              if (!abst)
+                os << "bool d (typeid (" << type << ") != typeid (*i));"
+                   << "s << d;"
+                   << "if (!d)" << endl
+                   << "s << *i;"
+                   << "else" << endl;
+
+              os << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, *i);";
+            }
+            else
+              os << "s << *i;";
+
+            os << "}" // for
+               << "}";
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            os << "{"
+               << "bool p (x." << aname << " ());"
+               << "s << p;"
+               << "if (p)";
+
+            if (poly)
+            {
+              os << "{"
+                 << "const " << type << "& i (*x." << aname << " ());";
+
+              if (!abst)
+                 os << "bool d (typeid (" << type << ") != typeid (i));"
+                    << "s << d;"
+                    << "if (!d)" << endl
+                    << "s << i;"
+                    << "else" << endl;
+
+              os << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, i);"
+                 << "}";
+            }
+            else
+              os << endl
+                 << "s << *x." << aname << " ();";
+
+            os << "}";
+          }
+          else
+          {
+            // one
+            //
+            if (poly)
+            {
+              os << "{"
+                 << "const " << type << "& i (x." << aname << " ());";
+
+              if (!abst)
+                os << "bool d (typeid (" << type << ") != typeid (i));"
+                   << "s << d;"
+                   << "if (!d)" << endl
+                   << "s << i;"
+                   << "else" << endl;
+
+              os << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, i);"
+                 << "}";
+            }
+            else
+              os << "s << x." << aname << " ();";
+          }
+        }
+
+      private:
+        String scope;
+        String stream;
+      };
+
+      struct Attribute: Traversal::Attribute, Context
+      {
+        Attribute (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& aname (eaname (a));
+
+          if (a.optional_p () && !a.default_p ())
+          {
+            os << "{"
+               << "bool p (x." << aname << " ());"
+               << "s << p;"
+               << "if (p)" << endl
+               << "s << *x." << aname << " ();"
+               << "}";
+          }
+          else
+          {
+            os << "s << x." << aname << " ();";
+          }
+        }
+      };
+
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+          bool has_body (ordered ||
+                         has<Traversal::Member> (c) ||
+                         c.inherits_p ());
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
+
+            os << stream_type << "&" << endl
+               << "operator<< (" << stream_type << "& s," << endl
+               << "const " << name << "&" << (has_body ? " x" : "") << ")"
+               << "{";
+
+            if (c.inherits_p ())
+            {
+              os << "s << static_cast< const ";
+
+              inherits (c, inherits_);
+
+              os << "& > (x);";
+            }
+
+            // Write the order sequence.
+            //
+            if (ordered)
+            {
+              String const& ci (ctx.get<String> ("order-const-iterator"));
+              String const& an (ctx.get<String> ("order-aname"));
+
+              os << "s << ::xsd::cxx::tree::ostream_common::as_size< " <<
+                "::std::size_t > (" << endl
+                 << "x." << an << " ().size ());"
+                 << endl
+                 << "for (" << name << "::" << ci << endl
+                 << "b (x." << an << " ().begin ()), n (x." << an <<
+                " ().end ());" << endl
+                 << "b != n; ++b)"
+                 << "{"
+                 << "s << ::xsd::cxx::tree::ostream_common::as_size< " <<
+                "::std::size_t > (b->id);"
+                 << "s << ::xsd::cxx::tree::ostream_common::as_size< " <<
+                "::std::size_t > (b->index);"
+                 << "}";
+            }
+
+            {
+              Traversal::Names names_member;
+              Element element (*this, name, *i);
+              Attribute attribute (*this);
+
+              names_member >> element;
+              names_member >> attribute;
+
+              names (c, names_member);
+            }
+
+            os << "return s;"
+               << "}";
+
+
+            // Register with type map.
+            //
+            if (polymorphic &&
+                polymorphic_p (c) &&
+                !c.abstract_p () &&
+                (!anonymous_p (c) || anonymous_substitutes_p (c)))
+            {
+              // Note that we are using the original type name.
+              //
+              String const& name (ename (c));
+
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
+                 << "_xsd_" << name << "_stream_insertion_init_" <<
+                n++ << " (" << endl
+                 << strlit (c.name ()) << "," << endl
+                 << strlit (xml_ns_name (c)) << ");"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_;
+        BaseTypeName base_;
+      };
+    }
+
+    void
+    generate_stream_insertion_source (Context& ctx)
+    {
+      if (ctx.polymorphic)
+      {
+        NarrowStrings const& st (ctx.options.generate_insertion ());
+
+        ctx.os << "#include <xsd/cxx/tree/stream-insertion-map.hxx>" << endl
+               << 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 tree"
+                 << "{";
+
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            String stream (*i);
+
+            ctx.os << "#ifdef _MSC_VER" << endl;
+
+            if (export_maps)
+              ctx.os << "template struct __declspec (dllexport) " <<
+                "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
+
+            if (import_maps)
+              ctx.os << "template struct __declspec (dllimport) " <<
+                "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
+
+            ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
+                   << "template struct __attribute__ ((visibility(\"default\"))) " <<
+              "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
+                   << "#elif defined(XSD_MAP_VISIBILITY)" << endl
+                   << "template struct XSD_MAP_VISIBILITY " <<
+              "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
+                   << "#endif" << endl;
+          }
+
+          ctx.os << "}"  // tree
+                 << "}"  // cxx
+                 << "}"  // xsd
+                 << "#endif // XSD_NO_EXPORT" << endl
+                 << endl;
+        }
+
+        ctx.os << "namespace _xsd"
+               << "{";
+
+        size_t n (0);
+        for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+             ++i)
+        {
+          String stream (*i);
+
+          ctx.os << "static" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_plate< " <<
+            ctx.poly_plate << ", " << stream << ", " << ctx.char_type <<
+            " >" << endl
+                 << "stream_insertion_plate_init_" << n++ << ";";
+        }
+
+        ctx.os << "}";
+      }
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/stream-insertion-source.hxx b/xsd/cxx/tree/stream-insertion-source.hxx
new file mode 100644
index 0000000..ace8bf6
--- /dev/null
+++ b/xsd/cxx/tree/stream-insertion-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/stream-insertion-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_INSERTION_SOURCE_HXX
+#define XSD_CXX_TREE_INSERTION_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_stream_insertion_source (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_INSERTION_SOURCE_HXX
diff --git a/xsd/cxx/tree/stream-source.cxx b/xsd/cxx/tree/stream-source.cxx
new file mode 100644
index 0000000..eeb3ca3
--- /dev/null
+++ b/xsd/cxx/tree/stream-source.cxx
@@ -0,0 +1,496 @@
+// file      : xsd/cxx/tree/stream-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/stream-source.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String base (L"::xsd::cxx::tree::list< " +
+                       item_type_name (item_type) + L", " + char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base += L" >";
+
+          os << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "& o, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "return o << static_cast< const " << base << "& > (i);"
+             << "}";
+
+          // Register with ostream map.
+          //
+          if (polymorphic &&
+              polymorphic_p (l) &&
+              (!anonymous_p (l) || anonymous_substitutes_p (l)))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (l));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_std_ostream_init;"
+               << endl;
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          os << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "& o, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "return o << static_cast< const " << xs_string_type << "& > (i);"
+             << "}";
+
+          // Register with ostream map.
+          //
+          if (polymorphic &&
+              polymorphic_p (u) &&
+              (!anonymous_p (u) || anonymous_substitutes_p (u)))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (u));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_std_ostream_init;"
+               << endl;
+          }
+        }
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_base_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* be (0);
+            IsEnumBasedType t (be);
+            t.dispatch (e);
+
+            enum_based = (be != 0);
+          }
+
+          // If we are based on an enum then the value type is just an
+          // alias and we don't need to generate this operator again.
+          //
+          if (string_based && !enum_based)
+          {
+            os << std_ostream_type << "&" << endl
+               << "operator<< (" << std_ostream_type << "& o, " <<
+              name << "::" << evalue (e) << " i)"
+               << "{"
+               << "return o << " << name << "::_xsd_" << name <<
+              "_literals_[i];"
+               << "}";
+          }
+
+          os << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "& o, " <<
+            "const " << name << "& i)"
+             << "{"
+             << "return o << static_cast< const ";
+
+          inherits (e, inherits_base_);
+
+          os << "& > (i);"
+             << "}";
+
+          // Register with ostream map.
+          //
+          if (polymorphic &&
+              polymorphic_p (e) &&
+              (!anonymous_p (e) || anonymous_substitutes_p (e)))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (e));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_std_ostream_init;"
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_;
+      };
+
+      struct Element: Traversal::Element, Context
+      {
+        Element (Context& c, String const& scope_)
+            : Context (c), scope (scope_)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e))
+            return;
+
+          String const& aname (eaname (e));
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything. Note that if the type is anonymous then it can't be
+          // derived from which makes it impossible to substitute or
+          // dynamically-type with xsi:type.
+          //
+          SemanticGraph::Type& t (e.type ());
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          if (poly)
+          {
+            os << "{"
+               << "::xsd::cxx::tree::std_ostream_map< " << char_type
+               << " >& om (" << endl
+               << "::xsd::cxx::tree::std_ostream_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
+               << endl;
+          }
+
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+            os << "for (" << scope << "::" << econst_iterator (e) << endl
+               << "b (i." << aname << " ().begin ()), " <<
+              "e (i." << aname << " ().end ());" << endl
+               << "b != e; ++b)"
+               << "{"
+               << "o << ::std::endl << " << strlit (e.name () + L": ");
+
+            if (!poly)
+              os << " << *b;";
+            else
+              os << ";"
+                 << "om.insert (o, *b);";
+
+            os << "}";
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+
+            os << "if (i." << aname << " ())"
+               << "{"
+               << "o << ::std::endl << " << strlit (e.name () + L": ");
+
+            if (!poly)
+              os << " << *i." << aname << " ();";
+            else
+              os << ";"
+                 << "om.insert (o, *i." << aname << " ());";
+
+            os << "}";
+          }
+          else
+          {
+            // one
+            //
+            os << "o << ::std::endl << " << strlit (e.name () + L": ");
+
+            if (!poly)
+              os << " << i." << aname << " ();";
+            else
+              os << ";"
+                 << "om.insert (o, i." << aname << " ());";
+          }
+
+          if (poly)
+            os << "}";
+        }
+
+      private:
+        String scope;
+      };
+
+      struct Attribute: Traversal::Attribute, Context
+      {
+        Attribute (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& aname (eaname (a));
+
+          if (a.optional_p () && !a.default_p ())
+          {
+            os << "if (i." << aname << " ())"
+               << "{"
+               << "o << ::std::endl << " << strlit (a.name () + L": ") <<
+              " << *i." << aname << " ();"
+               << "}";
+          }
+          else
+          {
+            os << "o << ::std::endl << " << strlit (a.name () + L": ") <<
+              " << i." << aname << " ();";
+          }
+        }
+      };
+
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c), base_ (c)
+        {
+          inherits_ >> base_;
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          //
+          //
+          bool has_body (has<Traversal::Member> (c) || c.inherits_p ());
+
+          os << std_ostream_type << "&" << endl
+             << "operator<< (" << std_ostream_type << "& o, " <<
+            "const " << name << "&" << (has_body ? " i" : "") << ")"
+             << "{";
+
+          if (c.inherits_p ())
+          {
+            os << "o << static_cast< const ";
+
+            inherits (c, inherits_);
+
+            os << "& > (i);"
+               << endl;
+          }
+
+          {
+            Traversal::Names names_member;
+            Element element (*this, name);
+            Attribute attribute (*this);
+
+            names_member >> element;
+            names_member >> attribute;
+
+            names (c, names_member);
+          }
+
+          os << "return o;"
+             << "}";
+
+          // Register with ostream map.
+          //
+          if (polymorphic &&
+              polymorphic_p (c) &&
+              !c.abstract_p () &&
+              (!anonymous_p (c) || anonymous_substitutes_p (c)))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (c));
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
+               << "_xsd_" << name << "_std_ostream_init;"
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_;
+        BaseTypeName base_;
+      };
+    }
+
+    void
+    generate_stream_source (Context& ctx, size_t first, size_t last)
+    {
+      String c (ctx.char_type);
+
+      ctx.os << "#include <ostream>" << endl
+             << endl;
+
+      if (ctx.polymorphic)
+      {
+        ctx.os << "#include <xsd/cxx/tree/std-ostream-map.hxx>" << endl
+               << 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 tree"
+                 << "{"
+                 << "#ifdef _MSC_VER" << endl;
+
+          if (export_maps)
+            ctx.os << "template struct __declspec (dllexport) " <<
+              "std_ostream_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
+
+          if (import_maps)
+            ctx.os << "template struct __declspec (dllimport) " <<
+              "std_ostream_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
+
+          ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
+                 << "template struct __attribute__ ((visibility(\"default\"))) " <<
+            "std_ostream_plate< " << ctx.poly_plate << ", " << ctx.char_type <<
+            " >;";
+
+          ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl
+                 << "template struct XSD_MAP_VISIBILITY " <<
+            "std_ostream_plate< " << ctx.poly_plate << ", " << ctx.char_type <<
+            " >;";
+
+          ctx.os << "#endif" << endl
+                 << "}"  // tree
+                 << "}"  // cxx
+                 << "}"  // xsd
+                 << "#endif // XSD_NO_EXPORT" << endl
+                 << endl;
+        }
+
+        ctx.os << "namespace _xsd"
+               << "{"
+               << "static" << endl
+               << "const ::xsd::cxx::tree::std_ostream_plate< " <<
+          ctx.poly_plate << ", " << ctx.char_type << " >" << endl
+               << "std_ostream_plate_init;"
+               << "}";
+      }
+
+      Traversal::Schema schema;
+
+      Sources sources;
+      Traversal::Names names_ns, names;
+
+      Namespace ns (ctx, first, last);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/stream-source.hxx b/xsd/cxx/tree/stream-source.hxx
new file mode 100644
index 0000000..b2b4d5d
--- /dev/null
+++ b/xsd/cxx/tree/stream-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/stream-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_STREAM_SOURCE_HXX
+#define XSD_CXX_TREE_STREAM_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_stream_source (Context&, size_t first, size_t last);
+  }
+}
+
+#endif  // XSD_CXX_TREE_STREAM_SOURCE_HXX
diff --git a/xsd/cxx/tree/tree-forward.cxx b/xsd/cxx/tree/tree-forward.cxx
new file mode 100644
index 0000000..b715abe
--- /dev/null
+++ b/xsd/cxx/tree/tree-forward.cxx
@@ -0,0 +1,325 @@
+// file      : xsd/cxx/tree/tree-forward.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <xsd/cxx/tree/tree-forward.hxx>
+#include <xsd/cxx/tree/fundamental-header.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String const& name (ename (l));
+
+          if (String custom = custom_type (l))
+          {
+            String new_name;
+            renamed_type (l, new_name);
+
+            if (new_name)
+              os << "class " << new_name << ";";
+
+            if (custom == name)
+              os << "class " << name << ";";
+            else
+              os << "typedef " << custom << " " << name << ";";
+          }
+          else
+            os << "class " << name << ";";
+        }
+      };
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String const& name (ename (u));
+
+          if (String custom = custom_type (u))
+          {
+            String new_name;
+            renamed_type (u, new_name);
+
+            if (new_name)
+              os << "class " << new_name << ";";
+
+            if (custom == name)
+              os << "class " << name << ";";
+            else
+              os << "typedef " << custom << " " << name << ";";
+          }
+          else
+            os << "class " << name << ";";
+        }
+      };
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String const& name (ename (e));
+
+          if (String custom = custom_type (e))
+          {
+            String new_name;
+            renamed_type (e, new_name);
+
+            if (new_name)
+              os << "class " << new_name << ";";
+
+            if (custom == name)
+              os << "class " << name << ";";
+            else
+              os << "typedef " << custom << " " << name << ";";
+          }
+          else
+            os << "class " << name << ";";
+        }
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String const& name (ename (c));
+
+          if (String custom = custom_type (c))
+          {
+            String new_name;
+            renamed_type (c, 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
+    generate_forward (Context& ctx)
+    {
+      NarrowString xml_schema (ctx.options.extern_xml_schema ());
+
+      // Inlcude or Emit fundamental types.
+      //
+      if (xml_schema)
+      {
+        String name (ctx.hxx_expr->replace (xml_schema));
+
+        ctx.os << "#include " << ctx.process_include_path (name) << endl
+               << endl;
+      }
+      else
+      {
+        if (ctx.char_type == L"char" && ctx.char_encoding != L"custom")
+        {
+          ctx.os << "#include <xsd/cxx/xml/char-" << ctx.char_encoding <<
+            ".hxx>" << endl
+                 << endl;
+        }
+
+        ctx.os << "#include <xsd/cxx/tree/exceptions.hxx>" << endl
+               << "#include <xsd/cxx/tree/elements.hxx>" << endl
+               << "#include <xsd/cxx/tree/types.hxx>" << endl
+               << endl;
+
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/error-handler.hxx>" << endl
+                 << endl;
+        }
+
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl
+                 << endl;
+        }
+
+        bool element_map (ctx.options.generate_element_map ());
+
+        if (element_map)
+          ctx.os << "#include <xsd/cxx/tree/element-map.hxx>" << endl
+                 << endl;
+
+        // I need to include all the "optional" headers here (instead of
+        // later in the individual generators for each feature because
+        // those headers provide implementation for the fundamental types.
+        //
+        if (!ctx.options.suppress_parsing ())
+        {
+          ctx.os << "#include <xsd/cxx/tree/parsing.hxx>" << endl;
+
+          Traversal::Schema schema, xsd;
+          Traversal::Implies implies;
+          Traversal::Names names;
+          Traversal::Namespace ns;
+          Traversal::Names ns_names;
+          FundIncludes type (ctx, "parsing");
+
+          schema >> implies >> xsd >> names >> ns >> ns_names >> type;
+
+          schema.dispatch (ctx.schema_root);
+
+          if (element_map)
+            ctx.os << "#include <xsd/cxx/tree/parsing/element-map.txx>" <<
+              endl;
+
+          ctx.os << endl;
+        }
+
+        if (ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/dom/serialization-header.hxx>" << endl
+                 << "#include <xsd/cxx/tree/serialization.hxx>" << endl;
+
+          Traversal::Schema schema, xsd;
+          Traversal::Implies implies;
+          Traversal::Names names;
+          Traversal::Namespace ns;
+          Traversal::Names ns_names;
+          FundIncludes type (ctx, "serialization");
+
+          schema >> implies >> xsd >> names >> ns >> ns_names >> type;
+
+          schema.dispatch (ctx.schema_root);
+
+          if (element_map)
+            ctx.os << "#include <xsd/cxx/tree/serialization/element-map.txx>" <<
+              endl;
+
+          ctx.os << endl;
+        }
+
+        if (ctx.options.generate_ostream ())
+        {
+          ctx.os << "#include <xsd/cxx/tree/std-ostream-operators.hxx>" << endl
+                 << endl;
+        }
+
+        NarrowStrings const& ist (ctx.options.generate_insertion ());
+        if (!ist.empty ())
+        {
+          for (NarrowStrings::const_iterator i (ist.begin ()); i != ist.end ();
+               ++i)
+          {
+            if (*i == "ACE_OutputCDR")
+              ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-insertion.hxx>"
+                     << endl;
+            else if (*i == "XDR")
+              ctx.os << "#include <xsd/cxx/tree/xdr-stream-insertion.hxx>"
+                     << endl;
+          }
+
+          ctx.os << "#include <xsd/cxx/tree/stream-insertion.hxx>" << endl
+                 << endl;
+        }
+
+        NarrowStrings const& est (ctx.options.generate_extraction ());
+        if (!est.empty ())
+        {
+          for (NarrowStrings::const_iterator i (est.begin ()); i != est.end ();
+               ++i)
+          {
+            if (*i == "ACE_InputCDR")
+              ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-extraction.hxx>"
+                     << endl;
+            else if (*i == "XDR")
+              ctx.os << "#include <xsd/cxx/tree/xdr-stream-extraction.hxx>"
+                     << endl;
+          }
+
+          ctx.os << "#include <xsd/cxx/tree/stream-extraction.hxx>" << endl
+                 << endl;
+        }
+
+
+        Traversal::Schema schema, xsd;
+        Traversal::Implies implies;
+        Traversal::Names names;
+        FundamentalNamespace ns (ctx);
+
+        schema >> implies >> xsd >> names >> ns;
+
+        schema.dispatch (ctx.schema_root);
+      }
+
+      // First emit header includes.
+      //
+      if (ctx.options.generate_forward ())
+      {
+        Traversal::Schema schema;
+        Includes includes (ctx, Includes::forward);
+
+        schema >> includes;
+
+        schema.dispatch (ctx.schema_root);
+      }
+
+      ctx.os << "// Forward declarations." << endl
+             << "//" << endl;
+
+      Traversal::Schema schema;
+      Sources sources;
+      Traversal::Names names_ns, names;
+      Namespace ns (ctx);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      schema.dispatch (ctx.schema_root);
+
+      ctx.os << endl;
+    }
+  }
+}
diff --git a/xsd/cxx/tree/tree-forward.hxx b/xsd/cxx/tree/tree-forward.hxx
new file mode 100644
index 0000000..0610999
--- /dev/null
+++ b/xsd/cxx/tree/tree-forward.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/tree-forward.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_TREE_FORWARD_HXX
+#define XSD_CXX_TREE_TREE_FORWARD_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_forward (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_TREE_FORWARD_HXX
diff --git a/xsd/cxx/tree/tree-header.cxx b/xsd/cxx/tree/tree-header.cxx
new file mode 100644
index 0000000..99a9b17
--- /dev/null
+++ b/xsd/cxx/tree/tree-header.cxx
@@ -0,0 +1,4337 @@
+// file      : xsd/cxx/tree/tree-header.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/tree-header.hxx>
+#include <xsd/cxx/tree/default-value.hxx>
+#include <xsd/cxx/tree/fundamental-header.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      // List mapping.
+      //
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief List class corresponding to the %" <<
+              comment (l.name ()) << endl
+               << " * schema type." << endl
+               << " *" << endl
+               << " * This class has an interface of a standard C++ " <<
+              "sequence (e.g.," << endl
+               << " * std::vector)." << endl;
+
+            if (l.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (l.annotation ());
+            }
+
+            os << " */" << endl;
+          }
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String item_name (item_type_name (item_type));
+          String base_type (L"::xsd::cxx::tree::list< " + item_name + L", " +
+                            char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base_type += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base_type += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base_type += L" >";
+
+          os << "class " << type_exp << name <<
+            ": public " << any_simple_type << "," << endl
+             << "  public " << base_type
+             << "{"
+             << "public:" << endl;
+
+          // c-tor ()
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Default constructor." << endl
+               << " *" << endl
+               << " * Creates an empty list." << endl
+               << " */" << endl;
+          }
+          os << name << " ();"
+             << endl;
+
+          // c-tor (size_type, const X& x)
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create a list with copies of the specified " <<
+               "element." << endl
+               << " *" << endl
+               << " * @param n A number of elements to copy." << endl
+               << " * @param x An element to copy." << endl
+               << " *" << endl
+               << " * This constructor creates a list with @a n copies " <<
+              "of @a x." << endl
+               << " */" << endl;
+          }
+
+          String size_type (name != L"size_type"
+                            ? String (L"size_type")
+                            : base_type + L"::size_type");
+
+          os << name << " (" << size_type << " n, const " << item_name <<
+            "& x);"
+             << endl;
+
+          // c-tor (const I& begin, const I& end)
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create a list from an iterator range." << endl
+               << " *" << endl
+               << " * @param begin An iterator pointing to the first " <<
+              "element." << endl
+               << " * @param end An iterator pointing to the one past " <<
+              "the last element." << endl
+               << " *" << endl
+               << " * This constructor creates a list consisting of " <<
+              "copies of the" << endl
+               << " * elements in the range [begin,end)." << endl
+               << " */" << endl;
+          }
+
+          String iter_type (unclash (name, "I"));
+
+          os << "template < typename " << iter_type << " >" << endl
+             << name << " (const " << iter_type << "& begin, const " <<
+            iter_type << "& end)" << endl
+             << ": " << base_type << " (begin, end, this)"
+             << "{"
+             << "}";
+
+          // c-tor (istream&)
+          //
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a data " <<
+                "representation" << endl
+                 << " * stream." << endl
+                 << " *" << endl
+                 << " * @param s A stream to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << istream_type << "< " << i->c_str () <<
+              " >& s," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM element." << endl
+                 << " *" << endl
+                 << " * @param e A DOM element to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM attribute." << endl
+                 << " *" << endl
+                 << " * @param a A DOM attribute to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (std::basic_string const&, xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a string fragment." << endl
+                 << " *" << endl
+                 << " * @param s A string fragment to extract the data from." << endl
+                 << " * @param e A pointer to DOM element containing the " <<
+                "string fragment." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          // copy c-tor ()
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy constructor." << endl
+               << " *" << endl
+               << " * @param x An instance to make a copy of." << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " *" << endl
+               << " * For polymorphic object models use the @c _clone " <<
+              "function instead." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << name << "& x," << endl
+             << flags_type << " f = 0," << endl
+             << container << "* c = 0);"
+             << endl;
+
+          os << "#ifdef XSD_CXX11" << endl
+             << name << "&" << endl
+             << "operator= (const " << name << "&) = default;"
+             << "#endif" << endl
+             << endl;
+
+          // clone
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy the instance polymorphically." << endl
+               << " *" << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " * @return A pointer to the dynamically allocated copy." << endl
+               << " *" << endl
+               << " * This function ensures that the dynamic type of the " <<
+              "instance is" << endl
+               << " * used for copying and should be used for polymorphic " <<
+              "object" << endl
+               << " * models instead of the copy constructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << name << "*" << endl
+             << "_clone (" << flags_type << " f = 0," << endl
+             << container << "* c = 0) const;"
+             << endl;
+
+          // d-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Destructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << endl
+             << "~" << name << " ();";
+
+          os << "};";
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison ())
+          {
+            os << inst_exp
+               << "bool" << endl
+               << "operator== (const " << name << "&, const " << name << "&);"
+               << endl;
+
+            os << inst_exp
+               << "bool" << endl
+               << "operator!= (const " << name << "&, const " << name << "&);"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      // Union mapping.
+      //
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Union class corresponding to the %" <<
+              comment (u.name ()) << endl
+               << " * schema type." << endl
+               << " *" << endl
+               << " * The mapping represents unions as strings." << endl;
+
+            if (u.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (u.annotation ());
+            }
+
+            os << " */" << endl;
+          }
+
+          os << "class " << type_exp << name <<
+	    ": public " <<  xs_string_type
+             << "{"
+             << "public:" << endl
+             << endl;
+
+          if (options.generate_default_ctor ())
+          {
+            // c-tor ()
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Default constructor." << endl
+                 << " *" << endl
+                 << " * Note that this constructor may leave the " <<
+                "instance in an" << endl
+                 << " * invalid state." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " ();"
+               << endl;
+          }
+
+          // c-tor (const char*)
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create an instance from a C string." << endl
+               << " *" << endl
+               << " * @param v A string value." << endl
+               << " */" << endl;
+          }
+          os << name << " (const " << char_type << "* v);"
+             << endl;
+
+          // c-tor (string const&)
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create an instance from a string." << endl
+               << " *" << endl
+               << " * @param v A string value." << endl
+               << " */" << endl;
+          }
+          os << name << " (const " << string_type << "& v);"
+             << endl;
+
+          // c-tor (istream&)
+          //
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a data " <<
+                "representation" << endl
+                 << " * stream." << endl
+                 << " *" << endl
+                 << " * @param s A stream to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << istream_type << "< " << i->c_str () <<
+              " >& s," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM element." << endl
+                 << " *" << endl
+                 << " * @param e A DOM element to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM attribute." << endl
+                 << " *" << endl
+                 << " * @param a A DOM attribute to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (std::basic_string const&, xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a string fragment." << endl
+                 << " *" << endl
+                 << " * @param s A string fragment to extract the data from." << endl
+                 << " * @param e A pointer to DOM element containing the " <<
+                "string fragment." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          // copy c-tor ()
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy constructor." << endl
+               << " *" << endl
+               << " * @param x An instance to make a copy of." << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " *" << endl
+               << " * For polymorphic object models use the @c _clone " <<
+              "function instead." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << name << "& x," << endl
+             << flags_type << " f = 0," << endl
+             << container << "* c = 0);"
+             << endl;
+
+          os << "#ifdef XSD_CXX11" << endl
+             << name << "&" << endl
+             << "operator= (const " << name << "&) = default;"
+             << "#endif" << endl
+             << endl;
+
+          // clone
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy the instance polymorphically." << endl
+               << " *" << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " * @return A pointer to the dynamically allocated copy." << endl
+               << " *" << endl
+               << " * This function ensures that the dynamic type of the " <<
+              "instance is" << endl
+               << " * used for copying and should be used for polymorphic " <<
+              "object" << endl
+               << " * models instead of the copy constructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << name << "*" << endl
+             << "_clone (" << flags_type << " f = 0," << endl
+             << container << "* c = 0) const;"
+             << endl;
+
+          os << "};";
+        }
+      };
+
+      // Enum mapping.
+      //
+      struct Enumerator: Traversal::Enumerator, Context
+      {
+        Enumerator (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (doxygen && e.annotated_p ())
+          {
+            os << "/**" << endl;
+            write_annotation (e.annotation ());
+            os << " */" << endl;
+          }
+
+          os << ename (e);
+        }
+      };
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c),
+              base_ (c),
+              member_ (c),
+              enumerator_ (c)
+        {
+          inherits_base_ >> base_;
+          inherits_member_ >> member_;
+
+          names_ >> enumerator_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          SemanticGraph::Enumeration* base_enum (0);
+
+          if (string_based)
+          {
+            IsEnumBasedType t (base_enum);
+            t.dispatch (e);
+
+            if (base_enum != 0)
+              enum_based = true;
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          // Get to the ultimate base and see if is a fundamental type.
+          //
+          bool fund_based (false);
+          SemanticGraph::Type& ult_base (ultimate_base (e));
+          {
+            IsFundamentalType t (fund_based);
+            t.dispatch (ult_base);
+          }
+
+          // Count enumerators.
+          //
+          size_t enum_count (0);
+
+          for (Type::NamesIterator i (e.names_begin ()), end (e.names_end ());
+               i != end; ++i)
+            ++enum_count;
+
+          //
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Enumeration class corresponding to the %" <<
+              comment (e.name ()) << endl
+               << " * schema type." << endl;
+
+            if (e.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (e.annotation ());
+            }
+
+            os << " */" << endl;
+          }
+
+          os << "class " << type_exp << name << ": public ";
+
+          // Enumeration always has a base.
+          //
+          inherits (e, inherits_base_);
+
+          os << "{"
+             << "public:" << endl;
+
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Underlying enum type." << endl
+                 << " */" << endl;
+            }
+
+            if (enum_based)
+            {
+              os << "typedef ";
+
+              inherits (e, inherits_base_);
+
+              os << "::" << evalue (*base_enum) << " " << value << ";"
+                 << endl;
+            }
+            else
+            {
+              os << "enum " << value
+                 << "{";
+
+              names<Enumeration> (e, names_, 0, 0, 0, &Enumeration::comma);
+
+              os << "};";
+            }
+          }
+
+          // default c-tor
+          //
+          bool list_based (
+            ult_base.is_a<SemanticGraph::List> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::NameTokens> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::IdRefs> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::Entities> ());
+
+          if (options.generate_default_ctor () || list_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Default constructor." << endl
+                 << " *" << endl
+                 << " * Note that this constructor may leave the " <<
+                "instance in an" << endl
+                 << " * invalid state." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " ();"
+               << endl;
+          }
+
+          // c-tor (value)
+          //
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from the " <<
+                "underlying enum value." << endl
+                 << " *" << endl
+                 << " * @param v A enum value." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << value << " v);"
+               << endl;
+          }
+
+          // c-tor (const char*)
+          //
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a C string." << endl
+                 << " *" << endl
+                 << " * @param v A string value." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << char_type << "* v);"
+               << endl;
+          }
+
+          // c-tor (const std::string&)
+          //
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a string." << endl
+                 << " *" << endl
+                 << " * @param v A string value." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << string_type << "& v);"
+               << endl;
+          }
+
+          // c-tor (fundamental)
+          //
+          if (fund_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a fundamental " <<
+                "type value." << endl
+                 << " *" << endl
+                 << " * @param v A fundamental type value." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (";
+
+            member_.dispatch (ult_base);
+
+            os << " v);"
+               << endl;
+          }
+
+          // c-tor (base)
+          //
+          // If the ultimate is also our immediate base and it is a
+          // fundamental type then this c-tor clashes with c-tor
+          // (fundamental) above.
+          //
+          if (!fund_based || &ult_base != &e.inherits ().base ())
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from the " <<
+                "base value." << endl
+                 << " *" << endl
+                 << " * @param v A base value." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const ";
+
+            inherits (e, inherits_member_);
+
+            os << "& v);"
+               << endl;
+          }
+
+
+          // c-tor (istream&)
+          //
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a data " <<
+                "representation" << endl
+                 << " * stream." << endl
+                 << " *" << endl
+                 << " * @param s A stream to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << istream_type << "< " << i->c_str () <<
+              " >& s," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM element." << endl
+                 << " *" << endl
+                 << " * @param e A DOM element to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM attribute." << endl
+                 << " *" << endl
+                 << " * @param a A DOM attribute to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+            // c-tor (std::basic_string const&, xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a string fragment." << endl
+                 << " *" << endl
+                 << " * @param s A string fragment to extract the data from." << endl
+                 << " * @param e A pointer to DOM element containing the " <<
+                "string fragment." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+          // copy c-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy constructor." << endl
+               << " *" << endl
+               << " * @param x An instance to make a copy of." << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " *" << endl
+               << " * For polymorphic object models use the @c _clone " <<
+              "function instead." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << name << "& x," << endl
+             << flags_type << " f = 0," << endl
+             << container << "* c = 0);"
+             << endl;
+
+          os << "#ifdef XSD_CXX11" << endl
+             << name << "&" << endl
+             << "operator= (const " << name << "&) = default;"
+             << "#endif" << endl
+             << endl;
+
+          // clone
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy the instance polymorphically." << endl
+               << " *" << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " * @return A pointer to the dynamically allocated copy." << endl
+               << " *" << endl
+               << " * This function ensures that the dynamic type of the " <<
+              "instance is" << endl
+               << " * used for copying and should be used for polymorphic " <<
+              "object" << endl
+               << " * models instead of the copy constructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << name << "*" << endl
+             << "_clone (" << flags_type << " f = 0," << endl
+             << container << "* c = 0) const;"
+             << endl;
+
+          // operator= (value)
+          //
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Assign the underlying enum value." << endl
+                 << " *" << endl
+                 << " * @param v A enum value." << endl
+                 << " * @return A refernce to the instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << "&" << endl
+               << "operator= (" << value << " v);"
+               << endl;
+          }
+
+          // operator value ()
+          //
+          // Name lookup differences in various compilers make generation
+          // of this operator outside of the class a really hard task. So
+          // we are going to make it "always inline".
+          //
+          if (string_based)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Implicit conversion operator to the " <<
+                "underlying" << endl
+                 << " * enum value." << endl
+                 << " *" << endl
+                 << " * @return A enum value." << endl
+                 << " */" << endl;
+            }
+
+            os << "virtual" << endl
+               << "operator " << value << " () const"
+               << "{"
+               << "return _xsd_" << name << "_convert ();"
+               << "}";
+          }
+
+          //
+          //
+          if (string_based)
+          {
+            if (doxygen)
+              os << "//@cond" << endl
+                 << endl;
+
+            os << "protected:" << endl
+               << value << endl
+               << "_xsd_" << name << "_convert () const;"
+               << endl;
+
+            os << "public:" << endl;
+
+            if (enum_based)
+            {
+              // We are going to reuse our base's literals.
+              //
+              os << "static const " << char_type << "* const* " <<
+                "_xsd_" << name << "_literals_;";
+            }
+            else
+            {
+              os << "static const " << char_type << "* const " <<
+                "_xsd_" << name << "_literals_[" << enum_count << "];";
+            }
+
+            os << "static const " << value <<
+              " _xsd_" << name << "_indexes_[" << enum_count << "];";
+
+            if (doxygen)
+              os << endl
+                 << "//@endcond" << endl
+                 << endl;
+          }
+
+          os << "};";
+        }
+
+        virtual void
+        comma (Type&)
+        {
+          os << "," << endl;
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_;
+
+        Traversal::Inherits inherits_member_;
+        MemberTypeName member_;
+
+        Traversal::Names names_;
+        Enumerator enumerator_;
+      };
+
+
+      //
+      //
+      struct MemberFunction: Traversal::Member, Context
+      {
+        MemberFunction (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& aname (eaname (m));
+          String const& mname (emname (m));
+          String kind (m.is_a<SemanticGraph::Element> ()
+                       ? "element" : "attribute");
+
+          bool fund (false);
+          {
+            IsFundamentalType t (fund);
+            t.dispatch (m.type ());
+          }
+
+          bool def_attr (m.default_p () &&
+                         m.is_a<SemanticGraph::Attribute> ());
+
+          if (max (m) != 1)
+          {
+            // sequence
+            //
+            String container (econtainer (m));
+
+            // container const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the element" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << container << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // container&
+            // name ();
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "element sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+            }
+
+            os << container << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            // void
+            // name (container const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy elements from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "makes a copy and adds it " << endl
+                 << " * to the sequence. Note that this operation " <<
+                "completely changes the " << endl
+                 << " * sequence and all old elements will be lost." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << container << "& s);"
+               << endl;
+          }
+          else if (min (m) == 0 && !def_attr)
+          {
+            // optional
+            //
+            String const& type (etype (m));
+            String container (econtainer (m));
+
+            // container const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the " << kind << endl
+                 << " * container." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the optional " <<
+                "container." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << container << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // container&
+            // name ();
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                kind << " container." << endl
+                 << " *" << endl
+                 << " * @return A reference to the optional container." << endl
+                 << " */" << endl;
+            }
+
+            os << container << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            // void
+            // name (type const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the " << kind << " value." << endl
+                 << " *" << endl
+                 << " * @param x A new value to set." << endl
+                 << " *" << endl
+                 << " * This function makes a copy of its argument " <<
+                "and sets it as" << endl
+                 << " * the new value of the " << kind << "." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << type << "& x);"
+               << endl;
+
+            // void
+            // name (container const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the " << kind << " value." << endl
+                 << " *" << endl
+                 << " * @param x An optional container with the new value " <<
+                "to set." << endl
+                 << " *" << endl
+                 << " * If the value is present in @a x then this function " <<
+                "makes a copy " << endl
+                 << " * of this value and sets it as the new value of the " <<
+                kind << "." << endl
+                 << " * Otherwise the " << kind << " container is set " <<
+                "the 'not present' state." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << container << "& x);"
+               << endl;
+
+            // void
+            // name (auto_ptr<type>);
+            //
+            if (!fund)
+            {
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Set the " << kind << " value without " <<
+                  "copying." << endl
+                   << " *" << endl
+                   << " * @param p A new value to use." << endl
+                   << " *" << endl
+                   << " * This function will try to use the passed value " <<
+                  "directly instead" << endl
+                   << " * of making a copy." << endl
+                   << " */" << endl;
+              }
+
+              os << "void" << endl
+                 << mname << " (" << auto_ptr << "< " << type << " > p);"
+                 << endl;
+            }
+          }
+          else
+          {
+            // one
+            //
+            String const& type (etype (m));
+
+            // type const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the " << kind << "." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the " << kind <<
+                "." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << type << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // Do not generate modifiers for fixed attributes.
+            //
+            if (!(def_attr && m.fixed_p ()))
+            {
+              // type&
+              // name ();
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Return a read-write reference to the " <<
+                  kind << "." << endl
+                   << " *" << endl
+                   << " * @return A reference to the " << kind << "." << endl
+                   << " */" << endl;
+              }
+
+              os << type << "&" << endl
+                 << aname << " ();"
+                 << endl;
+
+              // void
+              // name (type const&);
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Set the " << kind << " value." << endl
+                   << " *" << endl
+                   << " * @param x A new value to set." << endl
+                   << " *" << endl
+                   << " * This function makes a copy of its argument " <<
+                  "and sets it as" << endl
+                   << " * the new value of the " << kind << "." << endl
+                   << " */" << endl;
+              }
+
+              os << "void" << endl
+                 << mname << " (const " << type << "& x);"
+                 << endl;
+
+              // void
+              // name (auto_ptr<type>);
+              //
+              if (!fund)
+              {
+                if (doxygen)
+                {
+                  os << "/**" << endl
+                     << " * @brief Set the " << kind << " value without " <<
+                    "copying." << endl
+                     << " *" << endl
+                     << " * @param p A new value to use." << endl
+                     << " *" << endl
+                     << " * This function will try to use the passed value " <<
+                    "directly" << endl
+                     << " * instead of making a copy." << endl
+                     << " */" << endl;
+                }
+
+                os << "void" << endl
+                   << mname << " (" << auto_ptr << "< " << type << " > p);"
+                   << endl;
+
+              }
+
+              // auto_ptr<type>
+              // detach_name ();
+              //
+              if (detach && !fund)
+              {
+                if (doxygen)
+                {
+                  os << "/**" << endl
+                     << " * @brief Detach the " << kind << " value from " <<
+                    "the object model." << endl
+                     << " *" << endl
+                     << " * @return A pointer to the " << kind << " value." << endl
+                     << " *" << endl
+                     << " * Note that this function leaves the required " <<
+                    kind << " in " << endl
+                     << " * the original object model uninitialized." << endl
+                     << " */" << endl;
+                }
+
+                os << auto_ptr << "< " << type << " >" << endl
+                   << edname (m) << " ();"
+                   << endl;
+              }
+            }
+          }
+
+          // default_value
+          //
+          if (m.default_p ())
+          {
+            bool simple (true);
+
+            if (m.is_a<SemanticGraph::Element> ())
+            {
+              IsSimpleType test (simple);
+              test.dispatch (m.type ());
+            }
+
+            if (simple)
+            {
+              bool lit (false);
+              {
+                IsLiteralValue test (lit);
+                test.dispatch (m.type ());
+              }
+
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Return the default value for the " <<
+                  kind << "." << endl
+                   << " *" << endl;
+
+                if (lit)
+                  os << " * @return The " << kind << "'s default value." << endl;
+                else
+                  os << " * @return A read-only (constant) reference to the "
+                     << kind << "'s" << endl
+                     << " * default value." << endl;
+
+                os << " */" << endl;
+              }
+
+              if (lit)
+                os << "static " << etype (m) << endl;
+              else
+                os << "static const " << etype (m) << "&" << endl;
+
+              os << edefault_value (m) << " ();"
+                 << endl;
+            }
+          }
+        }
+      };
+
+      struct AnyFunction: Traversal::Any, Context
+      {
+        AnyFunction (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& aname (eaname (a));
+          String const& mname (emname (a));
+
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            String container (econtainer (a));
+
+            // container const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the wildcard" << endl
+                 << " * element sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << container << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // container&
+            // name ();
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "wildcard element" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+            }
+
+            os << container << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            // void
+            // name (container const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy elements from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "makes a copy and adds" << endl
+                 << " * it to the wildcard element sequence. Note that " <<
+                "this operation" << endl
+                 << " * completely changes the sequence and all old " <<
+                "elements will be" << endl
+                 << " * lost." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << container << "& s);"
+               << endl;
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            String container (econtainer (a));
+
+            // container const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the wildcard" << endl
+                 << " * element container." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the optional " <<
+                "container." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << container << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // container&
+            // name ();
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "wildcard element" << endl
+                 << " * container." << endl
+                 << " *" << endl
+                 << " * @return A reference to the optional container." << endl
+                 << " */" << endl;
+            }
+
+            os << container << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            // void
+            // name (type const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the wildcard content." << endl
+                 << " *" << endl
+                 << " * @param e A new element to set." << endl
+                 << " *" << endl
+                 << " * This function makes a copy of its argument " <<
+                "and sets it as" << endl
+                 << " * the new wildcard content." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << xerces_ns << "::DOMElement& e);"
+               << endl;
+
+            // void
+            // name (type*);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the wildcard content without copying." << endl
+                 << " *" << endl
+                 << " * @param p A new element to use." << endl
+                 << " *" << endl
+                 << " * This function will use the passed element " <<
+                "directly instead" << endl
+                 << " * of making a copy. For this to work the element " <<
+                "should belong" << endl
+                 << " * to the DOM document associated with this instance." << endl
+                 << " *" << endl
+                 << " * @see " << edom_document (c) << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (" << xerces_ns << "::DOMElement* p);"
+               << endl;
+
+            // void
+            // name (container const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the wildcard content." << endl
+                 << " *" << endl
+                 << " * @param x An optional container with the new " <<
+                "element to set." << endl
+                 << " *" << endl
+                 << " * If the element is present in @a x then this function " <<
+                "makes a " << endl
+                 << " * copy of this element and sets it as the new wildcard " <<
+                "content." << endl
+                 << " * Otherwise the element container is set the 'not " <<
+                "present' state." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << container << "& x);"
+               << endl;
+          }
+          else
+          {
+            // one
+            //
+
+            // type const&
+            // name () const;
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the wildcard" << endl
+                 << " * element." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the DOM element." << endl
+                 << " */" << endl;
+            }
+
+            os << "const " << xerces_ns << "::DOMElement&" << endl
+               << aname << " () const;"
+               << endl;
+
+            // type&
+            // name ();
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "wildcard element." << endl
+                 << " *" << endl
+                 << " * @return A reference to the DOM element." << endl
+                 << " */" << endl;
+            }
+
+            os << xerces_ns << "::DOMElement&" << endl
+               << aname << " ();"
+               << endl;
+
+            // void
+            // name (type const&);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the wildcard content." << endl
+                 << " *" << endl
+                 << " * @param e A new element to set." << endl
+                 << " *" << endl
+                 << " * This function makes a copy of its argument " <<
+                "and sets it as" << endl
+                 << " * the new wildcard content." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (const " << xerces_ns << "::DOMElement& e);"
+               << endl;
+
+            // void
+            // name (const*);
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the wildcard content without copying." << endl
+                 << " *" << endl
+                 << " * @param p A new element to use." << endl
+                 << " *" << endl
+                 << " * This function will use the passed element " <<
+                "directly instead" << endl
+                 << " * of making a copy. For this to work the element " <<
+                "should belong" << endl
+                 << " * to the DOM document associated with this instance." << endl
+                 << " *" << endl
+                 << " * @see " << edom_document (c) << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (" << xerces_ns << "::DOMElement* p);"
+               << endl;
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& aname (eaname (a));
+          String const& mname (emname (a));
+
+          String container (econtainer (a));
+
+          // container const&
+          // name () const;
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a read-only (constant) reference " <<
+              "to the" << endl
+               << " * attribute set." << endl
+               << " *" << endl
+               << " * @return A constant reference to the set " <<
+              "container." << endl
+               << " */" << endl;
+          }
+
+          os << "const " << container << "&" << endl
+             << aname << " () const;"
+             << endl;
+
+          // container&
+          // name ();
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a read-write reference to the " <<
+              "attribute set." << endl
+               << " *" << endl
+               << " * @return A reference to the set container." << endl
+               << " */" << endl;
+          }
+
+          os << container << "&" << endl
+             << aname << " ();"
+             << endl;
+
+          // void
+          // name (container const&);
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy attributes from a given set." << endl
+               << " *" << endl
+               << " * @param s A set to copy elements from." << endl
+               << " *" << endl
+               << " * For each attribute in @a s this function " <<
+              "makes a copy and adds" << endl
+               << " * it to the set. Note that this operation " <<
+              "completely changes the " << endl
+               << " * set and all old attributes will be lost." << endl
+               << " */" << endl;
+          }
+
+          os << "void" << endl
+             << mname << " (const " << container << "& s);"
+             << endl;
+        }
+      };
+
+      //
+      //
+      struct Member: Traversal::Member, Context
+      {
+        Member (Context& c)
+            : Context (c),
+              type_name_ (c),
+              member_function_ (c)
+        {
+          belongs_ >> type_name_;
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+          if (skip (m))
+            return;
+
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (m.scope ()));
+
+          String const& type (etype (m));
+          bool el (m.is_a<SemanticGraph::Element> ());
+
+          bool def_attr (m.default_p () && !el);
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name " << comment (m.name ()) << endl
+               << " *" << endl
+               << " * @brief Accessor and modifier functions for the %" <<
+              comment (m.name ()) << endl
+               << " * ";
+
+            if (max (m) != 1)
+            {
+              os << "sequence element." << endl;
+            }
+            else if (min (m) == 0)
+            {
+              if (def_attr)
+                os << "optional attribute with a default value." << endl;
+              else
+                os << "optional " << (el ? "element." : "attribute.") << endl;
+            }
+            else
+            {
+              os << "required " << (el ? "element." : "attribute.") << endl;
+            }
+
+            if (m.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (m.annotation ());
+            }
+
+            os << " */" << endl
+               << "//@{" << endl;
+          }
+          else
+          {
+            os << "// " << comment (m.name ()) << endl
+               << "//" << endl;
+          }
+
+          // Typedefs.
+          //
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief " << (el ? "Element" : "Attribute") <<
+              " type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef ";
+
+          belongs (m, belongs_);
+
+          os << " " << type << ";";
+
+          if (max (m) != 1)
+          {
+            String const& container (econtainer (m));
+            bool isense (options.generate_intellisense ());
+
+            // sequence
+            //
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Element sequence container type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef ::xsd::cxx::tree::sequence< " << type << " > " <<
+              container << ";";
+
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Element iterator type." << endl
+                 << " */" << endl;
+            }
+
+            // IntelliSense does not like aliases and fully-qualified
+            // names here.
+            //
+            if (!isense)
+              os << "typedef " << container << "::iterator " <<
+                eiterator (m) << ";";
+            else
+              os << "typedef xsd::cxx::tree::sequence< " << type <<
+                " >::iterator " << eiterator (m) << ";";
+
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Element constant iterator type." << endl
+                 << " */" << endl;
+            }
+
+            if (!isense)
+              os << "typedef " << container << "::const_iterator " <<
+                econst_iterator (m) << ";";
+            else
+              os << "typedef xsd::cxx::tree::sequence< " << type <<
+                " >::const_iterator " << econst_iterator (m) << ";";
+
+          }
+          else if (min (m) == 0 && !def_attr)
+          {
+            // optional
+            //
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief " << (el ? "Element" : "Attribute") <<
+                " optional container type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef ::xsd::cxx::tree::optional< " << type << " > " <<
+              econtainer (m) << ";";
+          }
+          else
+          {
+            // one
+            //
+          }
+
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief " << (el ? "Element" : "Attribute") <<
+              " traits type." << endl
+               << " */" << endl;
+          }
+          os << "typedef ::xsd::cxx::tree::traits< " << type << ", " <<
+            char_type;
+
+          SemanticGraph::Type& t (m.type ());
+
+          if (t.is_a<SemanticGraph::Fundamental::Double> ())
+            os << ", ::xsd::cxx::tree::schema_type::double_";
+          else if (t.is_a<SemanticGraph::Fundamental::Decimal> ())
+            os << ", ::xsd::cxx::tree::schema_type::decimal";
+
+          os << " > " << etraits (m) << ";"
+             << endl;
+
+
+          // Element id.
+          //
+          if (el && ordered_p (c))
+          {
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Element id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            SemanticGraph::Context& ctx (m.context ());
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("ordered-id-name") << " = " <<
+              ctx.get<size_t> ("ordered-id") << "UL;" << endl;
+          }
+
+          member_function_.traverse (m);
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+        }
+
+      private:
+        MemberTypeName type_name_;
+        Traversal::Belongs belongs_;
+
+        MemberFunction member_function_;
+      };
+
+
+      struct Any: Traversal::Any,
+                  Traversal::AnyAttribute,
+                  Context
+      {
+        Any (Context& c)
+            : Context (c), any_function_ (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name " << ename (a) << endl
+               << " *" << endl
+               << " * @brief Accessor and modifier functions for the " <<
+              "any wildcard." << endl;
+
+            if (a.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (a.annotation ());
+            }
+
+            os << " */" << endl
+               << "//@{" << endl;
+          }
+          else
+          {
+            os << "// " << ename (a) << endl
+               << "//" << endl;
+          }
+
+          // Typedefs.
+          //
+          if (max (a) != 1)
+          {
+            String const& container (econtainer (a));
+
+            // sequence
+            //
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief DOM element sequence container type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef ::xsd::cxx::tree::element_sequence " <<
+              container << ";";
+
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief DOM element iterator type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef " << container << "::iterator " <<
+              eiterator (a) << ";";
+
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief DOM element constant iterator type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef " << container << "::const_iterator " <<
+              econst_iterator (a) << ";"
+               << endl;
+
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            if (doxygen)
+            {
+              os << endl
+                 << "/**" << endl
+                 << " * @brief DOM element optional container type." << endl
+                 << " */" << endl;
+            }
+
+            os << "typedef ::xsd::cxx::tree::element_optional " <<
+              econtainer (a) << ";"
+               << endl;
+          }
+          else
+          {
+            // one
+            //
+            if (doxygen)
+              os << endl;
+          }
+
+          // Wildcard id.
+          //
+          if (ordered_p (c))
+          {
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Wildcard id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            SemanticGraph::Context& ctx (a.context ());
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("ordered-id-name") << " = " <<
+              ctx.get<size_t> ("ordered-id") << "UL;" << endl;
+          }
+
+          any_function_.traverse (a);
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& container (econtainer (a));
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name " << ename (a) << endl
+               << " *" << endl
+               << " * @brief Accessor and modifier functions for the " <<
+              "anyAttribute" << endl
+               << " * wildcard." << endl;
+
+            if (a.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (a.annotation ());
+            }
+
+            os << " */" << endl
+               << "//@{" << endl;
+          }
+          else
+          {
+            os << "// " << ename (a) << endl
+               << "//" << endl;
+          }
+
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief DOM attribute set container type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef ::xsd::cxx::tree::attribute_set< " << char_type <<
+            " > " << container << ";";
+
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief DOM attribute iterator type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef " << container << "::iterator " <<
+            eiterator (a) << ";";
+
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief DOM attribute constant iterator type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef " << container << "::const_iterator " <<
+            econst_iterator (a) << ";"
+             << endl;
+
+          any_function_.traverse (a);
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+        }
+
+      private:
+        AnyFunction any_function_;
+      };
+
+      struct DataMember: Traversal::Member, Context
+      {
+        DataMember (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+          if (skip (m)) return;
+
+          String const& member (emember (m));
+
+          bool def_attr (m.default_p () &&
+                            m.is_a<SemanticGraph::Attribute> ());
+
+          if (max (m) != 1)
+          {
+            // sequence
+            //
+            os << econtainer (m) << " " << member << ";";
+          }
+          else if (min (m) == 0 && !def_attr)
+          {
+            // optional
+            //
+            os << econtainer (m) << " " << member << ";";
+          }
+          else
+          {
+            // one
+            //
+            os << "::xsd::cxx::tree::one< " << etype (m) << " > " <<
+              member << ";";
+          }
+
+          // default_value
+          //
+          if (m.default_p ())
+          {
+            bool simple (true);
+
+            if (m.is_a<SemanticGraph::Element> ())
+            {
+              IsSimpleType test (simple);
+              test.dispatch (m.type ());
+            }
+
+            if (simple)
+            {
+              bool lit (false);
+              {
+                IsLiteralValue test (lit);
+                test.dispatch (m.type ());
+              }
+
+              if (!lit)
+              {
+                os << "static const " << etype (m) << " " <<
+                  edefault_value_member (m) << ";";
+              }
+            }
+          }
+        }
+      };
+
+      struct DataAny: Traversal::Any,
+                      Traversal::AnyAttribute,
+                      Context
+      {
+        DataAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            os << econtainer (a) << " " << member << ";";
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            os << econtainer (a) << " " << member << ";";
+          }
+          else
+          {
+            // one
+            //
+            os << "::xsd::cxx::tree::element_one " << member << ";";
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          os << econtainer (a) << " " << emember (a) << ";";
+        }
+      };
+
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c),
+              base_name_ (c),
+              member_name_ (c),
+              any_ (c),
+              member_ (c),
+              data_any_ (c),
+              data_member_ (c)
+        {
+          inherits_base_ >> base_name_;
+          inherits_member_ >> member_name_;
+
+          names_ >> member_;
+          if (options.generate_wildcard ())
+            names_ >> any_;
+
+          names_data_ >> data_member_;
+          if (options.generate_wildcard ())
+            names_data_ >> data_any_;
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          bool renamed (renamed_type (c, name));
+          if (renamed && !name)
+            return;
+
+          SemanticGraph::Context& ctx (c.context ());
+
+          bool has_members (has<Traversal::Member> (c));
+
+          bool hae (has<Traversal::Any> (c));
+          bool haa (has<Traversal::AnyAttribute> (c));
+
+          bool gen_wildcard (options.generate_wildcard ());
+
+          bool mixed (mixed_p (c) && !ctx.count ("mixed-in-base"));
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+
+          bool simple (true);
+          {
+            IsSimpleType t (simple);
+            t.dispatch (c);
+          }
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (c);
+          }
+
+          SemanticGraph::Enumeration* enum_base (0);
+          {
+            IsEnumBasedType t (enum_base);
+            t.dispatch (c);
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Class corresponding to the %" <<
+	       comment (c.name ()) << " schema type." << endl;
+
+            if (c.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (c.annotation ());
+            }
+
+            os << " *" << endl
+               << " * @nosubgrouping" << endl
+               << " */" << endl;
+          }
+
+          os << "class " << type_exp << name << ": public ";
+
+          if (c.inherits_p ())
+            inherits (c, inherits_base_);
+          else
+            os << any_type;
+
+          os << "{"
+             << "public:" << endl;
+
+          // Members.
+          //
+          names (c, names_);
+
+          // Mixed content.
+          //
+          if (mixed)
+          {
+            String const& type (ctx.get<String> ("mixed-type"));
+            String const& cont (ctx.get<String> ("mixed-container"));
+            String const& iter (ctx.get<String> ("mixed-iterator"));
+            String const& citer (ctx.get<String> ("mixed-const-iterator"));
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @name " << comment ("text_content") << endl
+                 << " *" << endl
+                 << " * @brief Accessor and modifier functions for text " <<
+                "content." << endl
+                 << " */" << endl
+                 << "//@{" << endl;
+            else
+              os << "// text_content" << endl
+                 << "//" << endl;
+
+            // Typedefs.
+            //
+            bool isense (options.generate_intellisense ());
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << xs_string_type << " " << type << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content sequence container type." << endl
+                 << " */" << endl;
+
+            os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+              " > " << cont << ";";
+
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content iterator type." << endl
+                 << " */" << endl;
+
+            // IntelliSense does not like aliases and fully-qualified
+            // names here.
+            //
+            if (!isense)
+              os << "typedef " << cont << "::iterator " << iter<< ";";
+            else
+              os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+                " >::iterator " << iter << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content constant iterator type." << endl
+                 << " */" << endl;
+
+            if (!isense)
+              os << "typedef " << cont << "::const_iterator " << citer<< ";";
+            else
+              os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+                " >::const_iterator " << citer << ";";
+
+            os << endl;
+
+            // Content id.
+            //
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Text content id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("mixed-ordered-id-name") << " = " <<
+              ctx.get<size_t> ("mixed-ordered-id") << "UL;" << endl;
+
+            // Accessors and modifiers.
+            //
+            String const& aname (ctx.get<String> ("mixed-aname"));
+            String const& mname (ctx.get<String> ("mixed-mname"));
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the text" << endl
+                 << " * content sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+
+            os << "const " << cont << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "text content" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+
+            os << cont << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy entries from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "add it to the sequence." << endl
+                 << " * Note that this operation " <<
+                "completely changes the sequence and" << endl
+                 << " * all old elements will be lost." << endl
+                 << " */" << endl;
+
+            os << "void" << endl
+               << mname << " (const " << cont << "& s);"
+               << endl;
+
+            if (doxygen)
+              os << "//@}" << endl
+                 << endl;
+          }
+
+          // dom_document accessors.
+          //
+          if (edom_document_member_p (c))
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the DOM" << endl
+                 << " * document associated with this instance." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the DOM document." << endl
+                 << " *" << endl
+                 << " * The DOM document returned by this function is " <<
+                "used to store" << endl
+                 << " * the raw XML content corresponding to wildcards." << endl
+                 << " */" << endl;
+            }
+            else
+              os << "// DOMDocument for wildcard content." << endl
+                 << "//" << endl;
+
+            os << "const " << xerces_ns << "::DOMDocument&" << endl
+               << edom_document (c) << " () const;"
+               << endl;
+
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the DOM " <<
+                "document" << endl
+                 << " * associated with this instance." << endl
+                 << " *" << endl
+                 << " * @return A reference to the DOM document." << endl
+                 << " *" << endl
+                 << " * The DOM document returned by this function is " <<
+                "used to store" << endl
+                 << " * the raw XML content corresponding to wildcards." << endl
+                 << " */" << endl;
+            }
+            os << xerces_ns << "::DOMDocument&" << endl
+               << edom_document (c) << " ();"
+               << endl;
+          }
+
+          // Order container.
+          //
+          if (ordered)
+          {
+            String const& type (ctx.get<String> ("order-type"));
+            String const& cont (ctx.get<String> ("order-container"));
+            String const& iter (ctx.get<String> ("order-iterator"));
+            String const& citer (ctx.get<String> ("order-const-iterator"));
+
+            String const ct (options.order_container_specified ()
+                             ? options.order_container ()
+                             : "::std::vector");
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @name " << comment ("content_order") << endl
+                 << " *" << endl
+                 << " * @brief Accessor and modifier functions for content " <<
+                "order." << endl
+                 << " */" << endl
+                 << "//@{" << endl;
+            else
+              os << "// content_order" << endl
+                 << "//" << endl;
+
+            // Typedefs.
+            //
+            bool isense (options.generate_intellisense ());
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order entry type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << ns_name (xs_ns ()) << "::" <<
+              xs_ns ().context ().get<String> ("content-order") << " " <<
+              type << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order sequence container type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << ct << "< " << type << " > " << cont << ";";
+
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order iterator type." << endl
+                 << " */" << endl;
+
+            // IntelliSense does not like aliases and fully-qualified
+            // names here.
+            //
+            if (!isense)
+              os << "typedef " << cont << "::iterator " << iter<< ";";
+            else
+              os << "typedef " << ct << "< " << type << " >::iterator " <<
+                iter << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order constant iterator type." << endl
+                 << " */" << endl;
+
+            if (!isense)
+              os << "typedef " << cont << "::const_iterator " << citer<< ";";
+            else
+              os << "typedef " <<  ct << "< " << type <<
+                " >::const_iterator " << citer << ";";
+
+            os << endl;
+
+            // Accessors and modifiers.
+            //
+            String const& aname (ctx.get<String> ("order-aname"));
+            String const& mname (ctx.get<String> ("order-mname"));
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the content" << endl
+                 << " * order sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+
+            os << "const " << cont << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "content order" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+
+            os << cont << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy entries from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "add it to the sequence." << endl
+                 << " * Note that this operation " <<
+                "completely changes the sequence and" << endl
+                 << " * all old elements will be lost." << endl
+                 << " */" << endl;
+
+            os << "void" << endl
+               << mname << " (const " << cont << "& s);"
+               << endl;
+
+            if (doxygen)
+              os << "//@}" << endl
+                 << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Constructors" << endl
+               << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+          else
+          {
+            os << "// Constructors." << endl
+               << "//" << endl;
+          }
+
+          bool generate_no_base_ctor (false);
+          {
+            GenerateWithoutBaseCtor t (generate_no_base_ctor);
+            t.traverse (c);
+          }
+
+          bool has_complex_non_op_args (false);
+          bool has_poly_non_op_args (false);
+          bool complex_poly_args_clash (true);
+          {
+            HasComplexPolyNonOptArgs t (*this, true,
+                                        has_complex_non_op_args,
+                                        has_poly_non_op_args,
+                                        complex_poly_args_clash);
+            t.traverse (c);
+          }
+
+          // default c-tor
+          //
+          if (options.generate_default_ctor ())
+          {
+            // c-tor (ultimate-base, all-non-optional-members) will become
+            // default c-tor if our inheritance hierarchy has no required
+            // members and no simple base. We can also collide with
+            // c-tor (all-non-optional-members) if we have no required
+            // members.
+            //
+            bool generate (false);
+            {
+              GenerateDefaultCtor t (*this, generate, generate_no_base_ctor);
+              t.traverse (c);
+            }
+
+            if (generate)
+            {
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Default constructor." << endl
+                   << " *" << endl
+                   << " * Note that this constructor leaves required " <<
+                  "elements and" << endl
+                   << " * attributes uninitialized." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " ();"
+                 << endl;
+            }
+          }
+
+          // c-tor (base, all-non-optional-members)
+          //
+          if (options.generate_from_base_ctor ())
+          {
+            // c-tor (base, all-non-optional-members) will be equivalent to
+            // c-tor (ultimate-base, all-non-optional-members) unless our
+            // immediate base's hierarchy has some non-optional members.
+            // We also need to generate this c-tor when one of the types
+            // in our inheritance hierarchy was customized since the
+            // customized version may not necessarily be convertible to
+            // the base without loss of information.
+            //
+            bool generate (false);
+            {
+              GenerateFromBaseCtor t (*this, generate);
+              t.traverse (c);
+            }
+
+            if (generate)
+            {
+              bool has_complex_non_op_args (false);
+              bool has_poly_non_op_args (false);
+              bool complex_poly_args_clash (true);
+              {
+                HasComplexPolyNonOptArgs t (*this, false,
+                                            has_complex_non_op_args,
+                                            has_poly_non_op_args,
+                                            complex_poly_args_clash);
+                t.traverse (c);
+              }
+
+              //
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from the immediate "
+                  "base and" << endl
+                   << " * initializers for required elements and "
+                   << "attributes." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (const ";
+              inherits (c, inherits_member_);
+              os << "&";
+              {
+                FromBaseCtorArg args (*this, CtorArgType::type, false);
+                Traversal::Names args_names (args);
+                names (c, args_names);
+              }
+              os << ");"
+                 << endl;
+
+              // If we have any complex arguments in the previous c-tor
+              // then also generate the auto_ptr version.
+              //
+              if (has_complex_non_op_args)
+              {
+                if (doxygen)
+                {
+                  os << "/**" << endl
+                     << " * @brief Create an instance from the immediate "
+                    "base and" << endl
+                     << " * initializers for required elements and "
+                     << "attributes" << endl
+                     << " * (" << auto_ptr << " version)." << endl
+                     << " *" << endl
+                     << " * This constructor will try to use the passed " <<
+                    "values directly" << endl
+                     << " * instead of making copies." << endl
+                     << " */" << endl;
+                }
+
+                os << name << " (const ";
+                inherits (c, inherits_member_);
+                os << "&";
+                {
+                  FromBaseCtorArg args (
+                    *this, CtorArgType::complex_auto_ptr, false);
+                  Traversal::Names args_names (args);
+                  names (c, args_names);
+                }
+                os << ");"
+                   << endl;
+              }
+
+              // If we are generating polymorphic code then we also need to
+              // provide auto_ptr version for every polymorphic type.
+              //
+              if (polymorphic &&
+                  has_poly_non_op_args && !complex_poly_args_clash)
+              {
+                if (doxygen)
+                {
+                  os << "/**" << endl
+                     << " * @brief Create an instance from the immediate "
+                    "base and" << endl
+                     << " * initializers for required elements and "
+                     << "attributes" << endl
+                     << " * (" << auto_ptr << " version)." << endl
+                     << " *" << endl
+                     << " * This constructor will try to use the passed " <<
+                    "values directly" << endl
+                     << " * instead of making copies." << endl
+                     << " */" << endl;
+                }
+
+                os << name << " (const ";
+                inherits (c, inherits_member_);
+                os << "&";
+                {
+                  FromBaseCtorArg args (
+                    *this, CtorArgType::poly_auto_ptr, false);
+                  Traversal::Names args_names (args);
+                  names (c, args_names);
+                }
+                os << ");"
+                   << endl;
+              }
+            }
+          }
+
+          // c-tor (all-non-optional-members)
+          //
+          if (generate_no_base_ctor)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from initializers " <<
+                "for required " << endl
+                 << " * elements and attributes." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (";
+            {
+              CtorArgsWithoutBase ctor_args (
+                *this, CtorArgType::type, false, true);
+              ctor_args.dispatch (c);
+            }
+            os << ");"
+               << endl;
+
+
+            // If we have any complex arguments in the previous c-tor
+            // then also generate the auto_ptr version. One case where
+            // this c-tor will be generated is restriction of anyType.
+            //
+            if (has_complex_non_op_args)
+            {
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from initializers " <<
+                  "for required " << endl
+                   << " * elements and attributes (" << auto_ptr <<
+                  " version)." << endl
+                   << " *" << endl
+                   << " * This constructor will try to use the passed " <<
+                  "values directly" << endl
+                   << " * instead of making copies." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (";
+              {
+                CtorArgsWithoutBase ctor_args (
+                  *this, CtorArgType::complex_auto_ptr, false, true);
+                ctor_args.dispatch (c);
+              }
+              os << ");"
+                 << endl;
+            }
+
+            // If we are generating polymorphic code then we also need to
+            // provide auto_ptr version for every polymorphic type.
+            //
+            if (polymorphic &&
+                has_poly_non_op_args && !complex_poly_args_clash)
+            {
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from initializers " <<
+                  "for required " << endl
+                   << " * elements and attributes (" << auto_ptr <<
+                  " version)." << endl
+                   << " *" << endl
+                   << " * This constructor will try to use the passed " <<
+                  "values directly" << endl
+                   << " * instead of making copies." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (";
+              {
+                CtorArgsWithoutBase ctor_args (
+                  *this, CtorArgType::poly_auto_ptr, false, true);
+                ctor_args.dispatch (c);
+              }
+              os << ");"
+                 << endl;
+            }
+          }
+
+          if (string_based)
+          {
+            // We might not have the value type if this enum is customized.
+            //
+            if (enum_base != 0 && enum_base->context ().count ("value"))
+            {
+              // c-tor (enum-value, all-non-optional-members)
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from the " <<
+                  "underlying enum value" << endl
+                   << " * and initializers for required elements and " <<
+                  "attributes." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (" << fq_name (*enum_base) << "::" <<
+                evalue (*enum_base);
+
+              {
+                CtorArgsWithoutBase ctor_args (
+                  *this, CtorArgType::type, false, false);
+                ctor_args.dispatch (c);
+              }
+
+              os << ");"
+                 << endl;
+            }
+
+            // c-tor (const char*, all-non-optional-members)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a C string and " <<
+                "initializers" << endl
+                 << " * for required elements and attributes." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << char_type << "*";
+
+            {
+              CtorArgsWithoutBase ctor_args (
+                *this, CtorArgType::type, false, false);
+              ctor_args.dispatch (c);
+            }
+
+            os << ");"
+               << endl;
+
+            // c-tor (const std::string&, all-non-optional-members)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a string and" <<
+                "initializers" << endl
+                 << " * for required elements and attributes." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << string_type << "&";
+
+            {
+              CtorArgsWithoutBase ctor_args (
+                *this, CtorArgType::type, false, false);
+              ctor_args.dispatch (c);
+            }
+
+            os << ");"
+               << endl;
+          }
+
+          // c-tor (ultimate-base, all-non-optional-members)
+          //
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create an instance from the ultimate "
+              "base and" << endl
+               << " * initializers for required elements and " <<
+              "attributes." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (";
+
+          {
+            CtorArgs ctor_args (*this, CtorArgType::type);
+            ctor_args.dispatch (c);
+          }
+
+          os << ");"
+             << endl;
+
+          // If we have any complex arguments in the previous c-tor
+          // then also generate the auto_ptr version.
+          //
+          if (has_complex_non_op_args)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from the ultimate "
+                "base and" << endl
+                 << " * initializers for required elements and " <<
+                "attributes" << endl
+                 << " * (" << auto_ptr << " version)." << endl
+                 << " *" << endl
+                 << " * This constructor will try to use the passed " <<
+                "values directly" << endl
+                 << " * instead of making copies." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (";
+
+            {
+              CtorArgs ctor_args (*this, CtorArgType::complex_auto_ptr);
+              ctor_args.dispatch (c);
+            }
+
+            os << ");"
+               << endl;
+          }
+
+          // If we are generating polymorphic code then we also need to
+          // provide auto_ptr version for every polymorphic type.
+          //
+          if (polymorphic && has_poly_non_op_args && !complex_poly_args_clash)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from the ultimate "
+                "base and" << endl
+                 << " * initializers for required elements and " <<
+                "attributes" << endl
+                 << " * (" << auto_ptr << " version)." << endl
+                 << " *" << endl
+                 << " * This constructor will try to use the passed " <<
+                "values directly" << endl
+                 << " * instead of making copies." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (";
+
+            {
+              CtorArgs ctor_args (*this, CtorArgType::poly_auto_ptr);
+              ctor_args.dispatch (c);
+            }
+
+            os << ");"
+               << endl;
+          }
+
+          // c-tor (istream&)
+          //
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a data " <<
+                "representation" << endl
+                 << " * stream." << endl
+                 << " *" << endl
+                 << " * @param s A stream to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << istream_type << "< " << i->c_str () <<
+              " >& s," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+          }
+
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM element." << endl
+                 << " *" << endl
+                 << " * @param e A DOM element to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " * @param c A pointer to the object that will " <<
+                "contain the new" << endl
+                 << " * instance." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f = 0," << endl
+               << container << "* c = 0);"
+               << endl;
+
+
+            if (simple)
+            {
+              // c-tor (xercesc::DOMAttr)
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from a DOM attribute." << endl
+                   << " *" << endl
+                   << " * @param a A DOM attribute to extract the data from." << endl
+                   << " * @param f Flags to create the new instance with." << endl
+                   << " * @param c A pointer to the object that will " <<
+                  "contain the new" << endl
+                   << " * instance." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+                 << flags_type << " f = 0," << endl
+                 << container << "* c = 0);"
+                 << endl;
+
+              // c-tor (std::basic_string const&, xercesc::DOMElement)
+              //
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Create an instance from a string fragment." << endl
+                   << " *" << endl
+                   << " * @param s A string fragment to extract the data from." << endl
+                   << " * @param e A pointer to DOM element containing the " <<
+                  "string fragment." << endl
+                   << " * @param f Flags to create the new instance with." << endl
+                   << " * @param c A pointer to the object that will " <<
+                  "contain the new" << endl
+                   << " * instance." << endl
+                   << " */" << endl;
+              }
+
+              os << name << " (const " << string_type << "& s," << endl
+                 << "const " << xerces_ns << "::DOMElement* e," << endl
+                 << flags_type << " f = 0," << endl
+                 << container << "* c = 0);"
+                 << endl;
+            }
+          }
+
+          // copy c-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy constructor." << endl
+               << " *" << endl
+               << " * @param x An instance to make a copy of." << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " *" << endl
+               << " * For polymorphic object models use the @c _clone " <<
+              "function instead." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << name << "& x," << endl
+             << flags_type << " f = 0," << endl
+             << container << "* c = 0);"
+             << endl;
+
+          // clone
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy the instance polymorphically." << endl
+               << " *" << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @param c A pointer to the object that will contain " <<
+              "the copy." << endl
+               << " * @return A pointer to the dynamically allocated copy." << endl
+               << " *" << endl
+               << " * This function ensures that the dynamic type of the " <<
+              "instance is" << endl
+               << " * used for copying and should be used for polymorphic " <<
+              "object" << endl
+               << " * models instead of the copy constructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << name << "*" << endl
+             << "_clone (" << flags_type << " f = 0," << endl
+             << container << "* c = 0) const";
+
+          // Make the _clone() function pure virtual if the type is
+          // abstract or we are generating a polymorphic base for a
+          // custom implementation (in which case the base must be
+          // inherited from and _clone() overridden).
+          //
+          if (c.abstract_p () ||
+              (renamed && polymorphic && polymorphic_p (c)))
+            os << " = 0";
+
+          os << ";"
+             << endl;
+
+          // operator=
+          //
+          bool priv (false);
+          bool asop (true);
+
+          if (!simple)
+          {
+            if (options.suppress_assignment ())
+            {
+              asop = false;
+
+              priv = true;
+              os << "private:" << endl;
+
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Disabled copy assignment operator." << endl
+                   << " *" << endl
+                   << " * @param x An instance to make a copy of." << endl
+                   << " * @return A reference to itself." << endl
+                   << " */" << endl;
+              }
+
+              os << name << "&" << endl
+                 << "operator= (const " << name << "& x);"
+                 << endl;
+            }
+            else if (has_members || (gen_wildcard && (hae || haa)))
+            {
+              asop = false;
+
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Copy assignment operator." << endl
+                   << " *" << endl
+                   << " * @param x An instance to make a copy of." << endl
+                   << " * @return A reference to itself." << endl
+                   << " *" << endl
+                   << " * For polymorphic object models use the @c _clone " <<
+                  "function instead." << endl
+                   << " */" << endl;
+              }
+
+              os << name << "&" << endl
+                 << "operator= (const " << name << "& x);"
+                 << endl;
+            }
+          }
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+
+          if (priv)
+            os << "public:" << endl;
+
+          if (asop)
+          {
+            os << "#ifdef XSD_CXX11" << endl
+               << name << "&" << endl
+               << "operator= (const " << name << "&) = default;"
+               << "#endif" << endl
+               << endl;
+          }
+
+          // d-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Destructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << endl
+             << "~" << name << " ();"
+             << endl;
+
+          // Data members and implementation functions.
+          //
+          if (has_members || hae || (haa && gen_wildcard) || ordered || mixed)
+          {
+            os << "// Implementation." << endl
+               << "//" << endl;
+
+            if (doxygen)
+              os << endl
+                 << "//@cond" << endl
+                 << endl;
+
+            if (!options.suppress_parsing () &&
+                (has_members || hae || (haa && gen_wildcard) || mixed))
+            {
+              // parse ()
+              //
+              os << "protected:" << endl
+                 << "void" << endl
+                 << unclash (name, "parse") << " (" <<
+                parser_type << "&," << endl
+                 << flags_type << ");"
+                 << endl;
+            }
+
+            os << "protected:"
+               << endl;
+
+            // parse (istream)
+            //
+            if (has_members)
+            {
+              for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+                   ++i)
+              {
+                os << "void" << endl
+                   << unclash (name, "parse") << " (" <<
+                  istream_type << "< " << i->c_str () << " >&," << endl
+                   << flags_type << ");"
+                   << endl;
+              }
+            }
+
+            // DOM document.
+            //
+            if (edom_document_member_p (c))
+            {
+              os << dom_auto_ptr << "< " << xerces_ns <<
+                "::DOMDocument > " << edom_document_member (c) << ";"
+                 << endl;
+            }
+
+            // Mixed text content.
+            //
+            if (mixed)
+            {
+              os << ctx.get<String> ("mixed-container") << " " <<
+                ctx.get<String> ("mixed-member") << ";"
+                 << endl;
+            }
+
+            // Order container.
+            //
+            if (ordered)
+            {
+              os << ctx.get<String> ("order-container") << " " <<
+                ctx.get<String> ("order-member") << ";"
+                 << endl;
+            }
+
+            //
+            //
+            names (c, names_data_);
+
+            if (doxygen)
+              os << endl
+                 << "//@endcond" << endl;
+          }
+
+          os << "};";
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison () &&
+              (has_members || !c.inherits_p () ||
+               ((hae || haa) && gen_wildcard)))
+          {
+            os << inst_exp
+               << "bool" << endl
+               << "operator== (const " << name << "&, const " << name << "&);"
+               << endl;
+
+            os << inst_exp
+               << "bool" << endl
+               << "operator!= (const " << name << "&, const " << name << "&);"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_base_;
+        BaseTypeName base_name_;
+
+        Traversal::Inherits inherits_member_;
+        MemberTypeName member_name_;
+
+        Traversal::Names names_;
+        Any any_;
+        Member member_;
+
+        Traversal::Names names_data_;
+        DataAny data_any_;
+        DataMember data_member_;
+      };
+
+
+      struct GlobalElement: Traversal::Element,
+                            GlobalElementBase,
+                            Context
+      {
+        GlobalElement (Context& c)
+            : GlobalElementBase (c), Context (c), type_name_ (c)
+        {
+          belongs_ >> type_name_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          SemanticGraph::Type& t (e.type ());
+
+          bool fund (false);
+          {
+            IsFundamentalType test (fund);
+            test.dispatch (t);
+          }
+
+          bool simple (true);
+          if (!fund)
+          {
+            IsSimpleType test (simple);
+            test.dispatch (t);
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Class corresponding to the %" <<
+              comment (e.name ()) << " root element." << endl;
+
+            if (e.annotated_p ())
+            {
+              os << " *" << endl;
+              write_annotation (e.annotation ());
+            }
+
+            os << " *" << endl
+               << " * @nosubgrouping" << endl
+               << " */" << endl;
+          }
+
+          String const& name (ename (e));
+
+          os << "class " << type_exp << name << ": public " << element_type
+             << "{"
+             << "public:" << endl
+             << endl;
+
+          String const& type (etype (e));
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Element value" << endl
+               << " *" << endl
+               << " * @brief Accessor and modifier functions for the " <<
+              "element value." << endl
+               << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+          else
+          {
+            os << "// Element value." << endl
+               << "//" << endl;
+          }
+
+          // Typedefs.
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Element value type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef ";
+
+          belongs (e, belongs_);
+
+          os << " " << type << ";";
+
+          if (doxygen)
+          {
+            os << endl
+               << "/**" << endl
+               << " * @brief Element value traits type." << endl
+               << " */" << endl;
+          }
+
+          os << "typedef ::xsd::cxx::tree::traits< " << type << ", " <<
+            char_type;
+
+          if (t.is_a<SemanticGraph::Fundamental::Double> ())
+            os << ", ::xsd::cxx::tree::schema_type::double_";
+          else if (t.is_a<SemanticGraph::Fundamental::Decimal> ())
+            os << ", ::xsd::cxx::tree::schema_type::decimal";
+
+          os << " > " << etraits (e) << ";"
+             << endl;
+
+          // Accessors/modifiers.
+          //
+          String const& aname (eaname (e));
+          String const& mname (emname (e));
+
+          // type const&
+          // name () const;
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a read-only (constant) reference " <<
+              "to the element" << endl
+               << " * value." << endl
+               << " *" << endl
+               << " * @return A constant reference to the element value." <<
+              endl
+               << " */" << endl;
+          }
+
+          os << "const " << type << "&" << endl
+             << aname << " () const;"
+             << endl;
+
+          // type&
+          // name ();
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a read-write reference to the " <<
+              "element value." << endl
+               << " *" << endl
+               << " * @return A reference to the element value." << endl
+               << " */" << endl;
+          }
+
+          os << type << "&" << endl
+             << aname << " ();"
+             << endl;
+
+          // void
+          // name (type const&);
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Set the element value." << endl
+               << " *" << endl
+               << " * @param x A new value to set." << endl
+               << " *" << endl
+               << " * This function makes a copy of its argument " <<
+              "and sets it as" << endl
+               << " * the new value of the element." << endl
+               << " */" << endl;
+          }
+
+          os << "void" << endl
+             << mname << " (const " << type << "& x);"
+             << endl;
+
+          // void
+          // name (auto_ptr<type>);
+          //
+          if (!fund)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Set the element value without " <<
+                "copying." << endl
+                 << " *" << endl
+                 << " * @param p A new value to use." << endl
+                 << " *" << endl
+                 << " * This function will try to use the passed value " <<
+                "directly" << endl
+                 << " * instead of making a copy." << endl
+                 << " */" << endl;
+            }
+
+            os << "void" << endl
+               << mname << " (" << auto_ptr << "< " << type << " > p);"
+               << endl;
+          }
+
+          // auto_ptr<type>
+          // detach_name ();
+          //
+          if (detach && !fund)
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Detach the element value from " <<
+                "the object." << endl
+                 << " *" << endl
+                 << " * @return A pointer to the element value." << endl
+                 << " *" << endl
+                 << " * Note that this function leaves the element " <<
+                "object uninitialized." << endl
+                 << " */" << endl;
+            }
+
+            os << auto_ptr << "< " << type << " >" << endl
+               << edname (e) << " ();"
+               << endl;
+          }
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a read-only (constant) pointer " <<
+              "to the element" << endl
+               << " * value." << endl
+               << " *" << endl
+               << " * @return A constant pointer to the element value " <<
+              "or 0 if this" << endl
+               << " * element is of a fundamental type." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual const " << any_type << "*" << endl
+             << "_value () const;"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return a pointer to the element value." << endl
+               << " *" << endl
+               << " * @return A pointer to the element value or 0 if this " <<
+              "element is" << endl
+               << " * of a fundamental type." << endl
+               << " */" << endl;
+          }
+          os << "virtual " << any_type << "*" << endl
+             << "_value ();"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+
+          // Constructor.
+          //
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Constructors" << endl
+               << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+          else
+          {
+            os << "// Constructors." << endl
+               << "//" << endl;
+          }
+
+          // default c-tor
+          //
+          if (options.generate_default_ctor ())
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Default constructor." << endl
+                 << " *" << endl
+                 << " * Note that this constructor leaves the element " <<
+                "value" << endl
+                 << " * uninitialized." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " ();"
+               << endl;
+          }
+
+          // c-tor (value)
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Create an instance from an initializer " <<
+              "for the element" << endl
+               << " * value." << endl
+               << " *" << endl
+               << " * @param x Element value." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << type << "& x);"
+             << endl;
+
+
+          // If the element value is a complex type (has elements,
+          // attributes, or wildcards) then also generate the auto_ptr
+          // version. If we are generating polymorphic code then we
+          // also need to provide auto_ptr version for simple types.
+          //
+          if (!simple || (polymorphic && polymorphic_p (t)))
+          {
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from an initializer " <<
+                "for" << endl
+                 << " * the element value (" << auto_ptr <<
+                " version)." << endl
+                 << " *" << endl
+                 << " * @param p Element value to use." << endl
+                 << " *" << endl
+                 << " * This constructor will try to use the passed " <<
+                "value directly" << endl
+                 << " * instead of making a copy." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (" << auto_ptr << "< " << type << " > p);"
+               << endl;
+          }
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            if (doxygen)
+            {
+              os << "/**" << endl
+                 << " * @brief Create an instance from a DOM element." << endl
+                 << " *" << endl
+                 << " * @param e A DOM element to extract the data from." << endl
+                 << " * @param f Flags to create the new instance with." << endl
+                 << " */" << endl;
+            }
+
+            os << name << " (const " << xerces_ns << "::DOMElement& e, " <<
+              flags_type << " f = 0);"
+               << endl;
+          }
+
+          // copy c-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy constructor." << endl
+               << " *" << endl
+               << " * @param x An instance to make a copy of." << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " *" << endl
+               << " * For polymorphic object models use the @c _clone " <<
+              "function instead." << endl
+               << " */" << endl;
+          }
+
+          os << name << " (const " << name << "& x, " <<
+            flags_type << " f = 0);"
+             << endl;
+
+          os << "#ifdef XSD_CXX11" << endl
+             << name << "&" << endl
+             << "operator= (const " << name << "&) = default;"
+             << "#endif" << endl
+             << endl;
+
+          // _clone
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Copy the instance polymorphically." << endl
+               << " *" << endl
+               << " * @param f Flags to create the copy with." << endl
+               << " * @return A pointer to the dynamically allocated copy." << endl
+               << " *" << endl
+               << " * This function ensures that the dynamic type of the " <<
+              "instance is" << endl
+               << " * used for copying and should be used for polymorphic " <<
+              "object" << endl
+               << " * models instead of the copy constructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << name << "*" << endl
+             << "_clone (" << flags_type << " f = 0) const;"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+
+          // Element name and namespace accessors.
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @name Element name and namespace" << endl
+               << " *" << endl
+               << " * @brief Accessor functions for the element name " <<
+              "and namespace." << endl
+               << " */" << endl
+               << "//@{" << endl
+               << endl;
+          }
+          else
+          {
+            os << "// Element name and namespace." << endl
+               << "//" << endl;
+          }
+
+          SemanticGraph::Context& ec (e.context ());
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return the element name (static function)." << endl
+               << " *" << endl
+               << " * @return A read-only string reference containing " <<
+              "the element" << endl
+               << " * name." << endl
+               << " */" << endl;
+          }
+          os << "static const " << string_type << "&" << endl
+             << ec.get<String> ("element-name") << " ();"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return the element namespace (static " <<
+              "function)." << endl
+               << " *" << endl
+               << " * @return A read-only string reference containing " <<
+              "the element" << endl
+               << " * namespace." << endl
+               << " */" << endl;
+          }
+          os << "static const " << string_type << "&" << endl
+             << ec.get<String> ("element-ns") << " ();"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return the element name." << endl
+               << " *" << endl
+               << " * @return A read-only string reference containing " <<
+              "the element" << endl
+               << " * name." << endl
+               << " */" << endl;
+          }
+          os << "virtual const " << string_type << "&" << endl
+             << "_name () const;"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Return the element namespace." << endl
+               << " *" << endl
+               << " * @return A read-only string reference containing " <<
+              "the element" << endl
+               << " * namespace." << endl
+               << " */" << endl;
+          }
+          os << "virtual const " << string_type << "&" << endl
+             << "_namespace () const;"
+             << endl;
+
+          if (doxygen)
+          {
+            os << "//@}" << endl
+               << endl;
+          }
+
+          // d-tor
+          //
+          if (doxygen)
+          {
+            os << "/**" << endl
+               << " * @brief Destructor." << endl
+               << " */" << endl;
+          }
+
+          os << "virtual " << endl
+             << "~" << name << " ();"
+             << endl;
+
+          // Data member.
+          //
+
+          if (doxygen)
+            os << "//@cond" << endl
+               << endl;
+
+          os << "protected:" << endl
+             << "::xsd::cxx::tree::one< " << type << " > " <<
+            emember (e) << ";"
+             << "static const " << string_type << " " <<
+            ec.get<String> ("element-name-member") << ";"
+             << "static const " << string_type << " " <<
+            ec.get<String> ("element-ns-member") << ";";
+
+          if (doxygen)
+            os << endl
+               << "//@endcond" << endl;
+
+          os << "};";
+        }
+
+      private:
+        Traversal::Belongs belongs_;
+        MemberTypeName type_name_;
+      };
+    }
+
+    void
+    generate_tree_header (Context& ctx)
+    {
+      if (ctx.generate_xml_schema)
+      {
+        if (ctx.char_type == L"char" && ctx.char_encoding != L"custom")
+        {
+          ctx.os << "#include <xsd/cxx/xml/char-" << ctx.char_encoding <<
+            ".hxx>" << endl
+                 << endl;
+        }
+
+        ctx.os << "#include <xsd/cxx/tree/exceptions.hxx>" << endl
+               << "#include <xsd/cxx/tree/elements.hxx>" << endl
+               << "#include <xsd/cxx/tree/types.hxx>" << endl
+               << endl;
+
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/error-handler.hxx>" << endl
+                 << endl;
+        }
+
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl
+                 << endl;
+        }
+
+        bool element_map (ctx.options.generate_element_map ());
+
+        if (element_map)
+          ctx.os << "#include <xsd/cxx/tree/element-map.hxx>" << endl
+                 << endl;
+
+        // I need to include all the "optional" headers here (instead of
+        // later in the individual generators for each feature because
+        // those headers provide implementation for the fundamental types.
+        //
+        if (!ctx.options.suppress_parsing ())
+        {
+          ctx.os << "#include <xsd/cxx/tree/parsing.hxx>" << endl;
+
+          Traversal::Schema schema;
+          Traversal::Names names;
+          Traversal::Namespace ns;
+          Traversal::Names ns_names;
+          FundIncludes type (ctx, "parsing");
+
+          schema >> names >> ns >> ns_names >> type;
+
+          schema.dispatch (ctx.schema_root);
+
+          if (element_map)
+            ctx.os << "#include <xsd/cxx/tree/parsing/element-map.txx>" <<
+              endl;
+
+          ctx.os << endl;
+        }
+
+        if (ctx.options.generate_serialization ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/dom/serialization-header.hxx>" << endl
+                 << "#include <xsd/cxx/tree/serialization.hxx>" << endl;
+
+          Traversal::Schema schema;
+          Traversal::Names names;
+          Traversal::Namespace ns;
+          Traversal::Names ns_names;
+          FundIncludes type (ctx, "serialization");
+
+          schema >> names >> ns >> ns_names >> type;
+
+          schema.dispatch (ctx.schema_root);
+
+          if (element_map)
+            ctx.os << "#include <xsd/cxx/tree/serialization/element-map.txx>" <<
+              endl;
+
+          ctx.os << endl;
+        }
+
+        if (ctx.options.generate_ostream ())
+        {
+          ctx.os << "#include <xsd/cxx/tree/std-ostream-operators.hxx>" << endl
+                 << endl;
+        }
+
+        NarrowStrings const& ist (ctx.options.generate_insertion ());
+        if (!ist.empty ())
+        {
+          for (NarrowStrings::const_iterator i (ist.begin ()); i != ist.end ();
+               ++i)
+          {
+            if (*i == "ACE_OutputCDR")
+              ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-insertion.hxx>"
+                     << endl;
+            else if (*i == "XDR")
+              ctx.os << "#include <xsd/cxx/tree/xdr-stream-insertion.hxx>"
+                     << endl;
+          }
+
+          ctx.os << "#include <xsd/cxx/tree/stream-insertion.hxx>" << endl
+                 << endl;
+        }
+
+        NarrowStrings const& est (ctx.options.generate_extraction ());
+        if (!est.empty ())
+        {
+          for (NarrowStrings::const_iterator i (est.begin ()); i != est.end ();
+               ++i)
+          {
+            if (*i == "ACE_InputCDR")
+              ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-extraction.hxx>"
+                     << endl;
+            else if (*i == "XDR")
+              ctx.os << "#include <xsd/cxx/tree/xdr-stream-extraction.hxx>"
+                     << endl;
+          }
+
+          ctx.os << "#include <xsd/cxx/tree/stream-extraction.hxx>" << endl
+                 << endl;
+        }
+
+        // Emit fundamental types.
+        //
+        {
+          Traversal::Schema schema;
+          Traversal::Names names;
+          FundamentalNamespace ns (ctx);
+
+          schema >> names >> ns;
+
+          schema.dispatch (ctx.schema_root);
+        }
+      }
+      else
+      {
+        bool inline_ (ctx.options.generate_inline ());
+
+        ctx.os << "#include <memory>    // " << ctx.auto_ptr << endl
+               << "#include <limits>    // std::numeric_limits" << endl
+               << "#include <algorithm> // std::binary_search" << endl;
+
+        if (ctx.std >= cxx_version::cxx11)
+          ctx.os << "#include <utility>   // std::move" << endl;
+
+        if (!ctx.options.ordered_type ().empty () ||
+            ctx.options.ordered_type_all ())
+        {
+          ctx.os << "#include <cstddef>   // std::size_t" << endl;
+
+          if (!ctx.options.order_container_specified ())
+            ctx.os << "#include <vector>" << endl;
+        }
+
+        ctx.os << endl;
+
+        if (ctx.char_type == L"char" && ctx.char_encoding != L"custom")
+        {
+          ctx.os << "#include <xsd/cxx/xml/char-" << ctx.char_encoding <<
+            ".hxx>" << endl
+                 << endl;
+        }
+
+        ctx.os << "#include <xsd/cxx/tree/exceptions.hxx>" << endl
+               << "#include <xsd/cxx/tree/elements.hxx>" << endl
+               << "#include <xsd/cxx/tree/containers.hxx>" << endl
+               << "#include <xsd/cxx/tree/list.hxx>" << endl
+               << endl;
+
+        if (!ctx.options.suppress_parsing ())
+        {
+          ctx.os << "#include <xsd/cxx/xml/dom/parsing-header.hxx>" << endl
+                 << endl;
+        }
+
+        if (ctx.options.generate_wildcard ())
+        {
+          if (ctx.options.suppress_parsing () ||
+              !ctx.options.generate_serialization ())
+            ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl;
+
+          ctx.os << "#include <xsd/cxx/tree/containers-wildcard.hxx>" << endl
+                 << endl;
+        }
+
+        if (!ctx.options.generate_extraction ().empty ())
+          ctx.os << "#include <xsd/cxx/tree/istream-fwd.hxx>" << endl
+                 << endl;
+
+        // Emit header includes.
+        //
+        {
+          if (inline_)
+          {
+            ctx.os << "#ifndef XSD_DONT_INCLUDE_INLINE" << endl
+                   << "#define XSD_DONT_INCLUDE_INLINE" << endl
+                   << endl;
+          }
+
+          Traversal::Schema schema;
+          Includes includes (ctx, Includes::header);
+
+          schema >> includes;
+
+          schema.dispatch (ctx.schema_root);
+
+          if (inline_)
+          {
+            ctx.os << "#undef XSD_DONT_INCLUDE_INLINE" << endl
+                   << "#else" << endl
+                   << endl;
+
+            schema.dispatch (ctx.schema_root);
+
+            ctx.os << "#endif // XSD_DONT_INCLUDE_INLINE" << endl
+                   << endl;
+          }
+        }
+
+
+        {
+          Traversal::Schema schema;
+
+          Sources sources;
+          Traversal::Names names_ns, names;
+
+          DocumentedNamespace ns (ctx);
+
+          List list (ctx);
+          Union union_ (ctx);
+          Complex complex (ctx);
+          Enumeration enumeration (ctx);
+          GlobalElement element (ctx);
+
+          schema >> sources >> schema;
+          schema >> names_ns >> ns >> names;
+
+          names >> list;
+          names >> union_;
+          names >> complex;
+          names >> enumeration;
+
+          if (ctx.options.generate_element_type ())
+            names >> element;
+
+          schema.dispatch (ctx.schema_root);
+        }
+
+        // Emit inline includes.
+        //
+        if (inline_)
+        {
+          ctx.os << "#ifndef XSD_DONT_INCLUDE_INLINE" << endl
+                 << endl;
+
+          Traversal::Schema schema;
+          Includes ixx_includes (ctx, Includes::inline_);
+          schema >> ixx_includes;
+
+          schema.dispatch (ctx.schema_root);
+
+          ctx.os << "#endif // XSD_DONT_INCLUDE_INLINE" << endl
+                 << endl;
+        }
+      }
+    }
+  }
+}
diff --git a/xsd/cxx/tree/tree-header.hxx b/xsd/cxx/tree/tree-header.hxx
new file mode 100644
index 0000000..d0e9ea6
--- /dev/null
+++ b/xsd/cxx/tree/tree-header.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/tree-header.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_TREE_HEADER_HXX
+#define XSD_CXX_TREE_TREE_HEADER_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_tree_header (Context&);
+  }
+}
+
+#endif  // XSD_CXX_TREE_TREE_HEADER_HXX
diff --git a/xsd/cxx/tree/tree-inline.cxx b/xsd/cxx/tree/tree-inline.cxx
new file mode 100644
index 0000000..aa8b726
--- /dev/null
+++ b/xsd/cxx/tree/tree-inline.cxx
@@ -0,0 +1,1161 @@
+// file      : xsd/cxx/tree/tree-inline.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/tree-inline.hxx>
+#include <xsd/cxx/tree/default-value.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          SemanticGraph::Type& item_type (l.argumented ().type ());
+          String item_name (item_type_name (item_type));
+          String base_type (L"::xsd::cxx::tree::list< " + item_name +
+                            L", " + char_type);
+
+          if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+            base_type += L", ::xsd::cxx::tree::schema_type::double_";
+          else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+            base_type += L", ::xsd::cxx::tree::schema_type::decimal";
+
+          base_type += L" >";
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          // c-tor ()
+          //
+          os << inl
+             << name << "::" << endl
+             << name << " ()" << endl
+             << ": " << base_type << " (this)"
+             << "{"
+             << "}";
+
+          // c-tor (size_type, const X& x)
+          //
+          String size_type (name != L"size_type"
+                            ? String (L"size_type")
+                            : base_type + L"::size_type");
+
+          os << inl
+             << name << "::" << endl
+             << name << " (" << size_type << " n, const " << item_name <<
+            "& x)" << endl
+             << ": " << base_type << " (n, x, this)"
+             << "{"
+             << "}";
+
+          // copy c-tor ()
+          //
+          os << inl
+             << name << "::" << endl
+             << name << " (const " << name << "& o," << endl
+             << flags_type << " f," << endl
+             << container << "* c)" << endl
+             << ": " << any_simple_type << " (o, f, c)," << endl
+             << "  " << base_type << " (o, f, this)"
+             << "{"
+             << "}";
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison ())
+          {
+            os << inl
+               << "bool" << endl
+               << "operator== (const " << name << "& x, " <<
+              "const " << name << "& y)"
+               << "{"
+               << "const " << base_type << "& bx (x);"
+               << "return bx == y;"
+               << "}";
+
+            os << inl
+               << "bool" << endl
+               << "operator!= (const " << name << "& x, " <<
+              "const " << name << "& y)"
+               << "{"
+               << "return !(x == y);"
+               << "}";
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          String const& base (xs_string_type);
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          if (options.generate_default_ctor ())
+          {
+            // c-tor ()
+            //
+            os << inl
+               << name << "::" << endl
+               << name << " ()" << endl
+               << ": " << base << " ()"
+               << "{"
+               << "}";
+          }
+
+          // c-tor (const char*)
+          //
+          os << inl
+             << name << "::" << endl
+             << name << " (const " << char_type << "* s)" << endl
+             << ": " << base << " (s)"
+             << "{"
+             << "}";
+
+          // c-tor (string const&)
+          //
+          os << inl
+             << name << "::" << endl
+             << name << " (const " << string_type << "& s)" << endl
+             << ": " << base << " (s)"
+             << "{"
+             << "}";
+
+          // copy c-tor ()
+          //
+          os << inl
+             << name << "::" << endl
+             << name << " (const " << name << "& o," << endl
+             << flags_type << " f," << endl
+             << container << "* c)" << endl
+             << ": " << base << " (o, f, c)"
+             << "{"
+             << "}";
+        }
+      };
+
+      // Enumeration
+      //
+
+      // Generate a sequence of explicit c-tor calls until we reach
+      // one of the fundamental string types that can be constructed
+      // from char literals.
+      //
+      struct CtorCallSequence: Traversal::Complex,
+                               Traversal::Fundamental::Type,
+                               Context
+      {
+        CtorCallSequence (Context& c, String const& arg)
+            : Context (c), arg_ (arg), base_type_name_ (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          // This type should be ultimately string based.
+          //
+          assert (c.inherits_p ());
+
+          os << ename (c) << " (" << endl;
+
+          dispatch (c.inherits ().base ());
+
+          os << ")";
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Type& t)
+        {
+          base_type_name_.dispatch (t);
+
+          os << " (" << arg_ << ")";
+        }
+
+      private:
+        String arg_;
+        BaseTypeName base_type_name_;
+      };
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), member_ (c)
+        {
+          inherits_member_ >> member_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* be (0);
+            IsEnumBasedType t (be);
+            t.dispatch (e);
+
+            enum_based = (be != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          // Get to the ultimate base and see if is a fundamental type.
+          //
+          bool fund_based (false);
+          SemanticGraph::Type& ult_base (ultimate_base (e));
+          {
+            IsFundamentalType t (fund_based);
+            t.dispatch (ult_base);
+          }
+
+          //
+          //
+          String base; // base type name
+          {
+            std::wostringstream o;
+
+            BaseTypeName base_type (*this, o);
+            Traversal::Inherits inherits_type (base_type);
+
+            inherits (e, inherits_type);
+            base = o.str ();
+          }
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          // default c-tor
+          //
+          bool list_based (
+            ult_base.is_a<SemanticGraph::List> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::NameTokens> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::IdRefs> () ||
+            ult_base.is_a<SemanticGraph::Fundamental::Entities> ());
+
+          if (options.generate_default_ctor () || list_based)
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " ()" << endl
+               << ": " << base << " ()"
+               << "{"
+               << "}";
+          }
+
+          // c-tor (value)
+          //
+          if (string_based)
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " (" << value << " v)" << endl
+               << ": ";
+
+            // If we are enum-based then we can just use the corresponding
+            // base c-tor directly. Otherwise we will use the from-string
+            // c-tor.
+            //
+            if (enum_based)
+              os << base << " (v)";
+            else
+            {
+              CtorCallSequence t (*this, L"_xsd_" + name + L"_literals_[v]");
+              t.dispatch (e.inherits ().base ());
+            }
+
+            os << "{"
+               << "}";
+          }
+
+          // c-tor (const char*)
+          //
+          if (string_based)
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " (const " << char_type << "* v)" << endl
+               << ": " << base << " (v)"
+               << "{"
+               << "}";
+          }
+
+          // c-tor (const std::string&)
+          //
+          if (string_based)
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " (const " << string_type << "& v)" << endl
+               << ": " << base << " (v)"
+               << "{"
+               << "}";
+          }
+
+          // c-tor (fundamental)
+          //
+          if (fund_based)
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " (";
+
+            member_.dispatch (ult_base);
+
+            os << " v)"
+               << ": " << base << " (v)"
+               << "{"
+               << "}";
+          }
+
+          // c-tor (base)
+          //
+          // If the ultimate is also our immediate base and it is a
+          // fundamental type then this c-tor clashes with c-tor
+          // (fundamental) above.
+          //
+          if (!fund_based || &ult_base != &e.inherits ().base ())
+          {
+            os << inl
+               << name << "::" <<  endl
+               << name << " (const ";
+
+          inherits (e, inherits_member_);
+
+          os << "& v)" << endl
+             << ": " << base << " (v)"
+             << "{"
+             << "}";
+          }
+
+          // copy c-tor
+          //
+          os << inl
+             << name << "::" <<  endl
+             << name << " (const " << name << "& v," << endl
+             << flags_type << " f," << endl
+             << container << "* c)" << endl
+             << ": " << base << " (v, f, c)"
+             << "{"
+             << "}";
+
+          // operato= (value)
+          //
+          if (string_based)
+          {
+            os << inl
+               << name << "& " << name << "::" << endl
+               << "operator= (" << value << " v)"
+               << "{"
+               << "static_cast< " << base << "& > (*this) = ";
+
+            // If we are enum-based then we can just use the corresponding
+            // base assignment directly. Otherwise we will use the from-
+            // base assignment and a from-string base c-tor.
+            //
+            if (enum_based)
+              os << "v";
+            else
+            {
+              os << endl;
+
+              CtorCallSequence t (*this, L"_xsd_" + name + L"_literals_[v]");
+              t.dispatch (e.inherits ().base ());
+            }
+
+            os << ";"
+               << endl
+               << "return *this;"
+               << "}";
+          }
+
+          os << endl;
+        }
+
+      private:
+        Traversal::Inherits inherits_member_;
+        MemberTypeName member_;
+      };
+
+      struct Member: Traversal::Member, Context
+      {
+        Member (Context& c, String const& scope)
+            : Context (c), scope_ (scope), lit_value_ (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& aname (eaname (m));
+          String const& mname (emname (m));
+          String const& member (emember (m));
+
+          bool fund (false);
+          {
+            IsFundamentalType t (fund);
+            t.dispatch (m.type ());
+          }
+
+          bool def_attr (m.default_p () &&
+                            m.is_a<SemanticGraph::Attribute> ());
+
+          if (max (m) != 1)
+          {
+            // sequence
+            //
+            String container (econtainer (m));
+            String q_container (scope_ + L"::" + container);
+
+            // container const&
+            // name () const;
+            //
+            os << inl
+               << "const " << q_container << "& " << scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // container&
+            // name ();
+            //
+            os << inl
+               << q_container << "& " << scope_ << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // void
+            // name (container const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << container << "& s)"
+               << "{"
+               << "this->" << member << " = s;"
+               << "}";
+          }
+          else if (min (m) == 0 && !def_attr)
+          {
+            // optional
+            //
+            String type (etype (m));
+            String container (econtainer (m));
+            String q_container (scope_ + L"::" + container);
+
+            // container const&
+            // name () const;
+            //
+            os << inl
+               << "const " << q_container << "& " << scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // container&
+            // name ();
+            //
+            os << inl
+               << q_container << "& " << scope_ << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // void
+            // name (type const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << type << "& x)"
+               << "{"
+               << "this->" << member << ".set (x);"
+               << "}";
+
+            // void
+            // name (container const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << container << "& x)"
+               << "{"
+               << "this->" << member << " = x;"
+               << "}";
+
+            // void
+            // name (auto_ptr<type>);
+            //
+            if (!fund)
+              os << inl
+                 << "void " << scope_ << "::" << endl
+                 << mname << " (" << auto_ptr << "< " << type << " > x)"
+                 << "{"
+                 << "this->" << member << ".set (" <<
+                (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
+                 << "}";
+          }
+          else
+          {
+            // one
+            //
+            String type (etype (m));
+            String q_type (scope_ + L"::" + type);
+
+            // type const&
+            // name () const;
+            //
+            os << inl
+               << "const " << q_type << "& " << scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ".get ();"
+               << "}";
+
+            // Do not generate modifiers for fixed attributes.
+            //
+            if (!(def_attr && m.fixed_p ()))
+            {
+              // type&
+              // name ();
+              //
+              os << inl
+                 << q_type << "& " << scope_ << "::" << endl
+                 << aname << " ()"
+                 << "{"
+                 << "return this->" << member << ".get ();"
+                 << "}";
+
+              // void
+              // name (type const&);
+              //
+              os << inl
+                 << "void " << scope_ << "::" << endl
+                 << mname << " (const " << type << "& x)"
+                 << "{"
+                 << "this->" << member << ".set (x);"
+                 << "}";
+
+              // void
+              // name (auto_ptr<type>);
+              //
+              if (!fund)
+                os << inl
+                   << "void " << scope_ << "::" << endl
+                   << mname << " (" << auto_ptr << "< " << type << " > x)"
+                   << "{"
+                   << "this->" << member << ".set (" <<
+                  (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
+                   << "}";
+
+              // auto_ptr<type>
+              // detach_name ();
+              //
+              if (detach && !fund)
+                os << inl
+                   << auto_ptr << "< " << q_type << " > " <<
+                  scope_ << "::" << endl
+                   << edname (m) << " ()"
+                   << "{"
+                   << "return this->" << member << ".detach ();"
+                   << "}";
+            }
+          }
+
+
+          // default_value
+          //
+          if (m.default_p ())
+          {
+            bool simple (true);
+
+            if (m.is_a<SemanticGraph::Element> ())
+            {
+              IsSimpleType test (simple);
+              test.dispatch (m.type ());
+            }
+
+            if (simple)
+            {
+              String lit (lit_value_.dispatch (m.type (), m.value ()));
+
+              os << inl;
+
+              if (lit)
+                os << scope_ << "::" << etype (m) << " ";
+              else
+                os << "const " << scope_ << "::" << etype (m) << "& ";
+
+              os << scope_ << "::" << endl
+                 << edefault_value (m) << " ()"
+                 << "{";
+
+              if (lit)
+                os << "return " << etype (m) << " (" << lit << ");";
+              else
+                os << "return " << edefault_value_member (m) << ";";
+
+              os << "}";
+            }
+          }
+        }
+
+      private:
+        String scope_;
+        LiteralValue lit_value_;
+      };
+
+      struct Any: Traversal::Any,
+                  Traversal::AnyAttribute,
+                  Context
+      {
+        Any (Context& c, String const& scope)
+            : Context (c), scope_ (scope)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& aname (eaname (a));
+          String const& mname (emname (a));
+
+          String const& member (emember (a));
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            String container (econtainer (a));
+            String q_container (scope_ + L"::" + container);
+
+            // container const&
+            // name () const;
+            //
+            os << inl
+               << "const " << q_container << "& " << scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // container&
+            // name ();
+            //
+            os << inl
+               << q_container << "& " << scope_ << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // void
+            // name (container const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << container << "& s)"
+               << "{"
+               << "this->" << member << " = s;"
+               << "}";
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            String container (econtainer (a));
+            String q_container (scope_ + L"::" + container);
+
+            // container const&
+            // name () const;
+            //
+            os << inl
+               << "const " << q_container << "& " << scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // container&
+            // name ();
+            //
+            os << inl
+               << q_container << "& " << scope_ << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << member << ";"
+               << "}";
+
+            // void
+            // name (type const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << xerces_ns << "::DOMElement& e)"
+               << "{"
+               << "this->" << member << ".set (e);"
+               << "}";
+
+            // void
+            // name (type*);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (" << xerces_ns << "::DOMElement* e)"
+               << "{"
+               << "this->" << member << ".set (e);"
+               << "}";
+
+            // void
+            // name (container const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << container << "& x)"
+               << "{"
+               << "this->" << member << " = x;"
+               << "}";
+          }
+          else
+          {
+            // one
+            //
+
+            // type const&
+            // name () const;
+            //
+            os << inl
+               << "const " << xerces_ns << "::DOMElement& " <<
+              scope_ << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << member << ".get ();"
+               << "}";
+
+            // type&
+            // name ();
+            //
+            os << inl
+               << xerces_ns << "::DOMElement& " << scope_ << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << member << ".get ();"
+               << "}";
+
+            // void
+            // name (type const&);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (const " << xerces_ns << "::DOMElement& e)"
+               << "{"
+               << "this->" << member << ".set (e);"
+               << "}";
+
+            // void
+            // name (type*);
+            //
+            os << inl
+               << "void " << scope_ << "::" << endl
+               << mname << " (" << xerces_ns << "::DOMElement* e)"
+               << "{"
+               << "this->" << member << ".set (e);"
+               << "}";
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& aname (eaname (a));
+          String const& mname (emname (a));
+
+          String const& member (emember (a));
+          String container (econtainer (a));
+          String q_container (scope_ + L"::" + container);
+
+          // container const&
+          // name () const;
+          //
+          os << inl
+             << "const " << q_container << "& " << scope_ << "::" << endl
+             << aname << " () const"
+             << "{"
+             << "return this->" << member << ";"
+             << "}";
+
+          // container&
+          // name ();
+          //
+          os << inl
+             << q_container << "& " << scope_ << "::" << endl
+             << aname << " ()"
+             << "{"
+             << "return this->" << member << ";"
+             << "}";
+
+          // void
+          // name (container const&);
+          //
+          os << inl
+             << "void " << scope_ << "::" << endl
+             << mname << " (const " << container << "& s)"
+             << "{"
+             << "this->" << member << " = s;"
+             << "}";
+        }
+
+      private:
+        String scope_;
+      };
+
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (c, name) && !name)
+            return;
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          // Generate accessors and modifiers.
+          //
+          Any any (*this, name);
+          Member member (*this, name);
+          Traversal::Names names;
+
+          if (options.generate_wildcard ())
+            names >> any;
+
+          names >> member;
+
+          Complex::names (c, names);
+
+          // Mixed text content.
+          //
+          if (mixed_p (c) && !c.context ().count ("mixed-in-base"))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& cont (ctx.get<String> ("mixed-container"));
+            String const& memb (ctx.get<String> ("mixed-member"));
+
+            String const& aname (ctx.get<String> ("mixed-aname"));
+            String const& mname (ctx.get<String> ("mixed-mname"));
+
+            os << inl
+               << "const " << name << "::" << cont << "& " <<
+              name << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << name << "::" << cont << "& " << name << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << "void " << name << "::" << endl
+               << mname << " (const " << cont << "& s)"
+               << "{"
+               << "this->" << memb << " = s;"
+               << "}";
+          }
+
+          // dom_document accessors.
+          //
+          if (edom_document_member_p (c))
+          {
+            os << inl
+               << "const " << xerces_ns << "::DOMDocument& " <<
+              name << "::" << endl
+               << edom_document (c) << " () const"
+               << "{"
+               << "return *this->" << edom_document_member (c) << ";"
+               << "}";
+
+            os << inl
+               << xerces_ns << "::DOMDocument& " << name << "::" << endl
+               << edom_document (c) << " ()"
+               << "{"
+               << "return *this->" << edom_document_member (c) << ";"
+               << "}";
+          }
+
+          // Order container.
+          //
+          if (ordered_p (c) && !c.context ().count ("order-in-base"))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& cont (ctx.get<String> ("order-container"));
+            String const& memb (ctx.get<String> ("order-member"));
+
+            String const& aname (ctx.get<String> ("order-aname"));
+            String const& mname (ctx.get<String> ("order-mname"));
+
+            os << inl
+               << "const " << name << "::" << cont << "& " <<
+              name << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << name << "::" << cont << "& " << name << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << "void " << name << "::" << endl
+               << mname << " (const " << cont << "& s)"
+               << "{"
+               << "this->" << memb << " = s;"
+               << "}";
+          }
+
+          os << endl;
+        }
+      };
+
+
+      struct GlobalElement: Traversal::Element,
+                            GlobalElementBase,
+                            Context
+      {
+        GlobalElement (Context& c)
+            : GlobalElementBase (c), Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (!doc_root_p (e))
+            return;
+
+          bool fund (false);
+          {
+            IsFundamentalType test (fund);
+            test.dispatch (e.type ());
+          }
+
+          String const& name (ename (e));
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          // Accessors/modifiers.
+          //
+          String const& type (etype (e));
+          String const& aname (eaname (e));
+          String const& mname (emname (e));
+          String const& member (emember (e));
+
+          // type const&
+          // name () const;
+          //
+          os << inl
+             << "const " << name << "::" << type << "& " << name << "::" << endl
+             << aname << " () const"
+             << "{"
+             << "return this->" << member << ".get ();"
+             << "}";
+
+          // type&
+          // name ();
+          //
+          os << inl
+             << name << "::" << type << "& " << name << "::" << endl
+             << aname << " ()"
+             << "{"
+             << "return this->" << member << ".get ();"
+             << "}";
+
+          // void
+          // name (type const&);
+          //
+          os << inl
+             << "void " << name << "::" << endl
+             << mname << " (const " << type << "& x)"
+             << "{"
+             << "this->" << member << ".set (x);"
+             << "}";
+
+          // void
+          // name (auto_ptr<type>);
+          //
+          if (!fund)
+          {
+            os << inl
+               << "void " << name << "::" << endl
+               << mname << " (" << auto_ptr  << "< " << type << " > x)"
+               << "{"
+               << "this->" << member << ".set (" <<
+              (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
+               << "}";
+          }
+
+          // auto_ptr<type>
+          // detach_name ();
+          //
+          if (detach && !fund)
+            os << inl
+               << auto_ptr << "< " << name << "::" << type << " > " <<
+              name << "::" << endl
+               << edname (e) << " ()"
+               << "{"
+               << "return this->" << member << ".detach ();"
+               << "}";
+        }
+      };
+    }
+
+    void
+    generate_tree_inline (Context& ctx, size_t first, size_t last)
+    {
+      // Generate includes.
+      //
+      if (ctx.options.generate_inline ())
+      {
+        Traversal::Schema schema;
+        Includes includes (ctx, Includes::inline_);
+
+        schema >> includes;
+
+        schema.dispatch (ctx.schema_root);
+      }
+      else
+      {
+        // Emit "weak" header includes that are used in the file-per-type
+        // compilation model.
+        //
+        Traversal::Schema schema;
+        Includes includes (ctx, Includes::source);
+
+        schema >> includes;
+
+        schema.dispatch (ctx.schema_root);
+      }
+
+      Traversal::Schema schema;
+      Sources sources;
+      Traversal::Names names_ns, names;
+      Namespace ns (ctx, first, last);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+      GlobalElement element (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+
+      if (ctx.options.generate_element_type ())
+        names >> element;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/tree-inline.hxx b/xsd/cxx/tree/tree-inline.hxx
new file mode 100644
index 0000000..dad4c24
--- /dev/null
+++ b/xsd/cxx/tree/tree-inline.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/tree-inline.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_TREE_INLINE_HXX
+#define XSD_CXX_TREE_TREE_INLINE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_tree_inline (Context&, size_t first, size_t last);
+  }
+}
+
+#endif  // XSD_CXX_TREE_TREE_INLINE_HXX
diff --git a/xsd/cxx/tree/tree-source.cxx b/xsd/cxx/tree/tree-source.cxx
new file mode 100644
index 0000000..89419af
--- /dev/null
+++ b/xsd/cxx/tree/tree-source.cxx
@@ -0,0 +1,3912 @@
+// file      : xsd/cxx/tree/tree-source.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <map>
+#include <list>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/tree-source.hxx>
+#include <xsd/cxx/tree/default-value.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct List: Traversal::List, Context
+      {
+        List (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& l)
+        {
+          String name (ename (l));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (l, name) && !name)
+            return;
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          if (!options.suppress_parsing ())
+          {
+            SemanticGraph::Type& item_type (l.argumented ().type ());
+            String base (L"::xsd::cxx::tree::list< " +
+                         item_type_name (item_type) + L", " + char_type);
+
+            if (item_type.is_a<SemanticGraph::Fundamental::Double> ())
+              base += L", ::xsd::cxx::tree::schema_type::double_";
+            else if (item_type.is_a<SemanticGraph::Fundamental::Decimal> ())
+              base += L", ::xsd::cxx::tree::schema_type::decimal";
+
+            base += L" >";
+
+            // c-tor (xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << any_simple_type << " (e, f, c)," << endl
+               << "  " << base << " (e, f, this)"
+               << "{"
+               << "}";
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << any_simple_type << " (a, f, c)," << endl
+               << "  " << base << " (a, f, this)"
+               << "{"
+               << "}";
+
+            // c-tor (string const&, xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << any_simple_type << " (s, e, f, c)," << endl
+               << "  " << base << " (s, e, f, this)"
+               << "{"
+               << "}";
+          }
+
+          // _clone
+          //
+          os << name << "* " << name << "::" << endl
+             << "_clone (" << flags_type << " f," << endl
+             << container << "* c) const"
+             << "{"
+             << "return new class " << name << " (*this, f, c);"
+             << "}";
+
+          // d-tor
+          //
+          os << name << "::" << endl
+             << "~" << name << " ()"
+             << "{"
+             << "}";
+
+          // Register with type factory map.
+          //
+          if (polymorphic && polymorphic_p (l))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (l));
+
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (l) && !options.suppress_parsing ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_type_factory_init (" << endl
+                 << strlit (l.name ()) << "," << endl
+                 << strlit (xml_ns_name (l)) << ");"
+                 << endl;
+            }
+
+            if ((!anonymous_p (l) || anonymous_substitutes_p (l)) &&
+                options.generate_comparison ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_comparison_init;"
+                 << endl;
+            }
+          }
+        }
+
+      private:
+        String
+        item_type_name (SemanticGraph::Type& t)
+        {
+          std::wostringstream o;
+
+          MemberTypeName type (*this, o);
+          type.dispatch (t);
+
+          return o.str ();
+        }
+      };
+
+
+      struct Union: Traversal::Union, Context
+      {
+        Union (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& u)
+        {
+          String name (ename (u));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (u, name) && !name)
+            return;
+
+          String const& base (xs_string_type);
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (e, f, c)"
+               << "{"
+               << "}";
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (a, f, c)"
+               << "{"
+               << "}";
+
+            // c-tor (string const&, xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (s, e, f, c)"
+               << "{"
+               << "}";
+          }
+
+          // _clone
+          //
+          os << name << "* " << name << "::" << endl
+             << "_clone (" << flags_type << " f," << endl
+             << container << "* c) const"
+             << "{"
+             << "return new class " << name << " (*this, f, c);"
+             << "}";
+
+          // Register with type factory map.
+          //
+          if (polymorphic && polymorphic_p (u))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (u));
+
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (u) && !options.suppress_parsing ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_type_factory_init (" << endl
+                 << strlit (u.name ()) << "," << endl
+                 << strlit (xml_ns_name (u)) << ");"
+                 << endl;
+            }
+
+            if ((!anonymous_p (u) || anonymous_substitutes_p (u)) &&
+                options.generate_comparison ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_comparison_init;"
+                 << endl;
+            }
+          }
+        }
+      };
+
+
+      // Enumeration mapping.
+      //
+
+      struct EnumeratorLiteral: Traversal::Enumerator, Context
+      {
+        EnumeratorLiteral (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          os << strlit (e.name ());
+        }
+      };
+
+
+      //
+      //
+      struct LiteralInfo
+      {
+        LiteralInfo (String const& value, String const& name)
+            : value_ (value), name_ (name)
+        {
+        }
+
+        String value_;
+        String name_;
+      };
+
+      bool
+      operator< (LiteralInfo const& x, LiteralInfo const& y)
+      {
+        return x.value_ < y.value_;
+      }
+
+      typedef list<LiteralInfo> LiteralInfoList;
+
+
+      // Populate LiteralInfoList
+      //
+      struct EnumeratorLiteralInfo: Traversal::Enumerator, Context
+
+      {
+        EnumeratorLiteralInfo (Context& c, LiteralInfoList& list)
+            : Context (c), list_ (list)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          list_.push_back (LiteralInfo (e.name (), ename (e)));
+        }
+
+      private:
+        LiteralInfoList& list_;
+      };
+
+
+      struct Enumeration: Traversal::Enumeration, Context
+      {
+        Enumeration (Context& c)
+            : Context (c), enumerator_literal_ (c)
+        {
+          names_enumerator_literal_ >> enumerator_literal_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          String name (ename (e));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          if (renamed_type (e, name) && !name)
+            return;
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          SemanticGraph::Enumeration* be (0);
+          bool enum_based (false);
+          if (string_based)
+          {
+            IsEnumBasedType t (be);
+            t.dispatch (e);
+
+            enum_based = (be != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          size_t enum_count (0);
+
+          for (Type::NamesIterator i (e.names_begin ()), end (e.names_end ());
+               i != end; ++i)
+            ++enum_count;
+
+          String base; // base type name
+          {
+            std::wostringstream o;
+
+            BaseTypeName base_type (*this, o);
+            Traversal::Inherits inherits_type (base_type);
+
+            inherits (e, inherits_type);
+            base = o.str ();
+          }
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (e, f, c)"
+               << "{";
+
+            if (string_based)
+              os << "_xsd_" << name << "_convert ();";
+
+            os << "}";
+
+
+            // c-tor (xercesc::DOMAttr)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (a, f, c)"
+               << "{";
+
+            if (string_based)
+            {
+              os << "_xsd_" << name << "_convert ();";
+            }
+
+            os << "}";
+
+
+            // c-tor (string const&, xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << string_type << "& s," << endl
+               << "const " << xerces_ns << "::DOMElement* e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (s, e, f, c)"
+               << "{";
+
+            if (string_based)
+            {
+              os << "_xsd_" << name << "_convert ();";
+            }
+
+            os << "}";
+          }
+
+          // _clone
+          //
+          os << name << "* " << name << "::" << endl
+             << "_clone (" << flags_type << " f," << endl
+             << container << "* c) const"
+             << "{"
+             << "return new class " << name << " (*this, f, c);"
+             << "}";
+
+          // convert
+          //
+          // @@ TODO: expected list
+          //
+          if (string_based)
+          {
+            String i_name (L"_xsd_" + name + L"_indexes_");
+
+            os << name << "::" << value << " " <<
+              name << "::" << endl
+               << "_xsd_" << name << "_convert () const"
+               << "{"
+               << "::xsd::cxx::tree::enum_comparator< " << char_type <<
+              " > c (_xsd_" << name << "_literals_);"
+               << "const " << value << "* i (::std::lower_bound (" << endl
+               << i_name << "," << endl
+               << i_name << " + " << enum_count << "," << endl
+               << "*this," << endl
+               << "c));"
+               << endl
+               << "if (i == " << i_name << " + " << enum_count << " || " <<
+              "_xsd_" << name << "_literals_[*i] != *this)"
+               << "{"
+               << "throw ::xsd::cxx::tree::unexpected_enumerator < " <<
+              char_type << " > (*this);"
+               << "}"
+               << "return *i;"
+               << "}";
+          }
+
+          // literals and indexes
+          //
+          if (string_based)
+          {
+            if (enum_based)
+            {
+              os << "const " << char_type << "* const* " << name << "::" << endl
+                 << "_xsd_" << name << "_literals_ = " <<
+                fq_name (*be) << "::_xsd_" << ename (*be) << "_literals_;"
+                 << endl;
+            }
+            else
+            {
+              os << "const " << char_type << "* const " << name << "::" << endl
+                 << "_xsd_" << name << "_literals_[" << enum_count << "] ="
+                 << "{";
+
+              names<Enumeration> (
+                e, names_enumerator_literal_, 0, 0, 0, &Enumeration::comma);
+
+              os << "};";
+            }
+
+
+            LiteralInfoList l;
+            {
+              EnumeratorLiteralInfo enumerator (*this, l);
+              Traversal::Names names_enumerator (enumerator);
+              names (e, names_enumerator);
+            }
+
+            l.sort ();
+
+            os << "const " << name << "::" << value << " " <<
+              name << "::" << endl
+               << "_xsd_" << name << "_indexes_[" << enum_count << "] ="
+               << "{";
+
+            String fq_name (ns_scope + L"::" + name);
+
+            for (LiteralInfoList::iterator
+                   b (l.begin ()), i (b), end (l.end ()); i != end; ++i)
+            {
+              if (i != b)
+                os << "," << endl;
+
+              os << fq_name << "::" << i->name_;
+            }
+
+            os << "};";
+          }
+
+          // Register with type factory map.
+          //
+          if (polymorphic && polymorphic_p (e))
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (e));
+
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (e) && !options.suppress_parsing ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_type_factory_init (" << endl
+                 << strlit (e.name ()) << "," << endl
+                 << strlit (xml_ns_name (e)) << ");"
+                 << endl;
+            }
+
+            if ((!anonymous_p (e) || anonymous_substitutes_p (e)) &&
+                options.generate_comparison ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_comparison_init;"
+                 << endl;
+            }
+          }
+        }
+
+        virtual void
+        comma (Type&)
+        {
+          os << "," << endl;
+        }
+
+      private:
+        Traversal::Names names_enumerator_literal_;
+        EnumeratorLiteral enumerator_literal_;
+
+      };
+
+      //
+      //
+      struct Member: Traversal::Member, Context
+      {
+        Member (Context& c, String const& scope)
+            : Context (c), scope_ (scope), init_value_ (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+	  if (skip (m))
+            return;
+
+          // default_value
+          //
+          if (m.default_p ())
+          {
+            SemanticGraph::Type& t (m.type ());
+            bool simple (true);
+
+            if (m.is_a<SemanticGraph::Element> ())
+            {
+              IsSimpleType test (simple);
+              test.dispatch (t);
+            }
+
+            if (simple)
+            {
+              bool lit (false);
+              {
+                IsLiteralValue test (lit);
+                test.dispatch (t);
+              }
+
+              if (!lit)
+              {
+                InitKind::Kind kind (InitKind::simple);
+                {
+                  InitKind test (kind);
+                  test.dispatch (t);
+                }
+
+                String const& member (edefault_value_member (m));
+
+                String init_name;
+
+                switch (kind)
+                {
+                case InitKind::data:
+                  {
+                    init_name = escape (L"_xsd_" + scope_ + member + L"data");
+                    init_value_.data (init_name);
+                    init_value_.dispatch (t, m.value ());
+                    break;
+                  }
+                case InitKind::function:
+                  {
+                    init_name = escape (L"_xsd_" + scope_ + member + L"init");
+
+                    os << "static " << scope_ << "::" << etype (m) << endl
+                       << init_name << " ()"
+                       << "{"
+                       << scope_ << "::" << etype (m) << " r;"
+                       << endl;
+
+                    init_value_.dispatch (t, m.value ());
+
+                    os << "return r;"
+                       << "};";
+                    break;
+                  }
+                case InitKind::simple:
+                  break;
+                }
+
+                os << "const " << scope_ << "::" << etype (m) << " " <<
+                  scope_ << "::" << member << " (" << endl;
+
+                switch (kind)
+                {
+                case InitKind::data:
+                  {
+                    // Second dispatch.
+                    //
+                    init_value_.dispatch (t, m.value ());
+                    break;
+                  }
+                case InitKind::function:
+                  {
+                    os << init_name << " ()";
+                    break;
+                  }
+                case InitKind::simple:
+                  {
+                    init_value_.dispatch (t, m.value ());
+                    break;
+                  }
+                }
+
+                os << ");"
+                   << endl;
+              }
+            }
+          }
+        }
+
+      private:
+        String scope_;
+        InitValue init_value_;
+      };
+
+
+      struct Element: Traversal::Element, Context
+      {
+        Element (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e))
+            return;
+
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (e.scope ()));
+
+          String const& member (emember (e));
+
+          String tr (etraits (e)); // traits type name
+          String type (etype (e));
+
+          SemanticGraph::Type& t (e.type ());
+
+          bool fund (false);
+          {
+            IsFundamentalType traverser (fund);
+            traverser.dispatch (t);
+          }
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything. Note that if the type is anonymous then it can't be
+          // derived from which makes it impossible to substitute or
+          // dynamically-type with xsi:type.
+          //
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          os << "// " << comment (e.name ()) << endl
+             << "//" << endl;
+
+          if (poly)
+          {
+            os << "{"
+               << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
+               << strlit (e.name ()) << "," << endl
+               << (e.qualified_p ()
+                   ? strlit (e.namespace_ ().name ())
+                   : L + String ("\"\"")) << "," << endl;
+
+            SemanticGraph::Complex* tc;
+            if ((tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+                tc->abstract_p ())
+              os << "0,";
+            else
+              os << "&::xsd::cxx::tree::factory_impl< " << type << " >,";
+
+            os << endl
+               << (e.global_p () ? "true" : "false") << ", " <<
+              (e.qualified_p () ? "true" : "false") << ", " <<
+              "i, n, f, this));"
+               << endl
+               << "if (tmp.get () != 0)"
+               << "{";
+          }
+          else
+          {
+            if (e.qualified_p () && e.namespace_ ().name ())
+            {
+              os << "if (n.name () == " << strlit (e.name ()) << " && " <<
+                "n.namespace_ () == " << strlit (e.namespace_ ().name ()) << ")"
+                 << "{";
+            }
+            else
+            {
+              os << "if (n.name () == " << strlit (e.name ()) << " && " <<
+                "n.namespace_ ().empty ())"
+                 << "{";
+            }
+
+            if (!fund)
+            {
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (i, f";
+
+              if (t.is_a<SemanticGraph::AnyType> () &&
+                  options.generate_any_type ())
+                os << " | " << flags_type << "::extract_content";
+
+              os << ", this));"
+                 << endl;
+            }
+          }
+
+
+          // Checks. Disabled at the moment since they make it impossible to
+          // parse valid instances where the same element is used in both
+          // base and derived types. See the cxx/tree/name-clash/inheritance
+          // test for details.
+          //
+          //
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            os << "if (!this->" << member << ")"
+               << "{";
+          }
+          else
+          {
+            // one
+            //
+            os << "if (!" << member << ".present ())"
+               << "{";
+          }
+
+
+          if (poly || !fund)
+          {
+            if (poly)
+            {
+              // Cast to static type.
+              //
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << "dynamic_cast< " << type << "* > (tmp.get ()));"
+                 << endl
+                 << "if (r.get ())" << endl
+                 << "tmp.release ();"
+                 << "else" << endl
+                 << "throw ::xsd::cxx::tree::not_derived< " << char_type <<
+                " > ();"
+                 << endl;
+            }
+
+            char const* r (std >= cxx_version::cxx11 ? "::std::move (r)" : "r");
+
+            if (max (e) != 1)
+            {
+              // sequence
+              //
+              os << "this->" << member << ".push_back (" << r << ");";
+            }
+            else if (min (e) == 0)
+            {
+              // optional
+              //
+              os << "this->" << member << ".set (" << r << ");";
+            }
+            else
+            {
+              // one
+              //
+              os << "this->" << member << ".set (" << r << ");";
+            }
+          }
+          else
+          {
+            if (max (e) != 1)
+            {
+              // sequence
+              //
+              os << "this->" << member << ".push_back (" << tr <<
+                "::create (i, f, this));";
+            }
+            else if (min (e) == 0)
+            {
+              // optional
+              //
+              os << "this->" << member << ".set (" << tr <<
+                "::create (i, f, this));";
+            }
+            else
+            {
+              // one
+              //
+              os << "this->" << member << ".set (" << tr <<
+                "::create (i, f, this));";
+            }
+          }
+
+          // Capture order.
+          //
+          if (ordered_p (c))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& t (ctx.get<String> ("order-type"));
+            String const& m (ctx.get<String> ("order-member"));
+
+            os << "this->" << m << ".push_back (" << endl
+               << t << " (" <<
+              e.context ().get<String> ("ordered-id-name");
+
+            // sequence
+            //
+            if (max (e) != 1)
+              os << ", " << "this->" << member << ".size () - 1";
+
+            os << "));";
+          }
+
+          os << "continue;";
+
+          // End of check block.
+          //
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            os << "}";
+          }
+          else
+          {
+            // one
+            //
+            os << "}";
+          }
+
+          os << "}"; // if block
+
+          if (poly)
+            os << "}";
+        }
+      };
+
+      struct ElementTest: Traversal::Element, Context
+      {
+        ElementTest (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          if (skip (e))
+            return;
+
+          if (max (e) == 1 && min (e) == 1)
+          {
+            // one
+            //
+            os << "if (!" << emember (e) << ".present ())"
+               << "{"
+               << "throw ::xsd::cxx::tree::expected_element< " <<
+              char_type << " > (" << endl
+               << strlit (e.name ()) << "," << endl
+               << (e.qualified_p ()
+                   ? strlit (e.namespace_ ().name ())
+                   : L + String ("\"\"")) << ");"
+               << "}";
+          }
+        }
+      };
+
+      struct Any: Traversal::Any, Context
+      {
+        Any (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& member (emember (a));
+
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          String const& ns (a.definition_namespace ().name ());
+          String const& dom_doc (edom_document (c));
+
+          os << "// " << ename (a) << endl
+             << "//" << endl
+             << "if (";
+
+          for (SemanticGraph::Any::NamespaceIterator i (a.namespace_begin ()),
+                 e (a.namespace_end ()); i != e;)
+          {
+            if (*i == L"##any")
+            {
+              os << "true";
+            }
+            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 << "(!n.namespace_ ().empty () && " <<
+                  "n.namespace_ () != " << strlit (ns) << ")";
+              }
+              else
+                os << "!n.namespace_ ().empty ()";
+            }
+            else if (*i == L"##local")
+            {
+              os << "n.namespace_ ().empty ()";
+            }
+            else if (*i == L"##targetNamespace")
+            {
+              os << "n.namespace_ () == " << strlit (ns);
+            }
+            else
+            {
+              os << "n.namespace_ () == " << strlit (*i);
+            }
+
+            if (++i != e)
+              os << " ||" << endl;
+          }
+
+          os << ")"
+             << "{";
+
+
+          // Checks.
+          //
+          //
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            os << "if (!this->" << member << ")"
+               << "{";
+          }
+          else
+          {
+            // one
+            //
+            os << "if (!" << member << ".present ())"
+               << "{";
+          }
+
+          os << xerces_ns << "::DOMElement* r (" << endl
+             << "static_cast< " << xerces_ns << "::DOMElement* > (" << endl
+             << "this->" << dom_doc << " ().importNode (" << endl
+             << "const_cast< " << xerces_ns << "::DOMElement* > (&i), true)));";
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            os << "this->" << member << ".push_back (r);";
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            os << "this->" << member << ".set (r);";
+          }
+          else
+          {
+            // one
+            //
+            os << "this->" << member << ".set (r);";
+          }
+
+          // Capture order.
+          //
+          if (ordered_p (c))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& t (ctx.get<String> ("order-type"));
+            String const& m (ctx.get<String> ("order-member"));
+
+            os << "this->" << m << ".push_back (" << endl
+               << t << " (" <<
+              a.context ().get<String> ("ordered-id-name") << ", ";
+
+            if (max (a) != 1)
+              // sequence
+              //
+              os << "this->" << member << ".size () - 1";
+            else
+              // optional & one
+              //
+              os << "0";
+
+            os << "));";
+          }
+
+          os << "continue;";
+
+          // End of check block.
+          //
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            os << "}";
+          }
+          else
+          {
+            // one
+            //
+            os << "}";
+          }
+
+          os << "}"; // if block
+        }
+      };
+
+      struct AnyTest: Traversal::Any, Context
+      {
+        AnyTest (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          if (max (a) == 1 && min (a) == 1)
+          {
+            // one
+            //
+            os << "if (!" << emember (a) << ".present ())"
+               << "{"
+               << "throw ::xsd::cxx::tree::expected_element< " <<
+              char_type << " > (" << endl
+               << L << "\"*\"," << endl
+               << strlit (*a.namespace_begin ()) << ");"
+               << "}";
+          }
+        }
+      };
+
+      struct Attribute: Traversal::Attribute, Context
+      {
+        Attribute (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& member (emember (a));
+
+          String const& tr (etraits (a)); // traits type name
+
+          if (a.qualified_p () && a.namespace_ ().name ())
+          {
+            os << "if (n.name () == " << strlit (a.name ()) << " && " <<
+              "n.namespace_ () == " << strlit (a.namespace_ ().name ()) << ")"
+               << "{";
+          }
+          else
+          {
+            os << "if (n.name () == " << strlit (a.name ()) << " && " <<
+              "n.namespace_ ().empty ())"
+               << "{";
+          }
+
+          os << "this->" << member << ".set (" << tr <<
+            "::create (i, f, this));";
+
+          os << "continue;"
+             << "}";
+
+        }
+      };
+
+      struct AnyAttribute: Traversal::AnyAttribute, Context
+      {
+        AnyAttribute (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& member (emember (a));
+
+          String const& ns (a.definition_namespace ().name ());
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "// " << ename (a) << endl
+             << "//" << endl
+             << "if (";
+
+          // Note that we need to filter out namespaces for xmlns and
+          // xsi.
+          //
+          for (SemanticGraph::Any::NamespaceIterator i (a.namespace_begin ()),
+                 e (a.namespace_end ()); i != e;)
+          {
+            if (*i == L"##any")
+            {
+              os << "(n.namespace_ () != " <<
+                "::xsd::cxx::xml::bits::xmlns_namespace< " << char_type <<
+                " > () &&" << endl
+                 << "n.namespace_ () != " <<
+                "::xsd::cxx::xml::bits::xsi_namespace< " << char_type <<
+                " > ())";
+            }
+            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 << "(!n.namespace_ ().empty () &&" << endl
+                   << "n.namespace_ () != " << strlit (ns) << " &&" <<endl
+                   << "n.namespace_ () != " <<
+                  "::xsd::cxx::xml::bits::xmlns_namespace< " << char_type <<
+                  " > () &&" << endl
+                   << "n.namespace_ () != " <<
+                  "::xsd::cxx::xml::bits::xsi_namespace< " << char_type <<
+                  " > ())";
+              }
+              else
+                os << "(!n.namespace_ ().empty () &&" << endl
+                   << "n.namespace_ () != " <<
+                  "::xsd::cxx::xml::bits::xmlns_namespace< " << char_type <<
+                  " > () &&" << endl
+                   << "n.namespace_ () != " <<
+                  "::xsd::cxx::xml::bits::xsi_namespace< " << char_type <<
+                  " > ())";
+            }
+            else if (*i == L"##local")
+            {
+              os << "n.namespace_ ().empty ()";
+            }
+            else if (*i == L"##targetNamespace")
+            {
+              os << "n.namespace_ () == " << strlit (ns);
+            }
+            else
+            {
+              os << "n.namespace_ () == " << strlit (*i);
+            }
+
+            if (++i != e)
+              os << " ||" << endl;
+          }
+
+          os << ")"
+             << "{"
+             << xerces_ns << "::DOMAttr* r (" << endl
+             << "static_cast< " << xerces_ns << "::DOMAttr* > (" << endl
+             << "this->" << dom_doc << " ().importNode (" << endl
+             << "const_cast< " << xerces_ns << "::DOMAttr* > (&i), true)));"
+             << "this->" << member << " .insert (r);"
+             << "continue;"
+             << "}";
+        }
+      };
+
+
+      struct AttributeTest: Traversal::Attribute, Context
+      {
+        AttributeTest (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& a)
+        {
+          String const& member (emember (a));
+
+          if (!a.optional_p () || a.default_p ())
+          {
+            os << "if (!" << member << ".present ())"
+               << "{";
+
+            if (a.default_p ())
+            {
+              os << "this->" << member << ".set (" <<
+                edefault_value (a) << " ());";
+            }
+            else
+              os << "throw ::xsd::cxx::tree::expected_attribute< " <<
+                char_type << " > (" << endl
+                 << strlit (a.name ()) << "," << endl
+                 << (a.qualified_p ()
+                     ? strlit (a.namespace_ ().name ())
+                     : L + String ("\"\"")) << ");";
+
+            os << "}";
+          }
+        }
+      };
+
+
+      //
+      //
+      struct CtorBase: Traversal::Complex,
+                       Traversal::Enumeration,
+                       Traversal::Type,
+                       Context
+      {
+        // If base_arg is empty then no base argument is generated.
+        //
+        CtorBase (Context& c, CtorArgType at, String const& base_arg)
+            : Context (c), args_ (c, at, base_arg)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Type&)
+        {
+          if (args_.base_arg_)
+            os << args_.base_arg_;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Enumeration&)
+        {
+          if (args_.base_arg_)
+            os << args_.base_arg_;
+        }
+
+        void
+        traverse (SemanticGraph::Complex& c)
+        {
+          args_.traverse (c);
+        }
+
+      private:
+        // No need to traverse AnyAttribute since it is always mapped
+        // to a sequence.
+        //
+        struct Args: Traversal::Complex,
+                     Traversal::Enumeration,
+                     Traversal::Type,
+                     Traversal::Any,
+                     Traversal::Element,
+                     Traversal::Attribute,
+                     Context
+        {
+          Args (Context& c, CtorArgType at, String const& base_arg)
+              : Context (c),
+                arg_type_ (at), base_arg_ (base_arg), first_ (true)
+          {
+            *this >> inherits_ >> *this;
+            *this >> names_ >> *this;
+          }
+
+          virtual void
+          traverse (SemanticGraph::Type&)
+          {
+            if (base_arg_)
+              os << comma () << base_arg_;
+          }
+
+          virtual void
+          traverse (SemanticGraph::Enumeration&)
+          {
+            if (base_arg_)
+              os << comma () << base_arg_;
+          }
+
+          virtual void
+          traverse (SemanticGraph::Any& a)
+          {
+            if (!options.generate_wildcard ())
+              return;
+
+            if (min (a) == 1 && max (a) == 1)
+            {
+              // one
+              //
+              os << comma () << ename (a);
+            }
+          }
+
+          virtual void
+          traverse (SemanticGraph::Element& e)
+          {
+            if (!skip (e) && min (e) == 1 && max (e) == 1)
+            {
+              // one
+              //
+              bool move (false);
+
+              if (std >= cxx_version::cxx11)
+              {
+                switch (arg_type_)
+                {
+                case CtorArgType::complex_auto_ptr:
+                  {
+                    bool simple (true);
+                    IsSimpleType t (simple);
+                    t.dispatch (e.type ());
+                    move = !simple;
+                    break;
+                  }
+                case CtorArgType::poly_auto_ptr:
+                  {
+                    move = polymorphic && polymorphic_p (e.type ());
+                    break;
+                  }
+                case CtorArgType::type:
+                  break;
+                }
+              }
+
+              os << comma () << (move ? "std::move (" : "") << ename (e) <<
+                (move ? ")" : "");
+            }
+          }
+
+          virtual void
+          traverse (SemanticGraph::Attribute& a)
+          {
+            // Note that we are not including attributes with default
+            // or required fixed values here.
+            //
+            if (min (a) == 1 && !a.fixed_p ())
+            {
+              // one
+              //
+              os << comma () << ename (a);
+            }
+          }
+
+          using Complex::traverse;
+
+        private:
+          String
+          comma ()
+          {
+            bool tmp (first_);
+            first_ = false;
+            return tmp ? "" : ",\n";
+          }
+
+        public:
+          CtorArgType arg_type_;
+          String base_arg_;
+
+        private:
+          bool first_;
+
+          Traversal::Inherits inherits_;
+          Traversal::Names names_;
+        };
+
+        Args args_;
+      };
+
+
+      struct CtorMember: Traversal::Element,
+                         Traversal::Attribute,
+                         Context
+      {
+        CtorMember (Context& c, CtorArgType at)
+            : Context (c), arg_type_ (at)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (skip (e))
+            return;
+
+          String const& member (emember (e));
+
+          if (max (e) != 1)
+          {
+            // sequence
+            //
+            os << "," << endl
+               << "  " << member << " (this)";
+          }
+          else if (min (e) == 0)
+          {
+            // optional
+            //
+            os << "," << endl
+               << "  " << member << " (this)";
+          }
+          else
+          {
+            // one
+            //
+            bool move (false);
+
+            if (std >= cxx_version::cxx11)
+            {
+              switch (arg_type_)
+              {
+              case CtorArgType::complex_auto_ptr:
+                {
+                  bool simple (true);
+                  IsSimpleType t (simple);
+                  t.dispatch (e.type ());
+                  move = !simple;
+                  break;
+                }
+              case CtorArgType::poly_auto_ptr:
+                {
+                  move = polymorphic && polymorphic_p (e.type ());
+                  break;
+                }
+              case CtorArgType::type:
+                break;
+              }
+            }
+
+            os << "," << endl
+               << "  " << member << " (" << (move ? "std::move (" : "") <<
+              ename (e) << (move ? ")" : "") << ", this)";
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Attribute& a)
+        {
+          String const& member (emember (a));
+
+          bool def (a.default_p ());
+
+          if (min (a) == 0 && !def)
+          {
+            // optional
+            //
+            os << "," << endl
+               << "  " << member << " (this)";
+          }
+          else
+          {
+            // one
+            //
+
+            if (def)
+            {
+              // This is an attribute with default or fixed value. We are
+              // going to initialize it to its default value.
+              //
+              os << "," << endl
+                 << "  " << member << " (" <<
+                edefault_value (a) << " (), this)";
+            }
+            else
+            {
+              os << "," << endl
+                 << "  " << member << " (" << ename (a) << ", this)";
+            }
+          }
+        }
+
+      private:
+        CtorArgType arg_type_;
+      };
+
+      struct CtorAny: Traversal::Any,
+                      Traversal::AnyAttribute,
+                      Context
+      {
+        CtorAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          if (max (a) != 1)
+          {
+            // sequence
+            //
+            os << "," << endl
+               << "  " << member << " (this->" << dom_doc << " ())";
+          }
+          else if (min (a) == 0)
+          {
+            // optional
+            //
+            os << "," << endl
+               << "  " << member << " (this->" << dom_doc << " ())";
+          }
+          else
+          {
+            // one
+            //
+            os << "," << endl
+               << "  " << member << " (" << ename (a) << ", this->" <<
+              dom_doc << " ())";
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << emember (a) << " (this->" << dom_doc << " ())";
+        }
+      };
+
+
+      struct CopyMember: Traversal::Member, Context
+      {
+        CopyMember (Context& c, String const& arg_name_)
+            : Context (c), arg_name (arg_name_)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& member (emember (m));
+
+          os << "," << endl
+             << "  " << member << " (" <<
+            arg_name << "." << member << ", f, this)";
+        }
+
+      private:
+        String arg_name;
+      };
+
+      struct CopyAny: Traversal::Any,
+                      Traversal::AnyAttribute,
+                      Context
+      {
+        CopyAny (Context& c, String const& arg_name_)
+            : Context (c), arg_name (arg_name_)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (" <<
+            arg_name << "." << member << ", this->" << dom_doc << " ())";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (" <<
+            arg_name << "." << member << ", this->" << dom_doc << " ())";
+        }
+
+      private:
+        String arg_name;
+      };
+
+      struct AssignMember: Traversal::Member, Context
+      {
+        AssignMember (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& member (emember (m));
+          os << "this->" << member << " = x." << member << ";";
+        }
+      };
+
+      struct AssignAny: Traversal::Any,
+                        Traversal::AnyAttribute,
+                        Context
+      {
+        AssignAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          os << "this->" << member << " = x." << member << ";";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          os << "this->" << member << " = x." << member << ";";
+        }
+      };
+
+
+      // Element parsing c-tor initializers.
+      //
+      struct ElementCtorMember: Traversal::Member, Context
+      {
+        ElementCtorMember (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& member (emember (m));
+
+          os << "," << endl
+             << "  " << member << " (this)";
+        }
+      };
+
+      struct ElementCtorAny: Traversal::Any,
+                             Traversal::AnyAttribute,
+                             Context
+      {
+        ElementCtorAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+      };
+
+
+      // Default c-tor member initializer.
+      //
+      struct DefaultCtorMemberInit: Traversal::Element,
+                                    Traversal::Attribute,
+                                    Context
+      {
+        DefaultCtorMemberInit (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (skip (e))
+            return;
+
+          String const& member (emember (e));
+
+          os << "," << endl
+             << "  " << member << " (this)";
+        }
+
+        virtual void
+        traverse (SemanticGraph::Attribute& a)
+        {
+          String const& member (emember (a));
+
+          if (a.default_p ())
+          {
+            // This is an attribute with default or fixed value. We are
+            // going to initialize it to its default value.
+            //
+            os << "," << endl
+               << "  " << member << " (" <<
+              edefault_value (a) << " (), this)";
+          }
+          else
+            os << "," << endl
+               << "  " << member << " (this)";
+        }
+      };
+
+      struct DefaultCtorAnyInit: Traversal::Any,
+                                 Traversal::AnyAttribute,
+                                 Context
+      {
+        DefaultCtorAnyInit (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          String const& dom_doc (
+            edom_document (
+              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+
+          os << "," << endl
+             << "  " << member << " (this->" << dom_doc << " ())";
+        }
+      };
+
+      // Test whether the base has comparison operators.
+      //
+      struct HasComparisonOperator: Traversal::Fundamental::Type,
+                                    Traversal::List,
+                                    Traversal::Union,
+                                    Traversal::Complex,
+                                    Traversal::Enumeration,
+                                    Traversal::Member,
+                                    Traversal::Any,
+                                    Traversal::AnyAttribute,
+                                    Context
+      {
+        // generate should initially be false.
+        //
+        HasComparisonOperator (Context& c, bool& generate)
+            : Context (c), generate_ (generate)
+        {
+          *this >> inherits_ >> *this;
+          *this >> names_ >> *this;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Fundamental::Type&)
+        {
+          // All built-in types are comparable.
+          generate_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::List&)
+        {
+          generate_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Union&)
+        {
+          generate_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Enumeration& e)
+        {
+          Traversal::Enumeration::inherits (e);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          Complex::names (c);
+
+          if (!generate_)
+            Complex::inherits (c);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          if (!skip (m))
+            generate_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any&)
+        {
+          if (options.generate_wildcard ())
+            generate_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute&)
+        {
+          if (options.generate_wildcard ())
+            generate_ = true;
+        }
+
+      private:
+        bool& generate_;
+
+        Traversal::Inherits inherits_;
+        Traversal::Names names_;
+      };
+
+      //
+      //
+      struct MemberComparison: Traversal::Element,
+                               Traversal::Attribute,
+                               Context
+      {
+        MemberComparison (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (skip (e))
+            return;
+
+          String const& aname (eaname (e));
+
+          // Check if we need to handle xsi:type and substitution groups.
+          // If this element's type is anonymous then we don't need to do
+          // anything. Note that if the type is anonymous then it can't be
+          // derived from which makes it impossible to substitute or
+          // dynamically-type with xsi:type.
+          //
+          SemanticGraph::Type& t (e.type ());
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          if (!poly)
+          {
+            os << "if (!(x." << aname << " () == y." << aname << " ()))" << endl
+               << "return false;"
+               << endl;
+          }
+          else
+          {
+            os << "{"
+               << "::xsd::cxx::tree::comparison_map< " << char_type
+               << " >& cm (" << endl
+               << "::xsd::cxx::tree::comparison_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
+               << endl;
+
+            if (max (e) != 1)
+            {
+              // sequence
+              //
+              String const& scope (ename (e.scope ()));
+
+              os << scope << "::" << econtainer (e) <<
+                " a (x." << aname << " ()), b (y." << aname << " ());"
+                 << endl;
+
+              os << "if (a.size () != b.size ())" << endl
+                 << "return false;"
+                 << endl;
+
+              os << "for (" << scope << "::" << econst_iterator (e) << endl
+                 << "ai (a.begin ()), bi (b.begin ()), " <<
+                "ae (a.end ()), be (b.end ());" << endl
+                 << "ai != ae; ++ai, ++bi)"
+                 << "{"
+                 << "if (!cm.compare (*ai, *bi))" << endl
+                 << "return false;"
+                 << "}";
+            }
+            else if (min (e) == 0)
+            {
+              // optional
+              //
+              String const& scope (ename (e.scope ()));
+
+              os << scope << "::" << econtainer (e) <<
+                " a (x." << aname << " ()), b (y." << aname << " ());"
+                 << endl;
+
+              os << "if (!a || !b)"
+                 << "{"
+                 << "if (a.present () != b.present ())" << endl
+                 << "return false;"
+                 << "}"
+                 << "else"
+                 << "{"
+                 << "if (!cm.compare (*a, *b))" << endl
+                 << "return false;"
+                 << "}";
+            }
+            else
+            {
+              // one
+              //
+              os << "if (!cm.compare (x." << aname << " (), y." <<
+                aname << " ()))" << endl
+                 << "return false;";
+            }
+
+            os << "}";
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Attribute& a)
+        {
+          String const& aname (eaname (a));
+
+          os << "if (!(x." << aname << " () == y." << aname << " ()))" << endl
+             << "return false;"
+             << endl;
+        }
+      };
+
+      struct AnyComparison: Traversal::Any,
+                            Traversal::AnyAttribute,
+                            Context
+      {
+        AnyComparison (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& aname (eaname (a));
+
+          if (max (a) == 1 && min (a) == 1)
+            os << "if (!x." << aname << " ().isEqualNode (&y." <<
+              aname << " ()))";
+          else
+            os << "if (!(x." << aname << " () == y." << aname << " ()))";
+
+          os << endl
+             << "return false;"
+             << endl;
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& aname (eaname (a));
+
+          os << "if (!(x." << aname << " () == y." << aname << " ()))" << endl
+             << "return false;"
+             << endl;
+        }
+      };
+
+      // Check whether a type has a parse() function (i.e., has any
+      // members, recursively).
+      //
+      struct HasParseFunction: Traversal::Complex,
+                               Traversal::Element,
+                               Traversal::Any,
+                               Traversal::Attribute,
+                               Traversal::AnyAttribute,
+                               Context
+      {
+        HasParseFunction (Context& c, bool& has_el, bool& has_at)
+            : Context (c), has_el_ (has_el), has_at_ (has_at)
+        {
+          *this >> names_ >> *this;
+          *this >> inherits_ >> *this;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          if (mixed_p (c) && !c.context ().count ("mixed-in-base"))
+            has_el_ = true;
+
+          names (c);
+
+          if (!(has_el_ && has_at_))
+            inherits (c);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element&)
+        {
+          has_el_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any&)
+        {
+          has_el_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Attribute&)
+        {
+          has_at_ = true;
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute&)
+        {
+          if (options.generate_wildcard ())
+            has_at_ = true;
+        }
+
+      private:
+        bool& has_el_;
+        bool& has_at_;
+
+        Traversal::Names names_;
+        Traversal::Inherits inherits_;
+      };
+
+      //
+      //
+      struct FacetArray: Traversal::Complex, Context
+      {
+        FacetArray (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (Type& c)
+        {
+          Facets f;
+          FacetCollector col (f);
+          col.traverse (c);
+
+          for (Facets::const_iterator i (f.begin ()); i != f.end (); ++i)
+          {
+            if (i->first == L"fractionDigits")
+              os << "{::xsd::cxx::tree::facet::fraction_digits, " <<
+                i->second << "UL}," << endl;
+            else if (i->first == L"totalDigits")
+              os << "{::xsd::cxx::tree::facet::total_digits, " <<
+                i->second << "UL}," << endl;
+          }
+        }
+
+      private:
+        typedef map<String, String> Facets;
+
+        struct FacetCollector: Traversal::Complex
+        {
+          FacetCollector (Facets& facets)
+              : facets_ (facets)
+          {
+            *this >> inherits_ >> *this;
+          }
+
+          virtual void
+          traverse (Type& c)
+          {
+            if (c.inherits_p ())
+            {
+              // First collect our base so that we can override its
+              // facets.
+              //
+              inherits (c);
+
+              using SemanticGraph::Restricts;
+
+              if (Restricts* r = dynamic_cast<Restricts*> (&c.inherits ()))
+              {
+                if (!r->facet_empty ())
+                {
+                  Restricts::FacetIterator i (r->facet_find ("totalDigits"));
+
+                  if (i != r->facet_end ())
+                    facets_[i->first] = i->second;
+
+                  i = r->facet_find ("fractionDigits");
+
+                  if (i != r->facet_end ())
+                    facets_[i->first] = i->second;
+                }
+              }
+            }
+          }
+
+        private:
+          Traversal::Inherits inherits_;
+          Facets& facets_;
+        };
+      };
+
+      //
+      //
+      struct Complex: Traversal::Complex, Context
+      {
+        Complex (Context& c)
+            : Context (c),
+              member_name_ (c),
+              any_ (c),
+              element_ (c),
+              any_test_ (c),
+              element_test_ (c),
+              attribute_ (c),
+              attribute_test_ (c),
+              any_attribute_ (c),
+              default_ctor_any_init_ (c),
+              default_ctor_member_init_ (c),
+              ctor_any_ (c),
+              ctor_member_ (c, CtorArgType::type),
+              element_ctor_any_ (c),
+              element_ctor_member_ (c),
+              assign_any_ (c),
+              assign_member_ (c),
+              comparison_any_ (c),
+              comparison_member_ (c),
+              facet_array_ (c)
+        {
+          bool gen_wildcard (options.generate_wildcard ());
+
+          inherits_member_ >> member_name_;
+
+          names_element_ >> element_;
+          if (gen_wildcard)
+            names_element_ >> any_;
+
+          names_element_test_ >> element_test_;
+          if (gen_wildcard)
+            names_element_test_ >> any_test_;
+
+          names_attribute_ >> attribute_;
+          names_attribute_test_ >> attribute_test_;
+          names_any_attribute_ >> any_attribute_;
+
+          default_ctor_init_names_ >> default_ctor_member_init_;
+          if (gen_wildcard)
+            default_ctor_init_names_ >> default_ctor_any_init_;
+
+          ctor_names_ >> ctor_member_;
+          if (gen_wildcard)
+            ctor_names_ >> ctor_any_;
+
+          element_ctor_names_ >> element_ctor_member_;
+          if (gen_wildcard)
+            element_ctor_names_ >> element_ctor_any_;
+
+          assign_names_ >> assign_member_;
+          if (gen_wildcard)
+            assign_names_ >> assign_any_;
+
+          comparison_names_ >> comparison_member_;
+          if (gen_wildcard)
+            comparison_names_ >> comparison_any_;
+        }
+
+
+        virtual void
+        traverse (Type& c)
+        {
+          bool gen_wildcard (options.generate_wildcard ());
+
+          String name (ename (c));
+
+          // If renamed name is empty then we do not need to generate
+          // anything for this type.
+          //
+          bool renamed (renamed_type (c, name));
+          if (renamed && !name)
+            return;
+
+          SemanticGraph::Context& ctx (c.context ());
+
+          bool mixed (mixed_p (c) && !ctx.count ("mixed-in-base"));
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (c);
+          }
+
+          SemanticGraph::Enumeration* enum_base (0);
+          {
+            IsEnumBasedType t (enum_base);
+            t.dispatch (c);
+          }
+
+          bool facets (false);
+          String base; // base type name
+          if (c.inherits_p ())
+          {
+            // Get base name.
+            //
+            std::wostringstream o;
+
+            BaseTypeName base_type (*this, o);
+            Traversal::Inherits inherits_type (base_type);
+
+            // Cannot use inherits_none here because need the
+            // result in a string.
+            //
+            inherits (c, inherits_type);
+
+            base = o.str ();
+
+            // See if we have any facets that we need to handle.
+            //
+            using SemanticGraph::Restricts;
+            using SemanticGraph::Fundamental::Decimal;
+
+            if (Restricts* r = dynamic_cast<Restricts*> (&c.inherits ()))
+            {
+              if (!r->facet_empty () &&
+                  (r->facet_find ("fractionDigits") != r->facet_end () ||
+                   r->facet_find ("totalDigits") != r->facet_end ()) &&
+                  ultimate_base (c).is_a<Decimal> ())
+                facets = true;
+            }
+          }
+          else
+            base = any_type;
+
+          os << "// " << name << endl
+             << "//" << endl
+             << endl;
+
+          //
+          //
+          {
+            Member member (*this, name);
+            Traversal::Names names_member (member);
+            names (c, names_member);
+          }
+
+          // facets
+          //
+          if (facets)
+          {
+            os << "static const ::xsd::cxx::tree::facet _xsd_" << name <<
+              "_facet_table[] = "
+               << "{";
+
+            facet_array_.traverse (c);
+
+            os << "{::xsd::cxx::tree::facet::none, 0UL}"
+               << "};";
+          }
+
+          // c-tors
+          //
+          bool generate_no_base_ctor (false);
+          {
+            GenerateWithoutBaseCtor t (generate_no_base_ctor);
+            t.traverse (c);
+          }
+
+          bool has_complex_non_op_args (false);
+          bool has_poly_non_op_args (false);
+          bool complex_poly_args_clash (true);
+          {
+            HasComplexPolyNonOptArgs t (*this, true,
+                                        has_complex_non_op_args,
+                                        has_poly_non_op_args,
+                                        complex_poly_args_clash);
+            t.traverse (c);
+          }
+
+          // default c-tor
+          //
+          if (options.generate_default_ctor ())
+          {
+            bool generate (false);
+            {
+              GenerateDefaultCtor t (*this, generate, generate_no_base_ctor);
+              t.traverse (c);
+            }
+
+            if (generate)
+            {
+              os << name << "::" << endl
+                 << name << " ()" << endl
+                 << ": " << base << " ()";
+
+              if (edom_document_member_p (c))
+              {
+                os << "," << endl
+                   << "  " << edom_document_member (c) << " (" <<
+                  "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                  " > ())";
+              }
+
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              names (c, default_ctor_init_names_);
+
+              os << "{";
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+              os << "}";
+            }
+          }
+
+          // c-tor (base, all-non-optional-members)
+          //
+          if (options.generate_from_base_ctor ())
+          {
+            bool generate (false);
+            {
+              GenerateFromBaseCtor t (*this, generate);
+              t.traverse (c);
+            }
+
+            if (generate)
+            {
+              bool has_complex_non_op_args (false);
+              bool has_poly_non_op_args (false);
+              bool complex_poly_args_clash (true);
+              {
+                HasComplexPolyNonOptArgs t (*this, false,
+                                            has_complex_non_op_args,
+                                            has_poly_non_op_args,
+                                            complex_poly_args_clash);
+                t.traverse (c);
+              }
+
+              String base_arg (
+                L"_xsd_" + ename (c.inherits ().base ()) + L"_base");
+
+              os << name << "::" << endl
+                 << name << " (const ";
+              inherits (c, inherits_member_);
+              os << "& " << base_arg;
+              {
+                FromBaseCtorArg args (*this, CtorArgType::type, true);
+                Traversal::Names args_names (args);
+                names (c, args_names);
+              }
+              os << ")" << endl
+                 << ": " << base << " (" << base_arg << ")";
+
+              if (edom_document_member_p (c))
+              {
+                os << "," << endl
+                   << "  " << edom_document_member (c) << " (" <<
+                  "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                  " > ())";
+              }
+
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              names (c, ctor_names_);
+
+              os << "{";
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+              os << "}";
+
+              // If we have any complex arguments in the previous c-tor
+              // then also generate the auto_ptr version.
+              //
+              if (has_complex_non_op_args)
+              {
+                CtorArgType const at (CtorArgType::complex_auto_ptr);
+
+                os << name << "::" << endl
+                   << name << " (const ";
+                inherits (c, inherits_member_);
+                os << "& " << base_arg;
+                {
+                  FromBaseCtorArg args (*this, at, true);
+                  Traversal::Names args_names (args);
+                  names (c, args_names);
+                }
+                os << ")" << endl
+                   << ": " << base << " (" << base_arg << ")";
+
+                if (edom_document_member_p (c))
+                {
+                  os << "," << endl
+                     << "  " << edom_document_member (c) << " (" <<
+                    "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                    " > ())";
+                }
+
+                if (mixed)
+                {
+                  os << "," << endl
+                     << "  " << ctx.get<String> ("mixed-member") << " (this)";
+                }
+
+                {
+                  CtorMember t (*this, at);
+                  Traversal::Names n (t);
+
+                  if (gen_wildcard)
+                    n >> ctor_any_;
+
+                  names (c, n);
+                }
+
+                os << "{";
+                if (facets)
+                  os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+                os << "}";
+              }
+
+              // If we are generating polymorphic code then we also need to
+              // provide auto_ptr version for every polymorphic type.
+              //
+              if (polymorphic &&
+                  has_poly_non_op_args && !complex_poly_args_clash)
+              {
+                CtorArgType const at (CtorArgType::poly_auto_ptr);
+
+                os << name << "::" << endl
+                   << name << " (const ";
+                inherits (c, inherits_member_);
+                os << "& " << base_arg;
+                {
+                  FromBaseCtorArg args (*this, at, true);
+                  Traversal::Names args_names (args);
+                  names (c, args_names);
+                }
+                os << ")" << endl
+                   << ": " << base << " (" << base_arg << ")";
+
+                if (edom_document_member_p (c))
+                {
+                  os << "," << endl
+                     << "  " << edom_document_member (c) << " (" <<
+                    "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                    " > ())";
+                }
+
+                if (mixed)
+                {
+                  os << "," << endl
+                     << "  " << ctx.get<String> ("mixed-member") << " (this)";
+                }
+
+                {
+                  CtorMember t (*this, at);
+                  Traversal::Names n (t);
+
+                  if (gen_wildcard)
+                    n >> ctor_any_;
+
+                  names (c, n);
+                }
+
+                os << "{";
+                if (facets)
+                  os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+                os << "}";
+              }
+            }
+          }
+
+          // c-tor (all-non-optional-members)
+          //
+          if (generate_no_base_ctor)
+          {
+            CtorArgType const at (CtorArgType::type);
+
+            os << name << "::" << endl
+               << name << " (";
+            {
+              CtorArgsWithoutBase ctor_args (*this, at, true, true);
+              ctor_args.dispatch (c);
+            }
+            os << ")" << endl
+               << ": " << base << " (";
+            {
+              CtorBase base (*this, at, "");
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            names (c, ctor_names_);
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+
+            // If we have any complex arguments in the previous c-tor
+            // then also generate the auto_ptr version. One case where
+            // this c-tor will be generated is restriction of anyType.
+            //
+            if (has_complex_non_op_args)
+            {
+              CtorArgType const at (CtorArgType::complex_auto_ptr);
+
+              os << name << "::" << endl
+                 << name << " (";
+              {
+                CtorArgsWithoutBase ctor_args (*this, at, true, true);
+                ctor_args.dispatch (c);
+              }
+              os << ")" << endl
+                 << ": " << base << " (";
+              {
+                CtorBase base (*this, at, "");
+                Traversal::Inherits inherits_base (base);
+
+                inherits (c, inherits_base);
+              }
+              os << ")";
+
+              if (edom_document_member_p (c))
+              {
+                os << "," << endl
+                   << "  " << edom_document_member (c) << " (" <<
+                  "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                  " > ())";
+              }
+
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              {
+                CtorMember t (*this, at);
+                Traversal::Names n (t);
+
+                if (gen_wildcard)
+                  n >> ctor_any_;
+
+                names (c, n);
+              }
+
+              os << "{";
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+              os << "}";
+            }
+
+            // If we are generating polymorphic code then we also need to
+            // provide auto_ptr version for every polymorphic type.
+            //
+            if (polymorphic &&
+                has_poly_non_op_args && !complex_poly_args_clash)
+            {
+              CtorArgType const at (CtorArgType::poly_auto_ptr);
+
+              os << name << "::" << endl
+                 << name << " (";
+              {
+                CtorArgsWithoutBase ctor_args (*this, at, true, true);
+                ctor_args.dispatch (c);
+              }
+              os << ")" << endl
+                 << ": " << base << " (";
+              {
+                CtorBase base (*this, at, "");
+                Traversal::Inherits inherits_base (base);
+
+                inherits (c, inherits_base);
+              }
+              os << ")";
+
+              if (edom_document_member_p (c))
+              {
+                os << "," << endl
+                   << "  " << edom_document_member (c) << " (" <<
+                  "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                  " > ())";
+              }
+
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              {
+                CtorMember t (*this, at);
+                Traversal::Names n (t);
+
+                if (gen_wildcard)
+                  n >> ctor_any_;
+
+                names (c, n);
+              }
+
+              os << "{";
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+              os << "}";
+            }
+          }
+
+          if (string_based)
+          {
+            // We might not have the value type if this enum is customized.
+            //
+            if (enum_base != 0 && enum_base->context ().count ("value"))
+            {
+              // c-tor (enum-value, all-non-optional-members)
+              //
+              CtorArgType const at (CtorArgType::type);
+              String base_arg (L"_xsd_" + ename (*enum_base) + L"_base");
+
+              os << name << "::" << endl
+                 << name << " (" << fq_name (*enum_base) << "::" <<
+                evalue (*enum_base) << " " << base_arg;
+
+              {
+                CtorArgsWithoutBase ctor_args (*this, at, true, false);
+                ctor_args.dispatch (c);
+              }
+
+              os << ")" << endl
+                 << ": " << base << " (";
+
+              {
+                CtorBase base (*this, at, base_arg);
+                Traversal::Inherits inherits_base (base);
+
+                inherits (c, inherits_base);
+              }
+
+              os << ")";
+
+              if (edom_document_member_p (c))
+              {
+                os << "," << endl
+                   << "  " << edom_document_member (c) << " (" <<
+                  "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                  " > ())";
+              }
+
+              // Cannot be mixed.
+
+              names (c, ctor_names_);
+
+              os << "{";
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+              os << "}";
+            }
+
+            CtorArgType const at (CtorArgType::type);
+            String base_arg (L"_xsd_" + ename (ultimate_base (c)) + L"_base");
+
+            // c-tor (const char*, all-non-optional-members)
+            //
+            os << name << "::" << endl
+               << name << " (const " << char_type << "* " << base_arg;
+
+            {
+              CtorArgsWithoutBase ctor_args (*this, at, true, false);
+              ctor_args.dispatch (c);
+            }
+
+            os << ")" << endl
+               << ": " << base << " (";
+
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            // Cannot be mixed.
+
+            names (c, ctor_names_);
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+
+
+            // c-tor (const std::string&, all-non-optional-members)
+            //
+            os << name << "::" << endl
+               << name << " (const " << string_type << "& " << base_arg;
+
+            {
+              CtorArgsWithoutBase ctor_args (*this, at, true, false);
+              ctor_args.dispatch (c);
+            }
+
+            os << ")" << endl
+               << ": " << base << " (";
+
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            // Cannot be mixed.
+
+            names (c, ctor_names_);
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+          }
+
+          // c-tor (ultimate-base, all-non-optional-members)
+          //
+          {
+            CtorArgType const at (CtorArgType::type);
+
+            os << name << "::" << endl
+               << name << " (";
+
+            String base_arg;
+
+            {
+              CtorArgs ctor_args (*this, at, base_arg);
+              ctor_args.dispatch (c);
+            }
+
+            os << ")" << endl
+               << ": " << base << " (";
+
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            names (c, ctor_names_);
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+          }
+
+          // If we have any complex arguments in the previous c-tor
+          // then also generate the auto_ptr version.
+          //
+          if (has_complex_non_op_args)
+          {
+            CtorArgType const at (CtorArgType::complex_auto_ptr);
+            String base_arg;
+
+            os << name << "::" << endl
+               << name << " (";
+
+            {
+              CtorArgs ctor_args (*this, at, base_arg);
+              ctor_args.dispatch (c);
+            }
+
+            os << ")" << endl
+               << ": " << base << " (";
+
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            {
+              CtorMember t (*this, at);
+              Traversal::Names n (t);
+
+              if (gen_wildcard)
+                n >> ctor_any_;
+
+              names (c, n);
+            }
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+          }
+
+          // If we are generating polymorphic code then we also need to
+          // provide auto_ptr version for every polymorphic type.
+          //
+          if (polymorphic &&
+              has_poly_non_op_args && !complex_poly_args_clash)
+          {
+            CtorArgType const at (CtorArgType::poly_auto_ptr);
+            String base_arg;
+
+            os << name << "::" << endl
+               << name << " (";
+
+            {
+              CtorArgs ctor_args (*this, at, base_arg);
+              ctor_args.dispatch (c);
+            }
+
+            os << ")" << endl
+               << ": " << base << " (";
+
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
+
+              inherits (c, inherits_base);
+            }
+
+            os << ")";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            {
+              CtorMember t (*this, at);
+              Traversal::Names n (t);
+
+              if (gen_wildcard)
+                n >> ctor_any_;
+
+              names (c, n);
+            }
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+          }
+
+
+          // copy c-tor
+          //
+
+          os << name << "::" << endl
+             << name << " (const " << name << "& x," << endl
+             << flags_type << " f," << endl
+             << container << "* c)" << endl
+             << ": " << base << " (x, f, c)";
+
+          if (edom_document_member_p (c))
+          {
+            os << "," << endl
+               << "  " << edom_document_member (c) << " (" <<
+              "::xsd::cxx::xml::dom::create_document< " << char_type <<
+              " > ())";
+          }
+
+          if (mixed)
+          {
+            String const& m (ctx.get<String> ("mixed-member"));
+            os << "," << endl
+               << "  " << m << " (x." << m << ", f, this)";
+          }
+
+          if (ordered)
+          {
+            String const& m (ctx.get<String> ("order-member"));
+            os << "," << endl
+               << "  " << m << " (x." << m << ")";
+          }
+
+          {
+            CopyAny copy_any (*this, "x");
+            CopyMember copy_member (*this, "x");
+            Traversal::Names names;
+
+            names >> copy_member;
+
+            if (gen_wildcard)
+              names >> copy_any;
+
+            Complex::names (c, names);
+          }
+
+          os << "{";
+          if (facets)
+            os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+          os << "}";
+
+          //
+          //
+          bool he (has<Traversal::Element> (c));
+          bool hae (has<Traversal::Any> (c));
+
+          bool ha (has<Traversal::Attribute> (c));
+          bool haa (has<Traversal::AnyAttribute> (c));
+
+          //
+          //
+          if (!options.suppress_parsing ())
+          {
+            // c-tor (xercesc::DOMElement)
+            //
+            os << name << "::" << endl
+               << name << " (const " << xerces_ns << "::DOMElement& e," << endl
+               << flags_type << " f," << endl
+               << container << "* c)" << endl
+               << ": " << base << " (e, f";
+
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
+              os << " | " << flags_type << "::base";
+
+            os << ", c)";
+
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
+
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            names (c, element_ctor_names_);
+
+            os << "{";
+
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);"
+                 << endl;
+
+            bool base_has_el (false), base_has_at (false);
+
+            // We are only interested in this information if we are
+            // generating our own parse().
+            //
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
+            {
+              if (c.inherits_p ())
+              {
+                HasParseFunction test (*this, base_has_el, base_has_at);
+                test.dispatch (c.inherits ().base ());
+              }
+            }
+
+            //@@ Throw if p is not exhausted at the end.
+            //
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
+              os << "if ((f & " << flags_type << "::base) == 0)"
+                 << "{"
+                 << parser_type << " p (e, " <<
+                (he || hae || base_has_el || mixed_p (c) ? "true, " : "false, ") <<
+                (mixed_p (c) ? "true, " : "false, ") <<
+                (ha || (haa && gen_wildcard) || base_has_at ? "true" : "false")
+                 << ");"
+                 << "this->" << unclash (name, "parse") << " (p, f);"
+                 << "}";
+
+            os << "}";
+
+            bool simple (true);
+            {
+              IsSimpleType t (simple);
+              t.dispatch (c);
+            }
+
+            if (simple)
+            {
+              // c-tor (xercesc::DOMAttr)
+              //
+              os << name << "::" << endl
+                 << name << " (const " << xerces_ns << "::DOMAttr& a," << endl
+                 << flags_type << " f," << endl
+                 << container << "* c)" << endl
+                 << ": " << base << " (a, f, c)"
+                 << "{";
+
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+
+              os << "}";
+
+              // c-tor (string const&, xercesc::DOMElement)
+              //
+              os << name << "::" << endl
+                 << name << " (const " << string_type << "& s," << endl
+                 << "const " << xerces_ns << "::DOMElement* e," << endl
+                 << flags_type << " f," << endl
+                 << container << "* c)" << endl
+                 << ": " << base << " (s, e, f, c)"
+                 << "{";
+
+              if (facets)
+                os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+
+              os << "}";
+            }
+
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
+            {
+              os << "void " << name << "::" << endl
+                 << unclash (name, "parse") << " (" <<
+                parser_type << "& p," << endl
+                 << flags_type <<
+                (he || ha || base_has_el || base_has_at ? " f" : "") << ")"
+                 << "{";
+
+              // Allow the base to parse its part.
+              //
+              if (base_has_el || base_has_at)
+                os << "this->" << base << "::parse (p, f);"
+                   << endl;
+
+              if (he || hae || mixed_p (c))
+              {
+                bool m (mixed_p (c));
+
+                os << "for (; p.more_content (); p.next_content (" <<
+                  (m ? "true" : "false") << "))"
+                   << "{";
+
+                if (m)
+                {
+                  String const& ma (ctx.get<String> ("mixed-aname"));
+                  String const& mi (ctx.get<String> ("mixed-ordered-id-name"));
+                  String const& oa (ctx.get<String> ("order-aname"));
+                  String const& ot (ctx.get<String> ("order-type"));
+
+                  os << "if (p.cur_is_text ())"
+                     << "{"
+                     << "const " << xerces_ns << "::DOMText& t (" <<
+                    "p.cur_text ());"
+                     << "this->" << ma << " ().push_back (" << endl
+                     << "::xsd::cxx::xml::transcode< " << char_type << " > (" <<
+                    "t.getData (), t.getLength ()));"
+                     << "this->" << oa << " ().push_back (" << endl
+                     << ot << " (" << mi << "," << endl
+                     << "this->" << ma << " ().size () - 1));"
+                     << "continue;"
+                     << "}";
+                }
+
+                if (he || hae)
+                {
+                  os << "const " << xerces_ns << "::DOMElement& i (" <<
+                    "p.cur_element ());"
+                     << "const " << qname_type << " n (" << endl
+                     << "::xsd::cxx::xml::dom::name< " << char_type << " > (i));"
+                     << endl;
+
+                  names (c, names_element_);
+                }
+
+                os << "break;"
+                   << "}";
+
+                // Make sure all non-optional elements are set.
+                //
+                names (c, names_element_test_);
+              }
+
+              if (ha || (haa && gen_wildcard))
+              {
+                if (base_has_at)
+                  os << "p.reset_attributes ();"
+                     << endl;
+
+                os << "while (p.more_attributes ())"
+                   << "{"
+                   << "const " << xerces_ns << "::DOMAttr& i (" <<
+                  "p.next_attribute ());"
+                   << "const " << qname_type << " n (" << endl
+                   << "::xsd::cxx::xml::dom::name< " << char_type << " > (i));"
+                   << endl;
+
+                names (c, names_attribute_);
+
+                // Generate anyAttribute code after all the attributes.
+                //
+                if (gen_wildcard)
+                  names (c, names_any_attribute_);
+
+
+                // os << "{"  // else block
+                // @@
+                // This doesn't play well with inheritance because we
+                // don't expect base's attributes. Also there are other
+                // "special" attributes such as xmlns, etc.
+                //
+                // << "throw ::xsd::cxx::tree::unexpected_attribute ... "
+                // << "}";
+
+                os << "}"; // while loop
+
+                // Make sure all non-optional attributes are set.
+                //
+                names (c, names_attribute_test_);
+              }
+
+              os << "}";
+            }
+          }
+
+          // _clone
+          //
+          if (!(c.abstract_p () ||
+                (renamed && polymorphic && polymorphic_p (c))))
+            os << name << "* " << name << "::" << endl
+               << "_clone (" << flags_type << " f," << endl
+               << container << "* c) const"
+               << "{"
+               << "return new class " << name << " (*this, f, c);"
+               << "}";
+
+          // operator=
+          //
+          if (!options.suppress_assignment () &&
+              (he || ha || (gen_wildcard && (hae || haa))))
+          {
+            os << name << "& " << name << "::" << endl
+               << "operator= (const " << name << "& x)"
+               << "{"
+               << "if (this != &x)"
+               << "{"
+               << "static_cast< " << base << "& > (*this) = x;";
+
+            // Note that here we don't assign the DOMDocument that is
+            // used to hold wildcard fragments. Each document has its
+            // own copy.
+
+            // Mixed text content.
+            //
+            if (mixed)
+            {
+              String const& m (ctx.get<String> ("mixed-member"));
+              os << "this->" << m << " = x." << m << ";";
+            }
+
+            // Order container.
+            //
+            if (ordered)
+            {
+              String const& m (ctx.get<String> ("order-member"));
+              os << "this->" << m << " = x." << m << ";";
+            }
+
+            names (c, assign_names_);
+
+            os << "}"
+               << "return *this;"
+               << "}";
+          }
+
+          // d-tor
+          //
+          os << name << "::" << endl
+             << "~" << name << " ()"
+             << "{"
+             << "}";
+
+          // Register with type factory map.
+          //
+          if (polymorphic && polymorphic_p (c) && !c.abstract_p ())
+          {
+            // Note that we are using the original type name.
+            //
+            String const& name (ename (c));
+
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (c) && !options.suppress_parsing ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_type_factory_init (" << endl
+                 << strlit (c.name ()) << "," << endl
+                 << strlit (xml_ns_name (c)) << ");"
+                 << endl;
+            }
+
+            if ((!anonymous_p (c) || anonymous_substitutes_p (c)) &&
+                options.generate_comparison ())
+            {
+              os << "static" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
+                 << "_xsd_" << name << "_comparison_init;"
+                 << endl;
+            }
+          }
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison () &&
+              (he || ha || mixed || ordered || !c.inherits_p () ||
+               ((hae || haa) && gen_wildcard)))
+          {
+            bool base_comp (false);
+
+            if (c.inherits_p ())
+            {
+              HasComparisonOperator test (*this, base_comp);
+              test.dispatch (c.inherits ().base ());
+            }
+
+            bool has_body (he || ha || ordered || mixed || base_comp ||
+                           ((hae || haa) && gen_wildcard));
+
+            os << "bool" << endl
+               << "operator== (const " << name << "&" <<
+              (has_body ? " x" : "") << ", " <<
+              "const " << name << "&" << (has_body ? " y" : "") << ")"
+               << "{";
+
+            if (base_comp)
+              os << "if (!(static_cast< const " << base << "& > (x) ==" << endl
+                 << "static_cast< const " << base << "& > (y)))" << endl
+                 << "return false;"
+                 << endl;
+
+            {
+              Complex::names (c, comparison_names_);
+            }
+
+            if (mixed)
+            {
+              String const& an (ctx.get<String> ("mixed-aname"));
+              os << "if (!(x." << an << " () == y." << an << " ()))" << endl
+                 << "return false;"
+                 << endl;
+            }
+
+            if (ordered)
+            {
+              String const& an (ctx.get<String> ("order-aname"));
+              os << "if (!(x." << an << " () == y." << an << " ()))" << endl
+                 << "return false;"
+                 << endl;
+            }
+
+            os << "return true;"
+               << "}";
+
+            os << "bool" << endl
+               << "operator!= (const " << name << "& x, " <<
+              "const " << name << "& y)"
+               << "{"
+               << "return !(x == y);"
+               << "}";
+          }
+        }
+
+      private:
+        Traversal::Inherits inherits_member_;
+        MemberTypeName member_name_;
+
+        Traversal::Names names_element_;
+        Traversal::Names names_element_test_;
+
+        Traversal::Names names_attribute_;
+        Traversal::Names names_any_attribute_;
+        Traversal::Names names_attribute_test_;
+
+        Any any_;
+        Element element_;
+
+        AnyTest any_test_;
+        ElementTest element_test_;
+
+        Attribute attribute_;
+        AttributeTest attribute_test_;
+
+        AnyAttribute any_attribute_;
+
+        DefaultCtorAnyInit default_ctor_any_init_;
+        DefaultCtorMemberInit default_ctor_member_init_;
+        Traversal::Names default_ctor_init_names_;
+
+        CtorAny ctor_any_;
+        CtorMember ctor_member_;
+        Traversal::Names ctor_names_;
+
+        ElementCtorAny element_ctor_any_;
+        ElementCtorMember element_ctor_member_;
+        Traversal::Names element_ctor_names_;
+
+        AssignAny assign_any_;
+        AssignMember assign_member_;
+        Traversal::Names assign_names_;
+
+        AnyComparison comparison_any_;
+        MemberComparison comparison_member_;
+        Traversal::Names comparison_names_;
+
+        FacetArray facet_array_;
+      };
+
+
+      // Generate element types and substitution group map entries.
+      //
+      struct GlobalElement: Traversal::Element,
+                            GlobalElementBase,
+                            Context
+      {
+        GlobalElement (Context& c)
+            : GlobalElementBase (c),
+              Context (c),
+              element_type_ (c.options.generate_element_type ()),
+              element_map_ (c.options.generate_element_map ()),
+              type_name_ (c)
+        {
+          belongs_ >> type_name_;
+        }
+
+        virtual void
+        traverse (Type& e)
+        {
+          SemanticGraph::Type& t (e.type ());
+
+          // Check if this element is abstract.
+          //
+          bool abst;
+          {
+            SemanticGraph::Complex* tc;
+            abst = (tc = dynamic_cast<SemanticGraph::Complex*> (&t)) != 0 &&
+              tc->abstract_p ();
+          }
+
+          if (!abst && element_type_ && doc_root_p (e))
+          {
+            bool fund (false);
+            {
+              IsFundamentalType test (fund);
+              test.dispatch (t);
+            }
+
+            bool simple (true);
+            if (!fund)
+            {
+              IsSimpleType test (simple);
+              test.dispatch (t);
+            }
+
+            String const& name (ename (e));
+            String const& type (etype (e));
+            String const& member (emember (e));
+
+            os << "// " << name << endl
+               << "//" << endl
+               << endl;
+
+            // Virtual accessors.
+            //
+            os << "const " << any_type << "* " << name << "::" << endl
+               << "_value () const"
+               << "{";
+
+            if (fund)
+              os << "return 0;";
+            else
+              os << "return &this->" << member << ".get ();";
+
+            os << "}";
+
+            os << any_type << "* " << name << "::" << endl
+               << "_value ()"
+               << "{";
+
+            if (fund)
+              os << "return 0;";
+            else
+              os << "return &this->" << member << ".get ();";
+
+            os << "}";
+
+            // default c-tor
+            //
+            if (options.generate_default_ctor ())
+            {
+              os << name << "::" << endl
+                 << name << " ()" << endl
+                 << ": " << member << " (0)"
+                 << "{"
+                 << "}";
+            }
+
+            // c-tor (value)
+            //
+            os << name << "::" << endl
+               << name << " (const " << type << "& x)" << endl
+               << ": " << member << " (x, 0)"
+               << "{"
+               << "}";
+
+
+            // c-tor (auto_ptr<value>)
+            //
+            if (!simple || (polymorphic && polymorphic_p (t)))
+            {
+              os << name << "::" << endl
+                 << name << " (" << auto_ptr << "< " << type << " > p)" << endl
+                 << ": " << member << " (" <<
+                (std >= cxx_version::cxx11 ? "::std::move (p)" : "p") << ", 0)"
+                 << "{"
+                 << "}";
+            }
+
+            // c-tor (xercesc::DOMElement)
+            //
+            SemanticGraph::Context& ec (e.context ());
+            String const& name_member (ec.get<String> ("element-name-member"));
+            String const& ns_member (ec.get<String> ("element-ns-member"));
+
+            bool parsing (!options.suppress_parsing ());
+            if (parsing)
+            {
+              String const& tr (etraits (e));
+
+              os << name << "::" << endl
+                 << name << " (const " << xerces_ns << "::DOMElement& e, " <<
+                flags_type << " f)" << endl
+                 << ": " << member << " (0)"
+                 << "{"
+                 << "const " << qname_type << " n (" << endl
+                 << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
+                 << endl
+                 << "if (n.name () == " << name_member << " && " <<
+                "n.namespace_ () == " << ns_member << ")" << endl
+                 << "this->" << member << ".set (" << tr <<
+                "::create (e, f, 0));"
+                 << "else" << endl
+                 << "throw ::xsd::cxx::tree::unexpected_element < " <<
+                char_type << " > (" << endl
+                 << "n.name (), n.namespace_ ()," << endl
+                 << name_member << ", " << ns_member << ");"
+                 << "}";
+            }
+
+            // copy c-tor
+            //
+            os << name << "::" << endl
+               << name << " (const " << name << "& x, " <<
+              flags_type << " f)" << endl
+               << ": " << element_type << " ()," << endl
+               << "  " << member << " (x." << member << ", f, 0)"
+               << "{"
+               << "}";
+
+            // _clone
+            //
+            os << name << "* " << name << "::" << endl
+               << "_clone (" << flags_type << " f) const"
+               << "{"
+               << "return new class " << name << " (*this, f);"
+               << "}";
+
+            // Element name and namespace accessors.
+            //
+            String const& aname (ec.get<String> ("element-name"));
+            String const& ans (ec.get<String> ("element-ns"));
+
+            os << "const " << string_type << "& " << name << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return " << name_member << ";"
+               << "}";
+
+            os << "const " << string_type << "& " << name << "::" << endl
+               << ans << " ()"
+               << "{"
+               << "return " << ns_member << ";"
+               << "}";
+
+            os << "const " << string_type << "& " << name << "::" << endl
+               << "_name () const"
+               << "{"
+               << "return " << name_member << ";"
+               << "}";
+
+            os << "const " << string_type << "& " << name << "::" << endl
+               << "_namespace () const"
+               << "{"
+               << "return " << ns_member << ";"
+               << "}";
+
+            os << "const " << string_type << " " << name << "::" << endl
+               << name_member << " (" << strlit (e.name ()) << ");"
+               << endl
+               << "const " << string_type << " " << name << "::" << endl
+               << ns_member << " (" << strlit (e.namespace_ ().name ()) << ");"
+               << endl;
+
+            // d-tor
+            //
+            os << name << "::" << endl
+               << "~" << name << " ()"
+               << "{"
+               << "}";
+
+            // Element map registration.
+            //
+            if (element_map_ && parsing)
+            {
+              os << "static " << endl
+                 << "const ::xsd::cxx::tree::parser_init< " << name << ", " <<
+                char_type << ", " << any_type << " >" << endl
+                 << "_xsd_" << name << "_parser_init (" <<
+                name << "::" << aname << " (), " <<
+                name << "::" << ans << " ());"
+                 << endl;
+            }
+          }
+
+          // Note that we cannot just omit this element if it's abstract
+          // because it may serve as a "link" between the root of the
+          // substitution group and a non-abstract element that uses this
+          // element as its root (see element_factory_map::find_substitution()
+          // for details).
+          //
+          if (polymorphic && e.substitutes_p () && !options.suppress_parsing ())
+          {
+            String const& name (ename (e));
+            Type& r (e.substitutes ().root ());
+
+            os << "static" << endl
+               << "const ::xsd::cxx::tree::element_factory_initializer< " <<
+              poly_plate << ", " << char_type << " >" << endl
+               << "_xsd_" << name << "_element_factory_init (" << endl
+               << strlit (r.name ()) << "," << endl
+               << strlit (r.namespace_ ().name ()) << "," << endl
+               << strlit (e.name ()) << "," << endl
+               << strlit (e.namespace_ ().name ()) << "," << endl;
+
+            if (abst)
+              os << "0";
+            else
+            {
+              os << "&::xsd::cxx::tree::factory_impl< ";
+              belongs (e, belongs_);
+              os << " >";
+            }
+
+            os << ");"
+               << endl
+               << endl;
+          }
+        }
+
+      private:
+        bool element_type_;
+        bool element_map_;
+        Traversal::Belongs belongs_;
+        MemberTypeName type_name_;
+      };
+    }
+
+    void
+    generate_tree_source (Context& ctx, size_t first, size_t last)
+    {
+      if (ctx.options.generate_wildcard ())
+      {
+        ctx.os << "#include <xsd/cxx/xml/dom/wildcard-source.hxx>" << endl
+               << endl;
+      }
+
+      if (!ctx.options.suppress_parsing ())
+        ctx.os << "#include <xsd/cxx/xml/dom/parsing-source.hxx>" << endl
+               << endl;
+
+      if (ctx.polymorphic)
+      {
+        bool parsing (!ctx.options.suppress_parsing ());
+        bool comparison (ctx.options.generate_comparison ());
+
+        if (parsing)
+          ctx.os << "#include <xsd/cxx/tree/type-factory-map.hxx>" << endl
+                 << endl;
+
+        if (comparison)
+          ctx.os << "#include <xsd/cxx/tree/comparison-map.hxx>" << endl
+                 << endl;
+
+        if (parsing || comparison)
+        {
+          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 tree"
+                   << "{"
+                   << "#ifdef _MSC_VER" << endl;
+
+            if (parsing && export_maps)
+              ctx.os << "template struct __declspec (dllexport) " <<
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            if (parsing && import_maps)
+              ctx.os << "template struct __declspec (dllimport) " <<
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            if (comparison && export_maps)
+              ctx.os << "template struct __declspec (dllexport) " <<
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            if (comparison && import_maps)
+              ctx.os << "template struct __declspec (dllimport) " <<
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl;
+
+            if (parsing)
+              ctx.os << "template struct __attribute__ ((visibility(\"default\"))) " <<
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            if (comparison)
+              ctx.os << "template struct __attribute__ ((visibility(\"default\"))) " <<
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl;
+
+            if (parsing)
+              ctx.os << "template struct XSD_MAP_VISIBILITY " <<
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            if (comparison)
+              ctx.os << "template struct XSD_MAP_VISIBILITY " <<
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
+
+            ctx.os << "#endif" << endl
+                   << "}"  // tree
+                   << "}"  // cxx
+                   << "}"  // xsd
+                   << "#endif // XSD_NO_EXPORT" << endl
+                   << endl;
+          }
+
+          ctx.os << "namespace _xsd"
+                 << "{";
+
+          if (parsing)
+            ctx.os << "static" << endl
+                   << "const ::xsd::cxx::tree::type_factory_plate< " <<
+              ctx.poly_plate << ", " << ctx.char_type << " >" << endl
+                   << "type_factory_plate_init;"
+                   << endl;
+
+          if (comparison)
+            ctx.os << "static" << endl
+                   << "const ::xsd::cxx::tree::comparison_plate< " <<
+              ctx.poly_plate << ", " << ctx.char_type << " >" << endl
+                   << "comparison_plate_init;"
+                   << endl;
+
+          ctx.os << "}";
+        }
+      }
+
+      Traversal::Schema schema;
+      Sources sources;
+      Traversal::Names names_ns, names;
+      Namespace ns (ctx, first, last);
+
+      List list (ctx);
+      Union union_ (ctx);
+      Complex complex (ctx);
+      Enumeration enumeration (ctx);
+      GlobalElement element (ctx);
+
+      schema >> sources >> schema;
+      schema >> names_ns >> ns >> names;
+
+      names >> list;
+      names >> union_;
+      names >> complex;
+      names >> enumeration;
+      names >> element;
+
+      schema.dispatch (ctx.schema_root);
+    }
+  }
+}
diff --git a/xsd/cxx/tree/tree-source.hxx b/xsd/cxx/tree/tree-source.hxx
new file mode 100644
index 0000000..66dcff7
--- /dev/null
+++ b/xsd/cxx/tree/tree-source.hxx
@@ -0,0 +1,18 @@
+// file      : xsd/cxx/tree/tree-source.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_TREE_SOURCE_HXX
+#define XSD_CXX_TREE_TREE_SOURCE_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    void
+    generate_tree_source (Context&, size_t first, size_t last);
+  }
+}
+
+#endif  // XSD_CXX_TREE_TREE_SOURCE_HXX
diff --git a/xsd/cxx/tree/validator.cxx b/xsd/cxx/tree/validator.cxx
new file mode 100644
index 0000000..9785560
--- /dev/null
+++ b/xsd/cxx/tree/validator.cxx
@@ -0,0 +1,676 @@
+// file      : xsd/cxx/tree/validator.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <set>
+#include <iostream>
+
+#include <xsd/cxx/tree/validator.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/cxx/tree/elements.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      class ValidationContext: public Context
+      {
+      public:
+        ValidationContext (SemanticGraph::Schema& root,
+                           SemanticGraph::Path const& path,
+                           Tree::options const& ops,
+                           const WarningSet& disabled_warnings,
+                           Counts const& counts,
+                           bool generate_xml_schema,
+                           bool& valid_)
+            : Context (std::wcerr,
+                       root,
+                       path,
+                       ops,
+                       counts,
+                       generate_xml_schema,
+                       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)
+        {
+          if (disabled_warnings_.find ("all") != disabled_warnings_.end ())
+            disabled_warnings_all_ = true;
+        }
+
+      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<SemanticGraph::Namespace> ())
+            return L"<namespace-level>"; // There is a bug if you see this.
+
+          if (n.named_p ())
+          {
+            SemanticGraph::Scope& scope (n.scope ());
+
+            if (scope.is_a<SemanticGraph::Namespace> ())
+              return n.name ();
+
+            return xpath (scope) + L"/" + n.name ();
+          }
+          else
+          {
+            return L"(anonymous type for " +
+              n.context ().get<String> ("instance-name") + L")";
+          }
+        }
+
+      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 T001: namespace '" << *i << "' allows for "
+                   << "element '" << e.name () << "'" << endl;
+
+                os << a.file () << ":" << a.line () << ":" << a.column ()
+                   << ": warning T001: 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;
+              }
+            }
+          }
+
+        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<SemanticGraph::Complex&> (
+              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_;
+
+          names_ >> *this >> names_;
+
+          // Any
+          //
+          if (!is_disabled ("T001"))
+          {
+            *this >> contains_compositor_ >> compositor_ >> contains_particle_;
+            contains_particle_ >> compositor_;
+            contains_particle_ >> any_;
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          using SemanticGraph::Schema;
+
+          traverse (static_cast<SemanticGraph::Type&> (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<Schema&> (t.scope ().scope ()));
+
+              if (&s == &schema_root || sources_p (schema_root, s))
+              {
+                valid = false;
+
+                os << c.file () << ":" << c.line () << ":" << c.column ()
+                   << ": error: type '" << xpath (c) << "' inherits from "
+                   << "yet undefined type '" << xpath (t) << "'" << endl;
+
+                os << t.file () << ":" << t.line () << ":" << t.column ()
+                   << ": info: '" << xpath (t) << "' is defined here"
+                   << endl;
+
+                os << c.file () << ":" << c.line () << ":" << c.column ()
+                   << ": info: inheritance from a yet-undefined type is "
+                   << "not supported" << endl;
+
+                os << c.file () << ":" << c.line () << ":" << c.column ()
+                   << ": info: re-arrange your schema and try again"
+                   << endl;
+              }
+            }
+          }
+
+          Complex::traverse (c);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Type& t)
+        {
+          // This is also used to traverse Complex.
+          //
+          if (t.named_p ())
+          {
+            types_.insert (t.scope ().name () + L"#" + t.name ());
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (is_disabled ("T002"))
+            return;
+
+          // Note that there is no test for generate_p since we want
+          // to catch cases when things are not being generated but
+          // most likely should have been.
+          //
+          if (e.substitutes_p () && !polymorphic &&
+              !subst_group_warning_issued)
+          {
+            subst_group_warning_issued = true;
+
+            os << e.file () << ":" << e.line () << ":" << e.column ()
+               << ": warning T002: 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 handle "
+               << "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<Sources> ())
+            {
+              if (&i->schema () == &s || sources_p (i->schema (), s))
+                return true;
+            }
+          }
+
+          return false;
+        }
+
+      private:
+        set<String> 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<SemanticGraph::Fundamental::IdRef> ()
+              && !t.is_a<SemanticGraph::Fundamental::IdRefs> ())
+          {
+            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<String> types_;
+
+        Sources sources_;
+
+        Traversal::Names schema_names_;
+        Traversal::Namespace ns_;
+
+        Traversal::Names names_;
+      };
+    }
+
+    bool Validator::
+    validate (options const& ops,
+              SemanticGraph::Schema& schema,
+              SemanticGraph::Path const& path,
+              const WarningSet& disabled_warnings,
+              Counts const& counts)
+    {
+      bool valid (true);
+      ValidationContext ctx (
+        schema, path, ops, disabled_warnings, counts, false, valid);
+
+      //
+      //
+      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;
+      }
+
+      //
+      //
+      if (ops.char_type () != "char" &&
+          ops.char_type () != "wchar_t" &&
+          !ctx.is_disabled ("T003"))
+      {
+        wcerr << "warning T003: unknown base character type '" <<
+          ops.char_type ().c_str () << "'" << endl;
+      }
+
+      //
+      //
+      NarrowString tn (ops.type_naming ());
+
+      if (tn != "knr" && tn != "ucc" && tn != "java")
+      {
+        wcerr << "error: unknown type naming style specified: '" <<
+          tn.c_str () << "'" << endl;
+
+        return false;
+      }
+
+      NarrowString fn (ops.function_naming ());
+
+      if (fn != "knr" && fn != "lcc" && fn != "ucc" && fn != "java")
+      {
+        wcerr << "error: unknown function naming style specified: '" <<
+          fn.c_str () << "'" << endl;
+
+        return false;
+      }
+
+      //
+      //
+      bool element_type (ops.generate_element_type ());
+      bool par (!ops.suppress_parsing ());
+      bool ser (ops.generate_serialization ());
+
+      if (ops.generate_element_map ())
+      {
+        if (!element_type)
+        {
+          wcerr << "error: --generate-element-map can only be specified " <<
+            "together with --generate-element-type" << endl;
+
+          return false;
+        }
+
+        if (!(par || ser))
+        {
+          wcerr << "error: --generate-element-map is specified but " <<
+            "neither parsing nor serialization code is generated" << endl;
+
+          return false;
+        }
+      }
+
+      // Issue a warning if there are more than one global element
+      // and we are generating parsing/serialization functions or
+      // element types for all of them by default.
+      //
+
+      if (counts.global_elements > 1 &&
+          (element_type || par || ser) &&
+          !ops.root_element_first () &&
+          !ops.root_element_last () &&
+          !ops.root_element_all () &&
+          !ops.root_element_none () &&
+          ops.root_element ().empty () &&
+          !ctx.is_disabled ("T004"))
+      {
+        wcerr << schema.file () << ": warning T004: generating ";
+
+        if (element_type)
+          wcerr << "element types";
+        else
+        {
+          wcerr << (par ? "parsing " : "") <<
+            (ser ? (par ? "and serialization " : "serialization ") : "") <<
+            "functions";
+        }
+        wcerr << " for " << counts.global_elements << " global elements" <<
+          endl;
+
+        wcerr << schema.file () << ": info: use --root-element-* options "
+              << "to specify document root(s)" << endl;
+      }
+
+
+      // Test for anonymout types.
+      //
+      {
+        AnonymousType traverser (ctx);
+        traverser.dispatch (schema);
+      }
+
+      // Test the rest.
+      //
+      if (valid)
+      {
+        Traverser traverser (ctx);
+        traverser.dispatch (schema);
+      }
+
+      return valid;
+
+      // T005 is used in polymorphism-processor.cxx.
+      //
+    }
+  }
+}
diff --git a/xsd/cxx/tree/validator.hxx b/xsd/cxx/tree/validator.hxx
new file mode 100644
index 0000000..23f3f04
--- /dev/null
+++ b/xsd/cxx/tree/validator.hxx
@@ -0,0 +1,29 @@
+// file      : xsd/cxx/tree/validator.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_CXX_TREE_VALIDATOR_HXX
+#define XSD_CXX_TREE_VALIDATOR_HXX
+
+#include <xsd/cxx/tree/elements.hxx>
+#include <xsd/cxx/tree/options.hxx>
+
+#include <xsd/xsd.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class Validator
+    {
+    public:
+      bool
+      validate (options const&,
+                SemanticGraph::Schema&,
+                SemanticGraph::Path const& tu,
+                const WarningSet& disabled_warnings,
+                Counts const& counts);
+    };
+  }
+}
+
+#endif  // XSD_CXX_TREE_VALIDATOR_HXX
diff --git a/xsd/elements.hxx b/xsd/elements.hxx
new file mode 100644
index 0000000..d3dd659
--- /dev/null
+++ b/xsd/elements.hxx
@@ -0,0 +1,125 @@
+// file      : xsd/elements.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_ELEMENTS_HXX
+#define XSD_ELEMENTS_HXX
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/types.hxx>
+
+namespace SemanticGraph = XSDFrontend::SemanticGraph;
+namespace Traversal = XSDFrontend::Traversal;
+
+// Anonymous feedback via belongs edge.
+//
+struct AnonymousBase : Traversal::Element, Traversal::Attribute
+{
+  AnonymousBase (Traversal::NodeDispatcher& d1)
+      : complex_ (&d1, 0)
+  {
+    edge_traverser (belongs_);
+    belongs_.node_traverser (complex_);
+  }
+
+  AnonymousBase (Traversal::NodeDispatcher& d1, Traversal::NodeDispatcher& d2)
+      : complex_ (&d1, &d2)
+  {
+    edge_traverser (belongs_);
+    belongs_.node_traverser (complex_);
+  }
+
+  // Hooks.
+  //
+public:
+  virtual void
+  member_pre (SemanticGraph::Member&)
+  {
+  }
+
+  virtual void
+  member_post (SemanticGraph::Member&)
+  {
+  }
+
+  /*
+    virtual void
+    type_pre (SemanticGraph::Type& t)
+    {
+    }
+
+    virtual void
+    type_post (SemanticGraph::Type& t)
+    {
+    }
+  */
+
+public:
+
+  virtual void
+  traverse (SemanticGraph::Element& e)
+  {
+    SemanticGraph::Type& t (e.type ());
+
+    if (!t.named_p () && !t.context ().count ("seen"))
+    {
+      t.context ().set ("seen", true);
+
+      member_pre (e);
+
+      Element::belongs (e, belongs_);
+
+      member_post (e);
+
+      t.context ().remove ("seen");
+    }
+  }
+
+  virtual void
+  traverse (SemanticGraph::Attribute& a)
+  {
+    SemanticGraph::Type& t (a.type ());
+
+    if (!t.named_p () && !t.context ().count ("seen"))
+    {
+      t.context ().set ("seen", true);
+
+      member_pre (a);
+
+      Attribute::belongs (a, belongs_);
+
+      member_post (a);
+
+      t.context ().remove ("seen");
+    }
+  }
+
+private:
+  struct Complex : Traversal::Complex
+  {
+    Complex (Traversal::NodeDispatcher* d1, Traversal::NodeDispatcher* d2)
+        : d1_ (d1), d2_ (d2)
+    {
+    }
+
+    virtual void
+    traverse (SemanticGraph::Complex& c)
+    {
+      if (d1_)
+        d1_->dispatch (c);
+
+      if (d2_)
+        d2_->dispatch (c);
+    }
+
+  private:
+    Traversal::NodeDispatcher* d1_;
+    Traversal::NodeDispatcher* d2_;
+
+  } complex_;
+
+  Traversal::Belongs belongs_;
+};
+
+#endif // XSD_ELEMENTS_HXX
diff --git a/xsd/options-parser.hxx b/xsd/options-parser.hxx
new file mode 100644
index 0000000..afcdf80
--- /dev/null
+++ b/xsd/options-parser.hxx
@@ -0,0 +1,29 @@
+// file      : xsd/options-parser.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_OPTIONS_PARSER_HXX
+#define XSD_OPTIONS_PARSER_HXX
+
+#include <xsd/types.hxx>
+#include <xsd/options.hxx>
+
+namespace cli
+{
+  template <>
+  struct parser<NarrowString>
+  {
+    static void
+    parse (NarrowString& x, bool& xs, scanner& s)
+    {
+      xs = true;
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+    }
+  };
+}
+
+#endif // XSD_OPTIONS_PARSER_HXX
diff --git a/xsd/options.cli b/xsd/options.cli
new file mode 100644
index 0000000..3153be9
--- /dev/null
+++ b/xsd/options.cli
@@ -0,0 +1,322 @@
+// file      : xsd/options.cli
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <cstddef>; // std::size_t
+include <cstdint>; // std::uint64_t
+
+include <xsd/types.hxx>; // NarrowString, NarrowStrings
+
+class help_options
+{
+  std::uint64_t --build2-metadata; // Leave undocumented/hidden.
+
+  // These are all documented elsewhere.
+  //
+  bool --help;
+  bool --version;
+  bool --proprietary-license;
+};
+
+class options = 0
+{
+  NarrowStrings --disable-warning
+  {
+    "<warn>",
+    "Disable printing warning with id <warn>. If \cb{all} is specified for
+     the warning id then all warnings are disabled."
+  };
+
+  // The following option is "fake" in that it is actually handled by
+  // argv_file_scanner. We have it here to get the documentation.
+  //
+  std::string --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 \cb{#} are ignored. Option values can
+     be enclosed in double (\cb{\"}) or single (\cb{'}) 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 \cb{'\"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 \cb{--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."
+  };
+
+  // SLOC/license options.
+  //
+  bool --show-sloc
+  {
+    "Show the number of generated physical source lines of code (SLOC)."
+  };
+
+  std::size_t --sloc-limit
+  {
+    "<num>",
+    "Check that the number of generated physical source lines of code (SLOC)
+     does not exceed <num>."
+  };
+
+  bool --proprietary-license
+  {
+    "Indicate that the generated code is licensed under a proprietary
+     license instead of the GPL."
+  };
+
+  NarrowString --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
+     \cb{custom-literals.xsd} XML Schema file that can be found in the
+     documentation directory."
+  };
+
+  // Anonymous type morphing.
+  //
+  bool --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."
+  };
+
+  bool --show-anonymous
+  {
+    "Show elements and attributes that are of anonymous types. This option
+     only makes sense together with the \cb{--preserve-anonymous} option."
+  };
+
+  NarrowStrings --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
+     \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} \i{xpath}}
+
+     For instance:
+
+     \cb{hello.xsd http://example.com/hello element}
+
+     \cb{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:
+
+     \cb{%.* .* (.+/)*(.+)%\\u$2%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --anonymous-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--anonymous-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  bool --morph-anonymous; // Deprecated and therefore undocumented.
+
+  // Location options.
+  //
+  NarrowStrings --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 \cb{http://example.com/foo.xsd} URL to the
+     \cb{foo.xsd} local file.
+
+     \cb{--location-map http://example.com/foo.xsd=foo.xsd}"
+  };
+
+  NarrowStrings --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
+     \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.
+
+     For example, the following expression maps URL locations in the form
+     \cb{http://example.com/foo/bar.xsd} to local files in the form
+     \cb{bar.xsd}:
+
+     \cb{%http://.+/(.+)%$1%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --location-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--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 option.
+  //
+  bool --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: \cb{--type-file-regex}, \cb{--schema-file-regex},
+     \cb{--fat-type-file}, and \cb{--file-list}."
+  };
+
+  NarrowStrings --type-file-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to translate type
+     names to file names when the \cb{--file-per-type} option is specified.
+     <regex> 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{namespace} \i{type-name}}
+
+     For example, the following expression maps type \cb{foo} that is
+     defined in the \cb{http://example.com/bar} namespace to file name
+     \cb{bar-foo}:
+
+     \cb{%http://example.com/(.+) (.+)%$1-$2%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --type-file-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--type-file-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  NarrowStrings --schema-file-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to translate schema
+     file names when the \cb{--file-per-type} option is specified. <regex> 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 the absolute filesystem path of a schema file
+     and the result, including the directory part, if any, is used to derive
+     the \cb{#include} directive paths as well as the generated C++ file
+     paths. This option, along with \cb{--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
+     \cb{foo/1.0.0/} subdirectory to the files in the \cb{foo/} subdirectory.
+     As a result, the \cb{#include} directive paths for such schemas will be
+     in the \cb{foo/schema.hxx} form and the generated C++ files will be
+     placed into the \cb{foo/} subdirectory:
+
+     \cb{%.*/foo/1.0.0/(.+)%foo/$1%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --schema-file-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--schema-file-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  bool --fat-type-file
+  {
+    "Generate code corresponding to global elements into type files instead
+     of schema files when the \cb{--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 options.
+  //
+  NarrowString --file-list
+  {
+    "<file>",
+    "Write a list of generated C++ files to <file> or to \cb{stdout} if
+     <file> is \cb{-}. This option is primarily useful in the file-per-type
+     compilation mode (\cb{--file-per-type}) to create a list of generated
+     C++ files, for example, as a makefile fragment."
+  };
+
+  bool --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
+     \cb{--file-list}."
+  }
+
+  NarrowString --file-list-prologue
+  {
+    "<text>",
+    "Insert <text> at the beginning of the file list. As a convenience, all
+     occurrences of the \cb{\\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."
+  };
+
+  NarrowString --file-list-epilogue
+  {
+    "<text>",
+    "Insert <text> at the end of the file list. As a convenience, all
+     occurrences of the \cb{\\n} character sequence in <text> are replaced
+     with new lines."
+  };
+
+  NarrowString --file-list-delim = "\n"
+  {
+    "<text>",
+    "Delimit file names written to the file list with <text> instead of new
+     lines. As a convenience, all occurrences of the \cb{\\n} character
+     sequence in <text> are replaced with new lines."
+  };
+
+  // Undocumented.
+  //
+  bool --disable-multi-import;
+  bool --disable-full-check;
+};
diff --git a/xsd/pregenerated/xsd/cxx/options.cxx b/xsd/pregenerated/xsd/cxx/options.cxx
new file mode 100644
index 0000000..9eea3a9
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/options.cxx
@@ -0,0 +1,739 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <xsd/options-parser.hxx>
+//
+// End prologue.
+
+#include <xsd/cxx/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      using namespace std;
+
+      const char* o (s.next ());
+      if (s.more ())
+      {
+        string v (s.next ());
+        istringstream is (v);
+        if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        const char* v (s.next ());
+
+        if (std::strcmp (v, "1")    == 0 ||
+            std::strcmp (v, "true") == 0 ||
+            std::strcmp (v, "TRUE") == 0 ||
+            std::strcmp (v, "True") == 0)
+          x = true;
+        else if (std::strcmp (v, "0")     == 0 ||
+                 std::strcmp (v, "false") == 0 ||
+                 std::strcmp (v, "FALSE") == 0 ||
+                 std::strcmp (v, "False") == 0)
+          x = false;
+        else
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::pair<X, std::size_t> >
+  {
+    static void
+    parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+    {
+      x.second = s.position ();
+      parser<X>::parse (x.first, xs, s);
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X, typename C>
+  struct parser<std::set<X, C> >
+  {
+    static void
+    parse (std::set<X, C>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::map<K, V, C> >
+  {
+    static void
+    parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m[k] = v;
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::multimap<K, V, C> >
+  {
+    static void
+    parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, bool X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    s.next ();
+    x.*M = true;
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+
+namespace CXX
+{
+  // options
+  //
+
+  options::
+  options ()
+  : std_ (cxx_version::cxx11),
+    std_specified_ (false),
+    char_type_ ("char"),
+    char_type_specified_ (false),
+    char_encoding_ (),
+    char_encoding_specified_ (false),
+    output_dir_ (),
+    output_dir_specified_ (false),
+    generate_inline_ (),
+    generate_xml_schema_ (),
+    extern_xml_schema_ (),
+    extern_xml_schema_specified_ (false),
+    namespace_map_ (),
+    namespace_map_specified_ (false),
+    namespace_regex_ (),
+    namespace_regex_specified_ (false),
+    namespace_regex_trace_ (),
+    reserved_name_ (),
+    reserved_name_specified_ (false),
+    include_with_brackets_ (),
+    include_prefix_ (),
+    include_prefix_specified_ (false),
+    include_regex_ (),
+    include_regex_specified_ (false),
+    include_regex_trace_ (),
+    guard_prefix_ (),
+    guard_prefix_specified_ (false),
+    hxx_suffix_ (".hxx"),
+    hxx_suffix_specified_ (false),
+    ixx_suffix_ (".ixx"),
+    ixx_suffix_specified_ (false),
+    cxx_suffix_ (".cxx"),
+    cxx_suffix_specified_ (false),
+    fwd_suffix_ ("-fwd.hxx"),
+    fwd_suffix_specified_ (false),
+    hxx_regex_ (),
+    hxx_regex_specified_ (false),
+    ixx_regex_ (),
+    ixx_regex_specified_ (false),
+    cxx_regex_ (),
+    cxx_regex_specified_ (false),
+    fwd_regex_ (),
+    fwd_regex_specified_ (false),
+    hxx_prologue_ (),
+    hxx_prologue_specified_ (false),
+    ixx_prologue_ (),
+    ixx_prologue_specified_ (false),
+    cxx_prologue_ (),
+    cxx_prologue_specified_ (false),
+    fwd_prologue_ (),
+    fwd_prologue_specified_ (false),
+    prologue_ (),
+    prologue_specified_ (false),
+    hxx_epilogue_ (),
+    hxx_epilogue_specified_ (false),
+    ixx_epilogue_ (),
+    ixx_epilogue_specified_ (false),
+    cxx_epilogue_ (),
+    cxx_epilogue_specified_ (false),
+    fwd_epilogue_ (),
+    fwd_epilogue_specified_ (false),
+    epilogue_ (),
+    epilogue_specified_ (false),
+    hxx_prologue_file_ (),
+    hxx_prologue_file_specified_ (false),
+    ixx_prologue_file_ (),
+    ixx_prologue_file_specified_ (false),
+    cxx_prologue_file_ (),
+    cxx_prologue_file_specified_ (false),
+    fwd_prologue_file_ (),
+    fwd_prologue_file_specified_ (false),
+    prologue_file_ (),
+    prologue_file_specified_ (false),
+    hxx_epilogue_file_ (),
+    hxx_epilogue_file_specified_ (false),
+    ixx_epilogue_file_ (),
+    ixx_epilogue_file_specified_ (false),
+    cxx_epilogue_file_ (),
+    cxx_epilogue_file_specified_ (false),
+    fwd_epilogue_file_ (),
+    fwd_epilogue_file_specified_ (false),
+    epilogue_file_ (),
+    epilogue_file_specified_ (false),
+    export_symbol_ (),
+    export_symbol_specified_ (false),
+    export_xml_schema_ (),
+    export_maps_ (),
+    import_maps_ (),
+    generate_dep_ (),
+    generate_dep_only_ (),
+    dep_phony_ (),
+    dep_target_ (),
+    dep_target_specified_ (false),
+    dep_suffix_ (".d"),
+    dep_suffix_specified_ (false),
+    dep_file_ (),
+    dep_file_specified_ (false),
+    dep_regex_ (),
+    dep_regex_specified_ (false)
+  {
+  }
+
+  ::cli::usage_para options::
+  print_usage (::std::wostream& os, ::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p == ::cli::usage_para::text)
+      os << ::std::endl;
+
+    os << "--std <version>              Specify the C++ standard that the generated code" << ::std::endl
+       << "                             should conform to." << ::std::endl;
+
+    os << "--char-type <type>           Generate code using the provided character <type>" << ::std::endl
+       << "                             instead of the default char." << ::std::endl;
+
+    os << "--char-encoding <enc>        Specify the character encoding that should be used" << ::std::endl
+       << "                             in the generated code." << ::std::endl;
+
+    os << "--output-dir <dir>           Write generated files to <dir> instead of the" << ::std::endl
+       << "                             current directory." << ::std::endl;
+
+    os << "--generate-inline            Generate simple functions inline." << ::std::endl;
+
+    os << "--generate-xml-schema        Generate a C++ header file as if the schema being" << ::std::endl
+       << "                             compiled defines the XML Schema namespace." << ::std::endl;
+
+    os << "--extern-xml-schema <file>   Include a header file derived from <file> instead" << ::std::endl
+       << "                             of generating the XML Schema namespace mapping" << ::std::endl
+       << "                             inline." << ::std::endl;
+
+    os << "--namespace-map <xns>=<cns>  Map XML Schema namespace <xns> to C++ namespace" << ::std::endl
+       << "                             <cns>." << ::std::endl;
+
+    os << "--namespace-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+       << "                             used to translate XML Schema namespace names to" << ::std::endl
+       << "                             C++ namespace names." << ::std::endl;
+
+    os << "--namespace-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+       << "                             specified with the --namespace-regex option." << ::std::endl;
+
+    os << "--reserved-name <n>[=<r>]    Add name <n> to the list of names that should not" << ::std::endl
+       << "                             be used as identifiers." << ::std::endl;
+
+    os << "--include-with-brackets      Use angle brackets (<>) instead of quotes (\"\") in" << ::std::endl
+       << "                             generated #include directives." << ::std::endl;
+
+    os << "--include-prefix <prefix>    Add <prefix> to generated #include directive" << ::std::endl
+       << "                             paths." << ::std::endl;
+
+    os << "--include-regex <regex>      Add <regex> to the list of regular expressions" << ::std::endl
+       << "                             used to transform #include directive paths." << ::std::endl;
+
+    os << "--include-regex-trace        Trace the process of applying regular expressions" << ::std::endl
+       << "                             specified with the --include-regex option." << ::std::endl;
+
+    os << "--guard-prefix <prefix>      Add <prefix> to generated header inclusion guards." << ::std::endl;
+
+    os << "--hxx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             .hxx to construct the name of the header file." << ::std::endl;
+
+    os << "--ixx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             .ixx to construct the name of the inline file." << ::std::endl;
+
+    os << "--cxx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             .cxx to construct the name of the source file." << ::std::endl;
+
+    os << "--fwd-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             -fwd.hxx to construct the name of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--hxx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the header file." << ::std::endl;
+
+    os << "--ixx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the inline file." << ::std::endl;
+
+    os << "--cxx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the source file." << ::std::endl;
+
+    os << "--fwd-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the forward declaration file." << ::std::endl;
+
+    os << "--hxx-prologue <text>        Insert <text> at the beginning of the header file." << ::std::endl;
+
+    os << "--ixx-prologue <text>        Insert <text> at the beginning of the inline file." << ::std::endl;
+
+    os << "--cxx-prologue <text>        Insert <text> at the beginning of the source file." << ::std::endl;
+
+    os << "--fwd-prologue <text>        Insert <text> at the beginning of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--prologue <text>            Insert <text> at the beginning of each generated" << ::std::endl
+       << "                             file for which there is no file-specific prologue." << ::std::endl;
+
+    os << "--hxx-epilogue <text>        Insert <text> at the end of the header file." << ::std::endl;
+
+    os << "--ixx-epilogue <text>        Insert <text> at the end of the inline file." << ::std::endl;
+
+    os << "--cxx-epilogue <text>        Insert <text> at the end of the source file." << ::std::endl;
+
+    os << "--fwd-epilogue <text>        Insert <text> at the end of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--epilogue <text>            Insert <text> at the end of each generated file" << ::std::endl
+       << "                             for which there is no file-specific epilogue." << ::std::endl;
+
+    os << "--hxx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the header file." << ::std::endl;
+
+    os << "--ixx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the inline file." << ::std::endl;
+
+    os << "--cxx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the source file." << ::std::endl;
+
+    os << "--fwd-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the forward declaration file." << ::std::endl;
+
+    os << "--prologue-file <file>       Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of each generated file for which there is no" << ::std::endl
+       << "                             file-specific prologue file." << ::std::endl;
+
+    os << "--hxx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             header file." << ::std::endl;
+
+    os << "--ixx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             inline file." << ::std::endl;
+
+    os << "--cxx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             source file." << ::std::endl;
+
+    os << "--fwd-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             forward declaration file." << ::std::endl;
+
+    os << "--epilogue-file <file>       Insert the content of the <file> at the end of" << ::std::endl
+       << "                             each generated file for which there is no" << ::std::endl
+       << "                             file-specific epilogue file." << ::std::endl;
+
+    os << "--export-symbol <symbol>     Insert <symbol> in places where DLL export/import" << ::std::endl
+       << "                             control statements" << ::std::endl
+       << "                             (__declspec(dllexport/dllimport)) are necessary." << ::std::endl;
+
+    os << "--export-xml-schema          Export/import types in the XML Schema namespace" << ::std::endl
+       << "                             using the export symbol provided with the" << ::std::endl
+       << "                             --export-symbol option." << ::std::endl;
+
+    os << "--export-maps                Export polymorphism support maps from a Win32 DLL" << ::std::endl
+       << "                             into which this generated code is placed." << ::std::endl;
+
+    os << "--import-maps                Import polymorphism support maps to a Win32 DLL or" << ::std::endl
+       << "                             executable into which this generated code is" << ::std::endl
+       << "                             linked." << ::std::endl;
+
+    os << "--generate-dep               Generate make dependency information." << ::std::endl;
+
+    os << "--generate-dep-only          Generate make dependency information only." << ::std::endl;
+
+    os << "--dep-phony                  Generate phony targets for included/imported" << ::std::endl
+       << "                             schema files, causing each to depend on nothing." << ::std::endl;
+
+    os << "--dep-target <target>        Change the target of the dependency rule." << ::std::endl;
+
+    os << "--dep-suffix <suffix>        Use <suffix> instead of the default .d to" << ::std::endl
+       << "                             construct the name of the dependency file." << ::std::endl;
+
+    os << "--dep-file <path>            Use <path> as the generated dependency file path" << ::std::endl
+       << "                             instead of deriving it from the input file name." << ::std::endl;
+
+    os << "--dep-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the dependency file." << ::std::endl;
+
+    p = ::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (options&, ::cli::scanner&)>
+  _cli_options_map;
+
+  static _cli_options_map _cli_options_map_;
+
+  struct _cli_options_map_init
+  {
+    _cli_options_map_init ()
+    {
+      _cli_options_map_["--std"] =
+      &::cli::thunk< options, cxx_version, &options::std_,
+        &options::std_specified_ >;
+      _cli_options_map_["--char-type"] =
+      &::cli::thunk< options, NarrowString, &options::char_type_,
+        &options::char_type_specified_ >;
+      _cli_options_map_["--char-encoding"] =
+      &::cli::thunk< options, NarrowString, &options::char_encoding_,
+        &options::char_encoding_specified_ >;
+      _cli_options_map_["--output-dir"] =
+      &::cli::thunk< options, NarrowString, &options::output_dir_,
+        &options::output_dir_specified_ >;
+      _cli_options_map_["--generate-inline"] =
+      &::cli::thunk< options, &options::generate_inline_ >;
+      _cli_options_map_["--generate-xml-schema"] =
+      &::cli::thunk< options, &options::generate_xml_schema_ >;
+      _cli_options_map_["--extern-xml-schema"] =
+      &::cli::thunk< options, NarrowString, &options::extern_xml_schema_,
+        &options::extern_xml_schema_specified_ >;
+      _cli_options_map_["--namespace-map"] =
+      &::cli::thunk< options, NarrowStrings, &options::namespace_map_,
+        &options::namespace_map_specified_ >;
+      _cli_options_map_["--namespace-regex"] =
+      &::cli::thunk< options, NarrowStrings, &options::namespace_regex_,
+        &options::namespace_regex_specified_ >;
+      _cli_options_map_["--namespace-regex-trace"] =
+      &::cli::thunk< options, &options::namespace_regex_trace_ >;
+      _cli_options_map_["--reserved-name"] =
+      &::cli::thunk< options, NarrowStrings, &options::reserved_name_,
+        &options::reserved_name_specified_ >;
+      _cli_options_map_["--include-with-brackets"] =
+      &::cli::thunk< options, &options::include_with_brackets_ >;
+      _cli_options_map_["--include-prefix"] =
+      &::cli::thunk< options, NarrowString, &options::include_prefix_,
+        &options::include_prefix_specified_ >;
+      _cli_options_map_["--include-regex"] =
+      &::cli::thunk< options, NarrowStrings, &options::include_regex_,
+        &options::include_regex_specified_ >;
+      _cli_options_map_["--include-regex-trace"] =
+      &::cli::thunk< options, &options::include_regex_trace_ >;
+      _cli_options_map_["--guard-prefix"] =
+      &::cli::thunk< options, NarrowString, &options::guard_prefix_,
+        &options::guard_prefix_specified_ >;
+      _cli_options_map_["--hxx-suffix"] =
+      &::cli::thunk< options, NarrowString, &options::hxx_suffix_,
+        &options::hxx_suffix_specified_ >;
+      _cli_options_map_["--ixx-suffix"] =
+      &::cli::thunk< options, NarrowString, &options::ixx_suffix_,
+        &options::ixx_suffix_specified_ >;
+      _cli_options_map_["--cxx-suffix"] =
+      &::cli::thunk< options, NarrowString, &options::cxx_suffix_,
+        &options::cxx_suffix_specified_ >;
+      _cli_options_map_["--fwd-suffix"] =
+      &::cli::thunk< options, NarrowString, &options::fwd_suffix_,
+        &options::fwd_suffix_specified_ >;
+      _cli_options_map_["--hxx-regex"] =
+      &::cli::thunk< options, NarrowString, &options::hxx_regex_,
+        &options::hxx_regex_specified_ >;
+      _cli_options_map_["--ixx-regex"] =
+      &::cli::thunk< options, NarrowString, &options::ixx_regex_,
+        &options::ixx_regex_specified_ >;
+      _cli_options_map_["--cxx-regex"] =
+      &::cli::thunk< options, NarrowString, &options::cxx_regex_,
+        &options::cxx_regex_specified_ >;
+      _cli_options_map_["--fwd-regex"] =
+      &::cli::thunk< options, NarrowString, &options::fwd_regex_,
+        &options::fwd_regex_specified_ >;
+      _cli_options_map_["--hxx-prologue"] =
+      &::cli::thunk< options, NarrowStrings, &options::hxx_prologue_,
+        &options::hxx_prologue_specified_ >;
+      _cli_options_map_["--ixx-prologue"] =
+      &::cli::thunk< options, NarrowStrings, &options::ixx_prologue_,
+        &options::ixx_prologue_specified_ >;
+      _cli_options_map_["--cxx-prologue"] =
+      &::cli::thunk< options, NarrowStrings, &options::cxx_prologue_,
+        &options::cxx_prologue_specified_ >;
+      _cli_options_map_["--fwd-prologue"] =
+      &::cli::thunk< options, NarrowStrings, &options::fwd_prologue_,
+        &options::fwd_prologue_specified_ >;
+      _cli_options_map_["--prologue"] =
+      &::cli::thunk< options, NarrowStrings, &options::prologue_,
+        &options::prologue_specified_ >;
+      _cli_options_map_["--hxx-epilogue"] =
+      &::cli::thunk< options, NarrowStrings, &options::hxx_epilogue_,
+        &options::hxx_epilogue_specified_ >;
+      _cli_options_map_["--ixx-epilogue"] =
+      &::cli::thunk< options, NarrowStrings, &options::ixx_epilogue_,
+        &options::ixx_epilogue_specified_ >;
+      _cli_options_map_["--cxx-epilogue"] =
+      &::cli::thunk< options, NarrowStrings, &options::cxx_epilogue_,
+        &options::cxx_epilogue_specified_ >;
+      _cli_options_map_["--fwd-epilogue"] =
+      &::cli::thunk< options, NarrowStrings, &options::fwd_epilogue_,
+        &options::fwd_epilogue_specified_ >;
+      _cli_options_map_["--epilogue"] =
+      &::cli::thunk< options, NarrowStrings, &options::epilogue_,
+        &options::epilogue_specified_ >;
+      _cli_options_map_["--hxx-prologue-file"] =
+      &::cli::thunk< options, NarrowString, &options::hxx_prologue_file_,
+        &options::hxx_prologue_file_specified_ >;
+      _cli_options_map_["--ixx-prologue-file"] =
+      &::cli::thunk< options, NarrowString, &options::ixx_prologue_file_,
+        &options::ixx_prologue_file_specified_ >;
+      _cli_options_map_["--cxx-prologue-file"] =
+      &::cli::thunk< options, NarrowString, &options::cxx_prologue_file_,
+        &options::cxx_prologue_file_specified_ >;
+      _cli_options_map_["--fwd-prologue-file"] =
+      &::cli::thunk< options, NarrowString, &options::fwd_prologue_file_,
+        &options::fwd_prologue_file_specified_ >;
+      _cli_options_map_["--prologue-file"] =
+      &::cli::thunk< options, NarrowString, &options::prologue_file_,
+        &options::prologue_file_specified_ >;
+      _cli_options_map_["--hxx-epilogue-file"] =
+      &::cli::thunk< options, NarrowString, &options::hxx_epilogue_file_,
+        &options::hxx_epilogue_file_specified_ >;
+      _cli_options_map_["--ixx-epilogue-file"] =
+      &::cli::thunk< options, NarrowString, &options::ixx_epilogue_file_,
+        &options::ixx_epilogue_file_specified_ >;
+      _cli_options_map_["--cxx-epilogue-file"] =
+      &::cli::thunk< options, NarrowString, &options::cxx_epilogue_file_,
+        &options::cxx_epilogue_file_specified_ >;
+      _cli_options_map_["--fwd-epilogue-file"] =
+      &::cli::thunk< options, NarrowString, &options::fwd_epilogue_file_,
+        &options::fwd_epilogue_file_specified_ >;
+      _cli_options_map_["--epilogue-file"] =
+      &::cli::thunk< options, NarrowString, &options::epilogue_file_,
+        &options::epilogue_file_specified_ >;
+      _cli_options_map_["--export-symbol"] =
+      &::cli::thunk< options, NarrowString, &options::export_symbol_,
+        &options::export_symbol_specified_ >;
+      _cli_options_map_["--export-xml-schema"] =
+      &::cli::thunk< options, &options::export_xml_schema_ >;
+      _cli_options_map_["--export-maps"] =
+      &::cli::thunk< options, &options::export_maps_ >;
+      _cli_options_map_["--import-maps"] =
+      &::cli::thunk< options, &options::import_maps_ >;
+      _cli_options_map_["--generate-dep"] =
+      &::cli::thunk< options, &options::generate_dep_ >;
+      _cli_options_map_["--generate-dep-only"] =
+      &::cli::thunk< options, &options::generate_dep_only_ >;
+      _cli_options_map_["--dep-phony"] =
+      &::cli::thunk< options, &options::dep_phony_ >;
+      _cli_options_map_["--dep-target"] =
+      &::cli::thunk< options, NarrowStrings, &options::dep_target_,
+        &options::dep_target_specified_ >;
+      _cli_options_map_["--dep-suffix"] =
+      &::cli::thunk< options, NarrowString, &options::dep_suffix_,
+        &options::dep_suffix_specified_ >;
+      _cli_options_map_["--dep-file"] =
+      &::cli::thunk< options, NarrowString, &options::dep_file_,
+        &options::dep_file_specified_ >;
+      _cli_options_map_["--dep-regex"] =
+      &::cli::thunk< options, NarrowString, &options::dep_regex_,
+        &options::dep_regex_specified_ >;
+    }
+  };
+
+  static _cli_options_map_init _cli_options_map_init_;
+
+  bool options::
+  _parse (const char* o, ::cli::scanner& s)
+  {
+    _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+    if (i != _cli_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // options base
+    //
+    if (::options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/pregenerated/xsd/cxx/options.hxx b/xsd/pregenerated/xsd/cxx/options.hxx
new file mode 100644
index 0000000..085aa4c
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/options.hxx
@@ -0,0 +1,451 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef XSD_CXX_OPTIONS_HXX
+#define XSD_CXX_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/option-types.hxx>
+
+#include <xsd/options.hxx>
+
+namespace CXX
+{
+  class options: public ::options
+  {
+    public:
+    // Option accessors.
+    //
+    const cxx_version&
+    std () const;
+
+    bool
+    std_specified () const;
+
+    const NarrowString&
+    char_type () const;
+
+    bool
+    char_type_specified () const;
+
+    const NarrowString&
+    char_encoding () const;
+
+    bool
+    char_encoding_specified () const;
+
+    const NarrowString&
+    output_dir () const;
+
+    bool
+    output_dir_specified () const;
+
+    const bool&
+    generate_inline () const;
+
+    const bool&
+    generate_xml_schema () const;
+
+    const NarrowString&
+    extern_xml_schema () const;
+
+    bool
+    extern_xml_schema_specified () const;
+
+    const NarrowStrings&
+    namespace_map () const;
+
+    bool
+    namespace_map_specified () const;
+
+    const NarrowStrings&
+    namespace_regex () const;
+
+    bool
+    namespace_regex_specified () const;
+
+    const bool&
+    namespace_regex_trace () const;
+
+    const NarrowStrings&
+    reserved_name () const;
+
+    bool
+    reserved_name_specified () const;
+
+    const bool&
+    include_with_brackets () const;
+
+    const NarrowString&
+    include_prefix () const;
+
+    bool
+    include_prefix_specified () const;
+
+    const NarrowStrings&
+    include_regex () const;
+
+    bool
+    include_regex_specified () const;
+
+    const bool&
+    include_regex_trace () const;
+
+    const NarrowString&
+    guard_prefix () const;
+
+    bool
+    guard_prefix_specified () const;
+
+    const NarrowString&
+    hxx_suffix () const;
+
+    bool
+    hxx_suffix_specified () const;
+
+    const NarrowString&
+    ixx_suffix () const;
+
+    bool
+    ixx_suffix_specified () const;
+
+    const NarrowString&
+    cxx_suffix () const;
+
+    bool
+    cxx_suffix_specified () const;
+
+    const NarrowString&
+    fwd_suffix () const;
+
+    bool
+    fwd_suffix_specified () const;
+
+    const NarrowString&
+    hxx_regex () const;
+
+    bool
+    hxx_regex_specified () const;
+
+    const NarrowString&
+    ixx_regex () const;
+
+    bool
+    ixx_regex_specified () const;
+
+    const NarrowString&
+    cxx_regex () const;
+
+    bool
+    cxx_regex_specified () const;
+
+    const NarrowString&
+    fwd_regex () const;
+
+    bool
+    fwd_regex_specified () const;
+
+    const NarrowStrings&
+    hxx_prologue () const;
+
+    bool
+    hxx_prologue_specified () const;
+
+    const NarrowStrings&
+    ixx_prologue () const;
+
+    bool
+    ixx_prologue_specified () const;
+
+    const NarrowStrings&
+    cxx_prologue () const;
+
+    bool
+    cxx_prologue_specified () const;
+
+    const NarrowStrings&
+    fwd_prologue () const;
+
+    bool
+    fwd_prologue_specified () const;
+
+    const NarrowStrings&
+    prologue () const;
+
+    bool
+    prologue_specified () const;
+
+    const NarrowStrings&
+    hxx_epilogue () const;
+
+    bool
+    hxx_epilogue_specified () const;
+
+    const NarrowStrings&
+    ixx_epilogue () const;
+
+    bool
+    ixx_epilogue_specified () const;
+
+    const NarrowStrings&
+    cxx_epilogue () const;
+
+    bool
+    cxx_epilogue_specified () const;
+
+    const NarrowStrings&
+    fwd_epilogue () const;
+
+    bool
+    fwd_epilogue_specified () const;
+
+    const NarrowStrings&
+    epilogue () const;
+
+    bool
+    epilogue_specified () const;
+
+    const NarrowString&
+    hxx_prologue_file () const;
+
+    bool
+    hxx_prologue_file_specified () const;
+
+    const NarrowString&
+    ixx_prologue_file () const;
+
+    bool
+    ixx_prologue_file_specified () const;
+
+    const NarrowString&
+    cxx_prologue_file () const;
+
+    bool
+    cxx_prologue_file_specified () const;
+
+    const NarrowString&
+    fwd_prologue_file () const;
+
+    bool
+    fwd_prologue_file_specified () const;
+
+    const NarrowString&
+    prologue_file () const;
+
+    bool
+    prologue_file_specified () const;
+
+    const NarrowString&
+    hxx_epilogue_file () const;
+
+    bool
+    hxx_epilogue_file_specified () const;
+
+    const NarrowString&
+    ixx_epilogue_file () const;
+
+    bool
+    ixx_epilogue_file_specified () const;
+
+    const NarrowString&
+    cxx_epilogue_file () const;
+
+    bool
+    cxx_epilogue_file_specified () const;
+
+    const NarrowString&
+    fwd_epilogue_file () const;
+
+    bool
+    fwd_epilogue_file_specified () const;
+
+    const NarrowString&
+    epilogue_file () const;
+
+    bool
+    epilogue_file_specified () const;
+
+    const NarrowString&
+    export_symbol () const;
+
+    bool
+    export_symbol_specified () const;
+
+    const bool&
+    export_xml_schema () const;
+
+    const bool&
+    export_maps () const;
+
+    const bool&
+    import_maps () const;
+
+    const bool&
+    generate_dep () const;
+
+    const bool&
+    generate_dep_only () const;
+
+    const bool&
+    dep_phony () const;
+
+    const NarrowStrings&
+    dep_target () const;
+
+    bool
+    dep_target_specified () const;
+
+    const NarrowString&
+    dep_suffix () const;
+
+    bool
+    dep_suffix_specified () const;
+
+    const NarrowString&
+    dep_file () const;
+
+    bool
+    dep_file_specified () const;
+
+    const NarrowString&
+    dep_regex () const;
+
+    bool
+    dep_regex_specified () const;
+
+    // Print usage information.
+    //
+    static ::cli::usage_para
+    print_usage (::std::wostream&,
+                 ::cli::usage_para = ::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    options ();
+
+    bool
+    _parse (const char*, ::cli::scanner&);
+
+    public:
+    cxx_version std_;
+    bool std_specified_;
+    NarrowString char_type_;
+    bool char_type_specified_;
+    NarrowString char_encoding_;
+    bool char_encoding_specified_;
+    NarrowString output_dir_;
+    bool output_dir_specified_;
+    bool generate_inline_;
+    bool generate_xml_schema_;
+    NarrowString extern_xml_schema_;
+    bool extern_xml_schema_specified_;
+    NarrowStrings namespace_map_;
+    bool namespace_map_specified_;
+    NarrowStrings namespace_regex_;
+    bool namespace_regex_specified_;
+    bool namespace_regex_trace_;
+    NarrowStrings reserved_name_;
+    bool reserved_name_specified_;
+    bool include_with_brackets_;
+    NarrowString include_prefix_;
+    bool include_prefix_specified_;
+    NarrowStrings include_regex_;
+    bool include_regex_specified_;
+    bool include_regex_trace_;
+    NarrowString guard_prefix_;
+    bool guard_prefix_specified_;
+    NarrowString hxx_suffix_;
+    bool hxx_suffix_specified_;
+    NarrowString ixx_suffix_;
+    bool ixx_suffix_specified_;
+    NarrowString cxx_suffix_;
+    bool cxx_suffix_specified_;
+    NarrowString fwd_suffix_;
+    bool fwd_suffix_specified_;
+    NarrowString hxx_regex_;
+    bool hxx_regex_specified_;
+    NarrowString ixx_regex_;
+    bool ixx_regex_specified_;
+    NarrowString cxx_regex_;
+    bool cxx_regex_specified_;
+    NarrowString fwd_regex_;
+    bool fwd_regex_specified_;
+    NarrowStrings hxx_prologue_;
+    bool hxx_prologue_specified_;
+    NarrowStrings ixx_prologue_;
+    bool ixx_prologue_specified_;
+    NarrowStrings cxx_prologue_;
+    bool cxx_prologue_specified_;
+    NarrowStrings fwd_prologue_;
+    bool fwd_prologue_specified_;
+    NarrowStrings prologue_;
+    bool prologue_specified_;
+    NarrowStrings hxx_epilogue_;
+    bool hxx_epilogue_specified_;
+    NarrowStrings ixx_epilogue_;
+    bool ixx_epilogue_specified_;
+    NarrowStrings cxx_epilogue_;
+    bool cxx_epilogue_specified_;
+    NarrowStrings fwd_epilogue_;
+    bool fwd_epilogue_specified_;
+    NarrowStrings epilogue_;
+    bool epilogue_specified_;
+    NarrowString hxx_prologue_file_;
+    bool hxx_prologue_file_specified_;
+    NarrowString ixx_prologue_file_;
+    bool ixx_prologue_file_specified_;
+    NarrowString cxx_prologue_file_;
+    bool cxx_prologue_file_specified_;
+    NarrowString fwd_prologue_file_;
+    bool fwd_prologue_file_specified_;
+    NarrowString prologue_file_;
+    bool prologue_file_specified_;
+    NarrowString hxx_epilogue_file_;
+    bool hxx_epilogue_file_specified_;
+    NarrowString ixx_epilogue_file_;
+    bool ixx_epilogue_file_specified_;
+    NarrowString cxx_epilogue_file_;
+    bool cxx_epilogue_file_specified_;
+    NarrowString fwd_epilogue_file_;
+    bool fwd_epilogue_file_specified_;
+    NarrowString epilogue_file_;
+    bool epilogue_file_specified_;
+    NarrowString export_symbol_;
+    bool export_symbol_specified_;
+    bool export_xml_schema_;
+    bool export_maps_;
+    bool import_maps_;
+    bool generate_dep_;
+    bool generate_dep_only_;
+    bool dep_phony_;
+    NarrowStrings dep_target_;
+    bool dep_target_specified_;
+    NarrowString dep_suffix_;
+    bool dep_suffix_specified_;
+    NarrowString dep_file_;
+    bool dep_file_specified_;
+    NarrowString dep_regex_;
+    bool dep_regex_specified_;
+  };
+}
+
+#include <xsd/cxx/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // XSD_CXX_OPTIONS_HXX
diff --git a/xsd/pregenerated/xsd/cxx/options.ixx b/xsd/pregenerated/xsd/cxx/options.ixx
new file mode 100644
index 0000000..8266e31
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/options.ixx
@@ -0,0 +1,615 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  // options
+  //
+
+  inline const cxx_version& options::
+  std () const
+  {
+    return this->std_;
+  }
+
+  inline bool options::
+  std_specified () const
+  {
+    return this->std_specified_;
+  }
+
+  inline const NarrowString& options::
+  char_type () const
+  {
+    return this->char_type_;
+  }
+
+  inline bool options::
+  char_type_specified () const
+  {
+    return this->char_type_specified_;
+  }
+
+  inline const NarrowString& options::
+  char_encoding () const
+  {
+    return this->char_encoding_;
+  }
+
+  inline bool options::
+  char_encoding_specified () const
+  {
+    return this->char_encoding_specified_;
+  }
+
+  inline const NarrowString& options::
+  output_dir () const
+  {
+    return this->output_dir_;
+  }
+
+  inline bool options::
+  output_dir_specified () const
+  {
+    return this->output_dir_specified_;
+  }
+
+  inline const bool& options::
+  generate_inline () const
+  {
+    return this->generate_inline_;
+  }
+
+  inline const bool& options::
+  generate_xml_schema () const
+  {
+    return this->generate_xml_schema_;
+  }
+
+  inline const NarrowString& options::
+  extern_xml_schema () const
+  {
+    return this->extern_xml_schema_;
+  }
+
+  inline bool options::
+  extern_xml_schema_specified () const
+  {
+    return this->extern_xml_schema_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  namespace_map () const
+  {
+    return this->namespace_map_;
+  }
+
+  inline bool options::
+  namespace_map_specified () const
+  {
+    return this->namespace_map_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  namespace_regex () const
+  {
+    return this->namespace_regex_;
+  }
+
+  inline bool options::
+  namespace_regex_specified () const
+  {
+    return this->namespace_regex_specified_;
+  }
+
+  inline const bool& options::
+  namespace_regex_trace () const
+  {
+    return this->namespace_regex_trace_;
+  }
+
+  inline const NarrowStrings& options::
+  reserved_name () const
+  {
+    return this->reserved_name_;
+  }
+
+  inline bool options::
+  reserved_name_specified () const
+  {
+    return this->reserved_name_specified_;
+  }
+
+  inline const bool& options::
+  include_with_brackets () const
+  {
+    return this->include_with_brackets_;
+  }
+
+  inline const NarrowString& options::
+  include_prefix () const
+  {
+    return this->include_prefix_;
+  }
+
+  inline bool options::
+  include_prefix_specified () const
+  {
+    return this->include_prefix_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  include_regex () const
+  {
+    return this->include_regex_;
+  }
+
+  inline bool options::
+  include_regex_specified () const
+  {
+    return this->include_regex_specified_;
+  }
+
+  inline const bool& options::
+  include_regex_trace () const
+  {
+    return this->include_regex_trace_;
+  }
+
+  inline const NarrowString& options::
+  guard_prefix () const
+  {
+    return this->guard_prefix_;
+  }
+
+  inline bool options::
+  guard_prefix_specified () const
+  {
+    return this->guard_prefix_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_suffix () const
+  {
+    return this->hxx_suffix_;
+  }
+
+  inline bool options::
+  hxx_suffix_specified () const
+  {
+    return this->hxx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_suffix () const
+  {
+    return this->ixx_suffix_;
+  }
+
+  inline bool options::
+  ixx_suffix_specified () const
+  {
+    return this->ixx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_suffix () const
+  {
+    return this->cxx_suffix_;
+  }
+
+  inline bool options::
+  cxx_suffix_specified () const
+  {
+    return this->cxx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_suffix () const
+  {
+    return this->fwd_suffix_;
+  }
+
+  inline bool options::
+  fwd_suffix_specified () const
+  {
+    return this->fwd_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_regex () const
+  {
+    return this->hxx_regex_;
+  }
+
+  inline bool options::
+  hxx_regex_specified () const
+  {
+    return this->hxx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_regex () const
+  {
+    return this->ixx_regex_;
+  }
+
+  inline bool options::
+  ixx_regex_specified () const
+  {
+    return this->ixx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_regex () const
+  {
+    return this->cxx_regex_;
+  }
+
+  inline bool options::
+  cxx_regex_specified () const
+  {
+    return this->cxx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_regex () const
+  {
+    return this->fwd_regex_;
+  }
+
+  inline bool options::
+  fwd_regex_specified () const
+  {
+    return this->fwd_regex_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  hxx_prologue () const
+  {
+    return this->hxx_prologue_;
+  }
+
+  inline bool options::
+  hxx_prologue_specified () const
+  {
+    return this->hxx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  ixx_prologue () const
+  {
+    return this->ixx_prologue_;
+  }
+
+  inline bool options::
+  ixx_prologue_specified () const
+  {
+    return this->ixx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  cxx_prologue () const
+  {
+    return this->cxx_prologue_;
+  }
+
+  inline bool options::
+  cxx_prologue_specified () const
+  {
+    return this->cxx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  fwd_prologue () const
+  {
+    return this->fwd_prologue_;
+  }
+
+  inline bool options::
+  fwd_prologue_specified () const
+  {
+    return this->fwd_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  prologue () const
+  {
+    return this->prologue_;
+  }
+
+  inline bool options::
+  prologue_specified () const
+  {
+    return this->prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  hxx_epilogue () const
+  {
+    return this->hxx_epilogue_;
+  }
+
+  inline bool options::
+  hxx_epilogue_specified () const
+  {
+    return this->hxx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  ixx_epilogue () const
+  {
+    return this->ixx_epilogue_;
+  }
+
+  inline bool options::
+  ixx_epilogue_specified () const
+  {
+    return this->ixx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  cxx_epilogue () const
+  {
+    return this->cxx_epilogue_;
+  }
+
+  inline bool options::
+  cxx_epilogue_specified () const
+  {
+    return this->cxx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  fwd_epilogue () const
+  {
+    return this->fwd_epilogue_;
+  }
+
+  inline bool options::
+  fwd_epilogue_specified () const
+  {
+    return this->fwd_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  epilogue () const
+  {
+    return this->epilogue_;
+  }
+
+  inline bool options::
+  epilogue_specified () const
+  {
+    return this->epilogue_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_prologue_file () const
+  {
+    return this->hxx_prologue_file_;
+  }
+
+  inline bool options::
+  hxx_prologue_file_specified () const
+  {
+    return this->hxx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_prologue_file () const
+  {
+    return this->ixx_prologue_file_;
+  }
+
+  inline bool options::
+  ixx_prologue_file_specified () const
+  {
+    return this->ixx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_prologue_file () const
+  {
+    return this->cxx_prologue_file_;
+  }
+
+  inline bool options::
+  cxx_prologue_file_specified () const
+  {
+    return this->cxx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_prologue_file () const
+  {
+    return this->fwd_prologue_file_;
+  }
+
+  inline bool options::
+  fwd_prologue_file_specified () const
+  {
+    return this->fwd_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  prologue_file () const
+  {
+    return this->prologue_file_;
+  }
+
+  inline bool options::
+  prologue_file_specified () const
+  {
+    return this->prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_epilogue_file () const
+  {
+    return this->hxx_epilogue_file_;
+  }
+
+  inline bool options::
+  hxx_epilogue_file_specified () const
+  {
+    return this->hxx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_epilogue_file () const
+  {
+    return this->ixx_epilogue_file_;
+  }
+
+  inline bool options::
+  ixx_epilogue_file_specified () const
+  {
+    return this->ixx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_epilogue_file () const
+  {
+    return this->cxx_epilogue_file_;
+  }
+
+  inline bool options::
+  cxx_epilogue_file_specified () const
+  {
+    return this->cxx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_epilogue_file () const
+  {
+    return this->fwd_epilogue_file_;
+  }
+
+  inline bool options::
+  fwd_epilogue_file_specified () const
+  {
+    return this->fwd_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  epilogue_file () const
+  {
+    return this->epilogue_file_;
+  }
+
+  inline bool options::
+  epilogue_file_specified () const
+  {
+    return this->epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  export_symbol () const
+  {
+    return this->export_symbol_;
+  }
+
+  inline bool options::
+  export_symbol_specified () const
+  {
+    return this->export_symbol_specified_;
+  }
+
+  inline const bool& options::
+  export_xml_schema () const
+  {
+    return this->export_xml_schema_;
+  }
+
+  inline const bool& options::
+  export_maps () const
+  {
+    return this->export_maps_;
+  }
+
+  inline const bool& options::
+  import_maps () const
+  {
+    return this->import_maps_;
+  }
+
+  inline const bool& options::
+  generate_dep () const
+  {
+    return this->generate_dep_;
+  }
+
+  inline const bool& options::
+  generate_dep_only () const
+  {
+    return this->generate_dep_only_;
+  }
+
+  inline const bool& options::
+  dep_phony () const
+  {
+    return this->dep_phony_;
+  }
+
+  inline const NarrowStrings& options::
+  dep_target () const
+  {
+    return this->dep_target_;
+  }
+
+  inline bool options::
+  dep_target_specified () const
+  {
+    return this->dep_target_specified_;
+  }
+
+  inline const NarrowString& options::
+  dep_suffix () const
+  {
+    return this->dep_suffix_;
+  }
+
+  inline bool options::
+  dep_suffix_specified () const
+  {
+    return this->dep_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  dep_file () const
+  {
+    return this->dep_file_;
+  }
+
+  inline bool options::
+  dep_file_specified () const
+  {
+    return this->dep_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  dep_regex () const
+  {
+    return this->dep_regex_;
+  }
+
+  inline bool options::
+  dep_regex_specified () const
+  {
+    return this->dep_regex_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/pregenerated/xsd/cxx/parser/options.cxx b/xsd/pregenerated/xsd/cxx/parser/options.cxx
new file mode 100644
index 0000000..60667ac
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/parser/options.cxx
@@ -0,0 +1,776 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <xsd/options-parser.hxx>
+//
+// End prologue.
+
+#include <xsd/cxx/parser/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      using namespace std;
+
+      const char* o (s.next ());
+      if (s.more ())
+      {
+        string v (s.next ());
+        istringstream is (v);
+        if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        const char* v (s.next ());
+
+        if (std::strcmp (v, "1")    == 0 ||
+            std::strcmp (v, "true") == 0 ||
+            std::strcmp (v, "TRUE") == 0 ||
+            std::strcmp (v, "True") == 0)
+          x = true;
+        else if (std::strcmp (v, "0")     == 0 ||
+                 std::strcmp (v, "false") == 0 ||
+                 std::strcmp (v, "FALSE") == 0 ||
+                 std::strcmp (v, "False") == 0)
+          x = false;
+        else
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::pair<X, std::size_t> >
+  {
+    static void
+    parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+    {
+      x.second = s.position ();
+      parser<X>::parse (x.first, xs, s);
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X, typename C>
+  struct parser<std::set<X, C> >
+  {
+    static void
+    parse (std::set<X, C>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::map<K, V, C> >
+  {
+    static void
+    parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m[k] = v;
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::multimap<K, V, C> >
+  {
+    static void
+    parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, bool X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    s.next ();
+    x.*M = true;
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+
+namespace CXX
+{
+  namespace Parser
+  {
+    // options
+    //
+
+    options::
+    options ()
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (::cli::scanner& s,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      _parse (s, opt, arg);
+    }
+
+    ::cli::usage_para options::
+    print_usage (::std::wostream& os, ::cli::usage_para p)
+    {
+      CLI_POTENTIALLY_UNUSED (os);
+
+      if (p == ::cli::usage_para::text)
+        os << ::std::endl;
+
+      os << "--type-map <mapfile>         Read XML Schema to C++ type mapping information" << ::std::endl
+         << "                             from <mapfile>." << ::std::endl;
+
+      os << "--xml-parser <parser>        Use <parser> as the underlying XML parser." << ::std::endl;
+
+      os << "--generate-validation        Generate validation code." << ::std::endl;
+
+      os << "--suppress-validation        Suppress the generation of validation code." << ::std::endl;
+
+      os << "--generate-polymorphic       Generate polymorphism-aware code." << ::std::endl;
+
+      os << "--generate-noop-impl         Generate a sample parser implementation that does" << ::std::endl
+         << "                             nothing (no operation)." << ::std::endl;
+
+      os << "--generate-print-impl        Generate a sample parser implementation that" << ::std::endl
+         << "                             prints the XML data to STDOUT." << ::std::endl;
+
+      os << "--generate-test-driver       Generate a test driver for the sample parser" << ::std::endl
+         << "                             implementation." << ::std::endl;
+
+      os << "--force-overwrite            Force overwriting of the existing implementation" << ::std::endl
+         << "                             and test driver files." << ::std::endl;
+
+      os << "--root-element-first         Indicate that the first global element is the" << ::std::endl
+         << "                             document root." << ::std::endl;
+
+      os << "--root-element-last          Indicate that the last global element is the" << ::std::endl
+         << "                             document root." << ::std::endl;
+
+      os << "--root-element <element>     Indicate that <element> is the document root." << ::std::endl;
+
+      os << "--skel-type-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             _pskel to construct the names of the generated" << ::std::endl
+         << "                             parser skeletons." << ::std::endl;
+
+      os << "--skel-file-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             -pskel to construct the names of the generated" << ::std::endl
+         << "                             parser skeleton files." << ::std::endl;
+
+      os << "--impl-type-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             _pimpl to construct the names of the parser" << ::std::endl
+         << "                             implementations for the built-in XML Schema types" << ::std::endl
+         << "                             as well as sample parser implementations." << ::std::endl;
+
+      os << "--impl-file-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             -pimpl to construct the names of the generated" << ::std::endl
+         << "                             sample parser implementation files." << ::std::endl;
+
+      p = ::cli::usage_para::option;
+
+      return p;
+    }
+
+    typedef
+    std::map<std::string, void (*) (options&, ::cli::scanner&)>
+    _cli_options_map;
+
+    static _cli_options_map _cli_options_map_;
+
+    struct _cli_options_map_init
+    {
+      _cli_options_map_init ()
+      {
+        _cli_options_map_["--type-map"] =
+        &::cli::thunk< options, NarrowStrings, &options::type_map_,
+          &options::type_map_specified_ >;
+        _cli_options_map_["--xml-parser"] =
+        &::cli::thunk< options, NarrowString, &options::xml_parser_,
+          &options::xml_parser_specified_ >;
+        _cli_options_map_["--generate-validation"] =
+        &::cli::thunk< options, &options::generate_validation_ >;
+        _cli_options_map_["--suppress-validation"] =
+        &::cli::thunk< options, &options::suppress_validation_ >;
+        _cli_options_map_["--generate-polymorphic"] =
+        &::cli::thunk< options, &options::generate_polymorphic_ >;
+        _cli_options_map_["--generate-noop-impl"] =
+        &::cli::thunk< options, &options::generate_noop_impl_ >;
+        _cli_options_map_["--generate-print-impl"] =
+        &::cli::thunk< options, &options::generate_print_impl_ >;
+        _cli_options_map_["--generate-test-driver"] =
+        &::cli::thunk< options, &options::generate_test_driver_ >;
+        _cli_options_map_["--force-overwrite"] =
+        &::cli::thunk< options, &options::force_overwrite_ >;
+        _cli_options_map_["--root-element-first"] =
+        &::cli::thunk< options, &options::root_element_first_ >;
+        _cli_options_map_["--root-element-last"] =
+        &::cli::thunk< options, &options::root_element_last_ >;
+        _cli_options_map_["--root-element"] =
+        &::cli::thunk< options, NarrowString, &options::root_element_,
+          &options::root_element_specified_ >;
+        _cli_options_map_["--skel-type-suffix"] =
+        &::cli::thunk< options, NarrowString, &options::skel_type_suffix_,
+          &options::skel_type_suffix_specified_ >;
+        _cli_options_map_["--skel-file-suffix"] =
+        &::cli::thunk< options, NarrowString, &options::skel_file_suffix_,
+          &options::skel_file_suffix_specified_ >;
+        _cli_options_map_["--impl-type-suffix"] =
+        &::cli::thunk< options, NarrowString, &options::impl_type_suffix_,
+          &options::impl_type_suffix_specified_ >;
+        _cli_options_map_["--impl-file-suffix"] =
+        &::cli::thunk< options, NarrowString, &options::impl_file_suffix_,
+          &options::impl_file_suffix_specified_ >;
+      }
+    };
+
+    static _cli_options_map_init _cli_options_map_init_;
+
+    bool options::
+    _parse (const char* o, ::cli::scanner& s)
+    {
+      _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+      if (i != _cli_options_map_.end ())
+      {
+        (*(i->second)) (*this, s);
+        return true;
+      }
+
+      // options base
+      //
+      if (::CXX::options::_parse (o, s))
+        return true;
+
+      return false;
+    }
+
+    bool options::
+    _parse (::cli::scanner& s,
+            ::cli::unknown_mode opt_mode,
+            ::cli::unknown_mode arg_mode)
+    {
+      // Can't skip combined flags (--no-combined-flags).
+      //
+      assert (opt_mode != ::cli::unknown_mode::skip);
+
+      bool r = false;
+      bool opt = true;
+
+      while (s.more ())
+      {
+        const char* o = s.peek ();
+
+        if (std::strcmp (o, "--") == 0)
+        {
+          opt = false;
+          s.skip ();
+          r = true;
+          continue;
+        }
+
+        if (opt)
+        {
+          if (_parse (o, s))
+          {
+            r = true;
+            continue;
+          }
+
+          if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+          {
+            // Handle combined option values.
+            //
+            std::string co;
+            if (const char* v = std::strchr (o, '='))
+            {
+              co.assign (o, 0, v - o);
+              ++v;
+
+              int ac (2);
+              char* av[] =
+              {
+                const_cast<char*> (co.c_str ()),
+                const_cast<char*> (v)
+              };
+
+              ::cli::argv_scanner ns (0, ac, av);
+
+              if (_parse (co.c_str (), ns))
+              {
+                // Parsed the option but not its value?
+                //
+                if (ns.end () != 2)
+                  throw ::cli::invalid_value (co, v);
+
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = co.c_str ();
+              }
+            }
+
+            // Handle combined flags.
+            //
+            char cf[3];
+            {
+              const char* p = o + 1;
+              for (; *p != '\0'; ++p)
+              {
+                if (!((*p >= 'a' && *p <= 'z') ||
+                      (*p >= 'A' && *p <= 'Z') ||
+                      (*p >= '0' && *p <= '9')))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                for (p = o + 1; *p != '\0'; ++p)
+                {
+                  std::strcpy (cf, "-");
+                  cf[1] = *p;
+                  cf[2] = '\0';
+
+                  int ac (1);
+                  char* av[] =
+                  {
+                    cf
+                  };
+
+                  ::cli::argv_scanner ns (0, ac, av);
+
+                  if (!_parse (cf, ns))
+                    break;
+                }
+
+                if (*p == '\0')
+                {
+                  // All handled.
+                  //
+                  s.next ();
+                  r = true;
+                  continue;
+                }
+                else
+                {
+                  // Set the unknown option and fall through.
+                  //
+                  o = cf;
+                }
+              }
+            }
+
+            switch (opt_mode)
+            {
+              case ::cli::unknown_mode::skip:
+              {
+                s.skip ();
+                r = true;
+                continue;
+              }
+              case ::cli::unknown_mode::stop:
+              {
+                break;
+              }
+              case ::cli::unknown_mode::fail:
+              {
+                throw ::cli::unknown_option (o);
+              }
+            }
+
+            break;
+          }
+        }
+
+        switch (arg_mode)
+        {
+          case ::cli::unknown_mode::skip:
+          {
+            s.skip ();
+            r = true;
+            continue;
+          }
+          case ::cli::unknown_mode::stop:
+          {
+            break;
+          }
+          case ::cli::unknown_mode::fail:
+          {
+            throw ::cli::unknown_argument (o);
+          }
+        }
+
+        break;
+      }
+
+      return r;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/pregenerated/xsd/cxx/parser/options.hxx b/xsd/pregenerated/xsd/cxx/parser/options.hxx
new file mode 100644
index 0000000..03b67fd
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/parser/options.hxx
@@ -0,0 +1,186 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef XSD_CXX_PARSER_OPTIONS_HXX
+#define XSD_CXX_PARSER_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/options.hxx>
+
+namespace CXX
+{
+  namespace Parser
+  {
+    class options: public ::CXX::options
+    {
+      public:
+      options ();
+
+      options (int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (::cli::scanner&,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      // Option accessors.
+      //
+      const NarrowStrings&
+      type_map () const;
+
+      bool
+      type_map_specified () const;
+
+      const NarrowString&
+      xml_parser () const;
+
+      bool
+      xml_parser_specified () const;
+
+      const bool&
+      generate_validation () const;
+
+      const bool&
+      suppress_validation () const;
+
+      const bool&
+      generate_polymorphic () const;
+
+      const bool&
+      generate_noop_impl () const;
+
+      const bool&
+      generate_print_impl () const;
+
+      const bool&
+      generate_test_driver () const;
+
+      const bool&
+      force_overwrite () const;
+
+      const bool&
+      root_element_first () const;
+
+      const bool&
+      root_element_last () const;
+
+      const NarrowString&
+      root_element () const;
+
+      bool
+      root_element_specified () const;
+
+      const NarrowString&
+      skel_type_suffix () const;
+
+      bool
+      skel_type_suffix_specified () const;
+
+      const NarrowString&
+      skel_file_suffix () const;
+
+      bool
+      skel_file_suffix_specified () const;
+
+      const NarrowString&
+      impl_type_suffix () const;
+
+      bool
+      impl_type_suffix_specified () const;
+
+      const NarrowString&
+      impl_file_suffix () const;
+
+      bool
+      impl_file_suffix_specified () const;
+
+      // Print usage information.
+      //
+      static ::cli::usage_para
+      print_usage (::std::wostream&,
+                   ::cli::usage_para = ::cli::usage_para::none);
+
+      // Implementation details.
+      //
+      protected:
+      bool
+      _parse (const char*, ::cli::scanner&);
+
+      private:
+      bool
+      _parse (::cli::scanner&,
+              ::cli::unknown_mode option,
+              ::cli::unknown_mode argument);
+
+      public:
+      NarrowStrings type_map_;
+      bool type_map_specified_;
+      NarrowString xml_parser_;
+      bool xml_parser_specified_;
+      bool generate_validation_;
+      bool suppress_validation_;
+      bool generate_polymorphic_;
+      bool generate_noop_impl_;
+      bool generate_print_impl_;
+      bool generate_test_driver_;
+      bool force_overwrite_;
+      bool root_element_first_;
+      bool root_element_last_;
+      NarrowString root_element_;
+      bool root_element_specified_;
+      NarrowString skel_type_suffix_;
+      bool skel_type_suffix_specified_;
+      NarrowString skel_file_suffix_;
+      bool skel_file_suffix_specified_;
+      NarrowString impl_type_suffix_;
+      bool impl_type_suffix_specified_;
+      NarrowString impl_file_suffix_;
+      bool impl_file_suffix_specified_;
+    };
+  }
+}
+
+#include <xsd/cxx/parser/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // XSD_CXX_PARSER_OPTIONS_HXX
diff --git a/xsd/pregenerated/xsd/cxx/parser/options.ixx b/xsd/pregenerated/xsd/cxx/parser/options.ixx
new file mode 100644
index 0000000..64c00c5
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/parser/options.ixx
@@ -0,0 +1,162 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  namespace Parser
+  {
+    // options
+    //
+
+    inline const NarrowStrings& options::
+    type_map () const
+    {
+      return this->type_map_;
+    }
+
+    inline bool options::
+    type_map_specified () const
+    {
+      return this->type_map_specified_;
+    }
+
+    inline const NarrowString& options::
+    xml_parser () const
+    {
+      return this->xml_parser_;
+    }
+
+    inline bool options::
+    xml_parser_specified () const
+    {
+      return this->xml_parser_specified_;
+    }
+
+    inline const bool& options::
+    generate_validation () const
+    {
+      return this->generate_validation_;
+    }
+
+    inline const bool& options::
+    suppress_validation () const
+    {
+      return this->suppress_validation_;
+    }
+
+    inline const bool& options::
+    generate_polymorphic () const
+    {
+      return this->generate_polymorphic_;
+    }
+
+    inline const bool& options::
+    generate_noop_impl () const
+    {
+      return this->generate_noop_impl_;
+    }
+
+    inline const bool& options::
+    generate_print_impl () const
+    {
+      return this->generate_print_impl_;
+    }
+
+    inline const bool& options::
+    generate_test_driver () const
+    {
+      return this->generate_test_driver_;
+    }
+
+    inline const bool& options::
+    force_overwrite () const
+    {
+      return this->force_overwrite_;
+    }
+
+    inline const bool& options::
+    root_element_first () const
+    {
+      return this->root_element_first_;
+    }
+
+    inline const bool& options::
+    root_element_last () const
+    {
+      return this->root_element_last_;
+    }
+
+    inline const NarrowString& options::
+    root_element () const
+    {
+      return this->root_element_;
+    }
+
+    inline bool options::
+    root_element_specified () const
+    {
+      return this->root_element_specified_;
+    }
+
+    inline const NarrowString& options::
+    skel_type_suffix () const
+    {
+      return this->skel_type_suffix_;
+    }
+
+    inline bool options::
+    skel_type_suffix_specified () const
+    {
+      return this->skel_type_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    skel_file_suffix () const
+    {
+      return this->skel_file_suffix_;
+    }
+
+    inline bool options::
+    skel_file_suffix_specified () const
+    {
+      return this->skel_file_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    impl_type_suffix () const
+    {
+      return this->impl_type_suffix_;
+    }
+
+    inline bool options::
+    impl_type_suffix_specified () const
+    {
+      return this->impl_type_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    impl_file_suffix () const
+    {
+      return this->impl_file_suffix_;
+    }
+
+    inline bool options::
+    impl_file_suffix_specified () const
+    {
+      return this->impl_file_suffix_specified_;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/pregenerated/xsd/cxx/tree/options.cxx b/xsd/pregenerated/xsd/cxx/tree/options.cxx
new file mode 100644
index 0000000..17214c1
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/tree/options.cxx
@@ -0,0 +1,1343 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <xsd/options-parser.hxx>
+//
+// End prologue.
+
+#include <xsd/cxx/tree/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      using namespace std;
+
+      const char* o (s.next ());
+      if (s.more ())
+      {
+        string v (s.next ());
+        istringstream is (v);
+        if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        const char* v (s.next ());
+
+        if (std::strcmp (v, "1")    == 0 ||
+            std::strcmp (v, "true") == 0 ||
+            std::strcmp (v, "TRUE") == 0 ||
+            std::strcmp (v, "True") == 0)
+          x = true;
+        else if (std::strcmp (v, "0")     == 0 ||
+                 std::strcmp (v, "false") == 0 ||
+                 std::strcmp (v, "FALSE") == 0 ||
+                 std::strcmp (v, "False") == 0)
+          x = false;
+        else
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::pair<X, std::size_t> >
+  {
+    static void
+    parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+    {
+      x.second = s.position ();
+      parser<X>::parse (x.first, xs, s);
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X, typename C>
+  struct parser<std::set<X, C> >
+  {
+    static void
+    parse (std::set<X, C>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::map<K, V, C> >
+  {
+    static void
+    parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m[k] = v;
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::multimap<K, V, C> >
+  {
+    static void
+    parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, bool X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    s.next ();
+    x.*M = true;
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    // options
+    //
+
+    options::
+    options ()
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (::cli::scanner& s,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      _parse (s, opt, arg);
+    }
+
+    ::cli::usage_para options::
+    print_usage (::std::wostream& os, ::cli::usage_para p)
+    {
+      CLI_POTENTIALLY_UNUSED (os);
+
+      if (p == ::cli::usage_para::text)
+        os << ::std::endl;
+
+      os << "--generate-polymorphic       Generate polymorphism-aware code." << ::std::endl;
+
+      os << "--polymorphic-type <type>    Indicate that <type> is a root of a polymorphic" << ::std::endl
+         << "                             type hierarchy." << ::std::endl;
+
+      os << "--polymorphic-type-all       Indicate that all types should be treated as" << ::std::endl
+         << "                             polymorphic." << ::std::endl;
+
+      os << "--polymorphic-plate <num>    Specify the polymorphic map plate the generated" << ::std::endl
+         << "                             code should register on." << ::std::endl;
+
+      os << "--ordered-type <type>        Indicate that element order in <type> is" << ::std::endl
+         << "                             significant." << ::std::endl;
+
+      os << "--ordered-type-derived       Automatically treat types derived from ordered" << ::std::endl
+         << "                             bases as also ordered." << ::std::endl;
+
+      os << "--ordered-type-mixed         Automatically treat complex types with mixed" << ::std::endl
+         << "                             content as ordered." << ::std::endl;
+
+      os << "--ordered-type-all           Indicate that element order in all types is" << ::std::endl
+         << "                             significant." << ::std::endl;
+
+      os << "--order-container <type>     Specify a custom class template that should be" << ::std::endl
+         << "                             used as a container for the content order in" << ::std::endl
+         << "                             ordered types instead of the default std::vector." << ::std::endl;
+
+      os << "--generate-serialization     Generate serialization functions." << ::std::endl;
+
+      os << "--generate-ostream           Generate ostream insertion operators (operator<<)" << ::std::endl
+         << "                             for generated types." << ::std::endl;
+
+      os << "--generate-doxygen           Generate documentation comments suitable for" << ::std::endl
+         << "                             extraction by the Doxygen documentation system." << ::std::endl;
+
+      os << "--generate-comparison        Generate comparison operators (operator== and" << ::std::endl
+         << "                             operator!=) for complex types." << ::std::endl;
+
+      os << "--generate-default-ctor      Generate default constructors even for types that" << ::std::endl
+         << "                             have required members." << ::std::endl;
+
+      os << "--generate-from-base-ctor    Generate constructors that expect an instance of a" << ::std::endl
+         << "                             base type followed by all required members." << ::std::endl;
+
+      os << "--suppress-assignment        Suppress the generation of copy assignment" << ::std::endl
+         << "                             operators for complex types." << ::std::endl;
+
+      os << "--generate-detach            Generate detach functions for required elements" << ::std::endl
+         << "                             and attributes." << ::std::endl;
+
+      os << "--generate-wildcard          Generate accessors and modifiers as well as" << ::std::endl
+         << "                             parsing and serialization code for XML Schema" << ::std::endl
+         << "                             wildcards (any and anyAttribute)." << ::std::endl;
+
+      os << "--generate-any-type          Extract and store content of the XML Schema" << ::std::endl
+         << "                             anyType type as a DOM fragment." << ::std::endl;
+
+      os << "--generate-insertion <os>    Generate data representation stream insertion" << ::std::endl
+         << "                             operators for the <os> output stream type." << ::std::endl;
+
+      os << "--generate-extraction <is>   Generate data representation stream extraction" << ::std::endl
+         << "                             constructors for the <is> input stream type." << ::std::endl;
+
+      os << "--generate-forward           Generate a separate header file with forward" << ::std::endl
+         << "                             declarations for the types being generated." << ::std::endl;
+
+      os << "--suppress-parsing           Suppress the generation of the parsing functions" << ::std::endl
+         << "                             and constructors." << ::std::endl;
+
+      os << "--generate-element-type      Generate types instead of parsing and" << ::std::endl
+         << "                             serialization functions for root elements." << ::std::endl;
+
+      os << "--generate-element-map       Generate a root element map that allows uniform" << ::std::endl
+         << "                             parsing and serialization of multiple root" << ::std::endl
+         << "                             elements." << ::std::endl;
+
+      os << "--generate-intellisense      Generate workarounds for IntelliSense bugs in" << ::std::endl
+         << "                             Visual Studio 2005 (8.0)." << ::std::endl;
+
+      os << "--omit-default-attributes    Omit attributes with default and fixed values from" << ::std::endl
+         << "                             serialized XML documents." << ::std::endl;
+
+      os << "--type-naming <style>        Specify the type naming convention that should be" << ::std::endl
+         << "                             used in the generated code." << ::std::endl;
+
+      os << "--function-naming <style>    Specify the function naming convention that should" << ::std::endl
+         << "                             be used in the generated code." << ::std::endl;
+
+      os << "--type-regex <regex>         Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema type names to C++" << ::std::endl
+         << "                             type names." << ::std::endl;
+
+      os << "--accessor-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes to C++ accessor function" << ::std::endl
+         << "                             names." << ::std::endl;
+
+      os << "--one-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality one to C++" << ::std::endl
+         << "                             accessor function names." << ::std::endl;
+
+      os << "--opt-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality optional to" << ::std::endl
+         << "                             C++ accessor function names." << ::std::endl;
+
+      os << "--seq-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality sequence to" << ::std::endl
+         << "                             C++ accessor function names." << ::std::endl;
+
+      os << "--modifier-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes to C++ modifier function" << ::std::endl
+         << "                             names." << ::std::endl;
+
+      os << "--one-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality one to C++" << ::std::endl
+         << "                             modifier function names." << ::std::endl;
+
+      os << "--opt-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality optional to" << ::std::endl
+         << "                             C++ modifier function names." << ::std::endl;
+
+      os << "--seq-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality sequence to" << ::std::endl
+         << "                             C++ modifier function names." << ::std::endl;
+
+      os << "--parser-regex <regex>       Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             parsing function names." << ::std::endl;
+
+      os << "--serializer-regex <regex>   Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             serialization function names." << ::std::endl;
+
+      os << "--const-regex <regex>        Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema-derived names to C++" << ::std::endl
+         << "                             constant names." << ::std::endl;
+
+      os << "--enumerator-regex <regex>   Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema enumeration values to" << ::std::endl
+         << "                             C++ enumerator names." << ::std::endl;
+
+      os << "--element-type-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             element type names." << ::std::endl;
+
+      os << "--name-regex-trace           Trace the process of applying regular expressions" << ::std::endl
+         << "                             specified with the name transformation options." << ::std::endl;
+
+      os << "--root-element-first         Treat only the first global element as a document" << ::std::endl
+         << "                             root." << ::std::endl;
+
+      os << "--root-element-last          Treat only the last global element as a document" << ::std::endl
+         << "                             root." << ::std::endl;
+
+      os << "--root-element-all           Treat all global elements as document roots." << ::std::endl;
+
+      os << "--root-element-none          Do not treat any global elements as document" << ::std::endl
+         << "                             roots." << ::std::endl;
+
+      os << "--root-element <element>     Treat only <element> as a document root." << ::std::endl;
+
+      os << "--custom-type <map>          Use a custom C++ type instead of the generated" << ::std::endl
+         << "                             class." << ::std::endl;
+
+      os << "--custom-type-regex <regex>  Use custom C++ types instead of the generated" << ::std::endl
+         << "                             classes." << ::std::endl;
+
+      os << "--parts <num>                Split generated source code into <num> parts." << ::std::endl;
+
+      os << "--parts-suffix <suffix>      Use <suffix> instead of the default '-' to" << ::std::endl
+         << "                             separate the file name from the part number." << ::std::endl;
+
+      p = ::cli::usage_para::option;
+
+      return p;
+    }
+
+    typedef
+    std::map<std::string, void (*) (options&, ::cli::scanner&)>
+    _cli_options_map;
+
+    static _cli_options_map _cli_options_map_;
+
+    struct _cli_options_map_init
+    {
+      _cli_options_map_init ()
+      {
+        _cli_options_map_["--generate-polymorphic"] =
+        &::cli::thunk< options, &options::generate_polymorphic_ >;
+        _cli_options_map_["--polymorphic-type"] =
+        &::cli::thunk< options, NarrowStrings, &options::polymorphic_type_,
+          &options::polymorphic_type_specified_ >;
+        _cli_options_map_["--polymorphic-type-all"] =
+        &::cli::thunk< options, &options::polymorphic_type_all_ >;
+        _cli_options_map_["--polymorphic-plate"] =
+        &::cli::thunk< options, unsigned long, &options::polymorphic_plate_,
+          &options::polymorphic_plate_specified_ >;
+        _cli_options_map_["--ordered-type"] =
+        &::cli::thunk< options, NarrowStrings, &options::ordered_type_,
+          &options::ordered_type_specified_ >;
+        _cli_options_map_["--ordered-type-derived"] =
+        &::cli::thunk< options, &options::ordered_type_derived_ >;
+        _cli_options_map_["--ordered-type-mixed"] =
+        &::cli::thunk< options, &options::ordered_type_mixed_ >;
+        _cli_options_map_["--ordered-type-all"] =
+        &::cli::thunk< options, &options::ordered_type_all_ >;
+        _cli_options_map_["--order-container"] =
+        &::cli::thunk< options, NarrowString, &options::order_container_,
+          &options::order_container_specified_ >;
+        _cli_options_map_["--generate-serialization"] =
+        &::cli::thunk< options, &options::generate_serialization_ >;
+        _cli_options_map_["--generate-ostream"] =
+        &::cli::thunk< options, &options::generate_ostream_ >;
+        _cli_options_map_["--generate-doxygen"] =
+        &::cli::thunk< options, &options::generate_doxygen_ >;
+        _cli_options_map_["--generate-comparison"] =
+        &::cli::thunk< options, &options::generate_comparison_ >;
+        _cli_options_map_["--generate-default-ctor"] =
+        &::cli::thunk< options, &options::generate_default_ctor_ >;
+        _cli_options_map_["--generate-from-base-ctor"] =
+        &::cli::thunk< options, &options::generate_from_base_ctor_ >;
+        _cli_options_map_["--suppress-assignment"] =
+        &::cli::thunk< options, &options::suppress_assignment_ >;
+        _cli_options_map_["--generate-detach"] =
+        &::cli::thunk< options, &options::generate_detach_ >;
+        _cli_options_map_["--generate-wildcard"] =
+        &::cli::thunk< options, &options::generate_wildcard_ >;
+        _cli_options_map_["--generate-any-type"] =
+        &::cli::thunk< options, &options::generate_any_type_ >;
+        _cli_options_map_["--generate-insertion"] =
+        &::cli::thunk< options, NarrowStrings, &options::generate_insertion_,
+          &options::generate_insertion_specified_ >;
+        _cli_options_map_["--generate-extraction"] =
+        &::cli::thunk< options, NarrowStrings, &options::generate_extraction_,
+          &options::generate_extraction_specified_ >;
+        _cli_options_map_["--generate-forward"] =
+        &::cli::thunk< options, &options::generate_forward_ >;
+        _cli_options_map_["--suppress-parsing"] =
+        &::cli::thunk< options, &options::suppress_parsing_ >;
+        _cli_options_map_["--generate-element-type"] =
+        &::cli::thunk< options, &options::generate_element_type_ >;
+        _cli_options_map_["--generate-element-map"] =
+        &::cli::thunk< options, &options::generate_element_map_ >;
+        _cli_options_map_["--generate-intellisense"] =
+        &::cli::thunk< options, &options::generate_intellisense_ >;
+        _cli_options_map_["--omit-default-attributes"] =
+        &::cli::thunk< options, &options::omit_default_attributes_ >;
+        _cli_options_map_["--type-naming"] =
+        &::cli::thunk< options, NarrowString, &options::type_naming_,
+          &options::type_naming_specified_ >;
+        _cli_options_map_["--function-naming"] =
+        &::cli::thunk< options, NarrowString, &options::function_naming_,
+          &options::function_naming_specified_ >;
+        _cli_options_map_["--type-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::type_regex_,
+          &options::type_regex_specified_ >;
+        _cli_options_map_["--accessor-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::accessor_regex_,
+          &options::accessor_regex_specified_ >;
+        _cli_options_map_["--one-accessor-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::one_accessor_regex_,
+          &options::one_accessor_regex_specified_ >;
+        _cli_options_map_["--opt-accessor-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::opt_accessor_regex_,
+          &options::opt_accessor_regex_specified_ >;
+        _cli_options_map_["--seq-accessor-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::seq_accessor_regex_,
+          &options::seq_accessor_regex_specified_ >;
+        _cli_options_map_["--modifier-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::modifier_regex_,
+          &options::modifier_regex_specified_ >;
+        _cli_options_map_["--one-modifier-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::one_modifier_regex_,
+          &options::one_modifier_regex_specified_ >;
+        _cli_options_map_["--opt-modifier-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::opt_modifier_regex_,
+          &options::opt_modifier_regex_specified_ >;
+        _cli_options_map_["--seq-modifier-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::seq_modifier_regex_,
+          &options::seq_modifier_regex_specified_ >;
+        _cli_options_map_["--parser-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::parser_regex_,
+          &options::parser_regex_specified_ >;
+        _cli_options_map_["--serializer-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::serializer_regex_,
+          &options::serializer_regex_specified_ >;
+        _cli_options_map_["--const-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::const_regex_,
+          &options::const_regex_specified_ >;
+        _cli_options_map_["--enumerator-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::enumerator_regex_,
+          &options::enumerator_regex_specified_ >;
+        _cli_options_map_["--element-type-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::element_type_regex_,
+          &options::element_type_regex_specified_ >;
+        _cli_options_map_["--name-regex-trace"] =
+        &::cli::thunk< options, &options::name_regex_trace_ >;
+        _cli_options_map_["--root-element-first"] =
+        &::cli::thunk< options, &options::root_element_first_ >;
+        _cli_options_map_["--root-element-last"] =
+        &::cli::thunk< options, &options::root_element_last_ >;
+        _cli_options_map_["--root-element-all"] =
+        &::cli::thunk< options, &options::root_element_all_ >;
+        _cli_options_map_["--root-element-none"] =
+        &::cli::thunk< options, &options::root_element_none_ >;
+        _cli_options_map_["--root-element"] =
+        &::cli::thunk< options, NarrowStrings, &options::root_element_,
+          &options::root_element_specified_ >;
+        _cli_options_map_["--custom-type"] =
+        &::cli::thunk< options, NarrowStrings, &options::custom_type_,
+          &options::custom_type_specified_ >;
+        _cli_options_map_["--custom-type-regex"] =
+        &::cli::thunk< options, NarrowStrings, &options::custom_type_regex_,
+          &options::custom_type_regex_specified_ >;
+        _cli_options_map_["--parts"] =
+        &::cli::thunk< options, std::size_t, &options::parts_,
+          &options::parts_specified_ >;
+        _cli_options_map_["--parts-suffix"] =
+        &::cli::thunk< options, NarrowString, &options::parts_suffix_,
+          &options::parts_suffix_specified_ >;
+      }
+    };
+
+    static _cli_options_map_init _cli_options_map_init_;
+
+    bool options::
+    _parse (const char* o, ::cli::scanner& s)
+    {
+      _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+      if (i != _cli_options_map_.end ())
+      {
+        (*(i->second)) (*this, s);
+        return true;
+      }
+
+      // options base
+      //
+      if (::CXX::options::_parse (o, s))
+        return true;
+
+      return false;
+    }
+
+    bool options::
+    _parse (::cli::scanner& s,
+            ::cli::unknown_mode opt_mode,
+            ::cli::unknown_mode arg_mode)
+    {
+      // Can't skip combined flags (--no-combined-flags).
+      //
+      assert (opt_mode != ::cli::unknown_mode::skip);
+
+      bool r = false;
+      bool opt = true;
+
+      while (s.more ())
+      {
+        const char* o = s.peek ();
+
+        if (std::strcmp (o, "--") == 0)
+        {
+          opt = false;
+          s.skip ();
+          r = true;
+          continue;
+        }
+
+        if (opt)
+        {
+          if (_parse (o, s))
+          {
+            r = true;
+            continue;
+          }
+
+          if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+          {
+            // Handle combined option values.
+            //
+            std::string co;
+            if (const char* v = std::strchr (o, '='))
+            {
+              co.assign (o, 0, v - o);
+              ++v;
+
+              int ac (2);
+              char* av[] =
+              {
+                const_cast<char*> (co.c_str ()),
+                const_cast<char*> (v)
+              };
+
+              ::cli::argv_scanner ns (0, ac, av);
+
+              if (_parse (co.c_str (), ns))
+              {
+                // Parsed the option but not its value?
+                //
+                if (ns.end () != 2)
+                  throw ::cli::invalid_value (co, v);
+
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = co.c_str ();
+              }
+            }
+
+            // Handle combined flags.
+            //
+            char cf[3];
+            {
+              const char* p = o + 1;
+              for (; *p != '\0'; ++p)
+              {
+                if (!((*p >= 'a' && *p <= 'z') ||
+                      (*p >= 'A' && *p <= 'Z') ||
+                      (*p >= '0' && *p <= '9')))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                for (p = o + 1; *p != '\0'; ++p)
+                {
+                  std::strcpy (cf, "-");
+                  cf[1] = *p;
+                  cf[2] = '\0';
+
+                  int ac (1);
+                  char* av[] =
+                  {
+                    cf
+                  };
+
+                  ::cli::argv_scanner ns (0, ac, av);
+
+                  if (!_parse (cf, ns))
+                    break;
+                }
+
+                if (*p == '\0')
+                {
+                  // All handled.
+                  //
+                  s.next ();
+                  r = true;
+                  continue;
+                }
+                else
+                {
+                  // Set the unknown option and fall through.
+                  //
+                  o = cf;
+                }
+              }
+            }
+
+            switch (opt_mode)
+            {
+              case ::cli::unknown_mode::skip:
+              {
+                s.skip ();
+                r = true;
+                continue;
+              }
+              case ::cli::unknown_mode::stop:
+              {
+                break;
+              }
+              case ::cli::unknown_mode::fail:
+              {
+                throw ::cli::unknown_option (o);
+              }
+            }
+
+            break;
+          }
+        }
+
+        switch (arg_mode)
+        {
+          case ::cli::unknown_mode::skip:
+          {
+            s.skip ();
+            r = true;
+            continue;
+          }
+          case ::cli::unknown_mode::stop:
+          {
+            break;
+          }
+          case ::cli::unknown_mode::fail:
+          {
+            throw ::cli::unknown_argument (o);
+          }
+        }
+
+        break;
+      }
+
+      return r;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/pregenerated/xsd/cxx/tree/options.hxx b/xsd/pregenerated/xsd/cxx/tree/options.hxx
new file mode 100644
index 0000000..f5a808c
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/tree/options.hxx
@@ -0,0 +1,414 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef XSD_CXX_TREE_OPTIONS_HXX
+#define XSD_CXX_TREE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <xsd/types.hxx>
+
+#include <xsd/cxx/options.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class options: public ::CXX::options
+    {
+      public:
+      options ();
+
+      options (int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (::cli::scanner&,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      // Option accessors.
+      //
+      const bool&
+      generate_polymorphic () const;
+
+      const NarrowStrings&
+      polymorphic_type () const;
+
+      bool
+      polymorphic_type_specified () const;
+
+      const bool&
+      polymorphic_type_all () const;
+
+      const unsigned long&
+      polymorphic_plate () const;
+
+      bool
+      polymorphic_plate_specified () const;
+
+      const NarrowStrings&
+      ordered_type () const;
+
+      bool
+      ordered_type_specified () const;
+
+      const bool&
+      ordered_type_derived () const;
+
+      const bool&
+      ordered_type_mixed () const;
+
+      const bool&
+      ordered_type_all () const;
+
+      const NarrowString&
+      order_container () const;
+
+      bool
+      order_container_specified () const;
+
+      const bool&
+      generate_serialization () const;
+
+      const bool&
+      generate_ostream () const;
+
+      const bool&
+      generate_doxygen () const;
+
+      const bool&
+      generate_comparison () const;
+
+      const bool&
+      generate_default_ctor () const;
+
+      const bool&
+      generate_from_base_ctor () const;
+
+      const bool&
+      suppress_assignment () const;
+
+      const bool&
+      generate_detach () const;
+
+      const bool&
+      generate_wildcard () const;
+
+      const bool&
+      generate_any_type () const;
+
+      const NarrowStrings&
+      generate_insertion () const;
+
+      bool
+      generate_insertion_specified () const;
+
+      const NarrowStrings&
+      generate_extraction () const;
+
+      bool
+      generate_extraction_specified () const;
+
+      const bool&
+      generate_forward () const;
+
+      const bool&
+      suppress_parsing () const;
+
+      const bool&
+      generate_element_type () const;
+
+      const bool&
+      generate_element_map () const;
+
+      const bool&
+      generate_intellisense () const;
+
+      const bool&
+      omit_default_attributes () const;
+
+      const NarrowString&
+      type_naming () const;
+
+      bool
+      type_naming_specified () const;
+
+      const NarrowString&
+      function_naming () const;
+
+      bool
+      function_naming_specified () const;
+
+      const NarrowStrings&
+      type_regex () const;
+
+      bool
+      type_regex_specified () const;
+
+      const NarrowStrings&
+      accessor_regex () const;
+
+      bool
+      accessor_regex_specified () const;
+
+      const NarrowStrings&
+      one_accessor_regex () const;
+
+      bool
+      one_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      opt_accessor_regex () const;
+
+      bool
+      opt_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      seq_accessor_regex () const;
+
+      bool
+      seq_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      modifier_regex () const;
+
+      bool
+      modifier_regex_specified () const;
+
+      const NarrowStrings&
+      one_modifier_regex () const;
+
+      bool
+      one_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      opt_modifier_regex () const;
+
+      bool
+      opt_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      seq_modifier_regex () const;
+
+      bool
+      seq_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      parser_regex () const;
+
+      bool
+      parser_regex_specified () const;
+
+      const NarrowStrings&
+      serializer_regex () const;
+
+      bool
+      serializer_regex_specified () const;
+
+      const NarrowStrings&
+      const_regex () const;
+
+      bool
+      const_regex_specified () const;
+
+      const NarrowStrings&
+      enumerator_regex () const;
+
+      bool
+      enumerator_regex_specified () const;
+
+      const NarrowStrings&
+      element_type_regex () const;
+
+      bool
+      element_type_regex_specified () const;
+
+      const bool&
+      name_regex_trace () const;
+
+      const bool&
+      root_element_first () const;
+
+      const bool&
+      root_element_last () const;
+
+      const bool&
+      root_element_all () const;
+
+      const bool&
+      root_element_none () const;
+
+      const NarrowStrings&
+      root_element () const;
+
+      bool
+      root_element_specified () const;
+
+      const NarrowStrings&
+      custom_type () const;
+
+      bool
+      custom_type_specified () const;
+
+      const NarrowStrings&
+      custom_type_regex () const;
+
+      bool
+      custom_type_regex_specified () const;
+
+      const std::size_t&
+      parts () const;
+
+      bool
+      parts_specified () const;
+
+      const NarrowString&
+      parts_suffix () const;
+
+      bool
+      parts_suffix_specified () const;
+
+      // Print usage information.
+      //
+      static ::cli::usage_para
+      print_usage (::std::wostream&,
+                   ::cli::usage_para = ::cli::usage_para::none);
+
+      // Implementation details.
+      //
+      protected:
+      bool
+      _parse (const char*, ::cli::scanner&);
+
+      private:
+      bool
+      _parse (::cli::scanner&,
+              ::cli::unknown_mode option,
+              ::cli::unknown_mode argument);
+
+      public:
+      bool generate_polymorphic_;
+      NarrowStrings polymorphic_type_;
+      bool polymorphic_type_specified_;
+      bool polymorphic_type_all_;
+      unsigned long polymorphic_plate_;
+      bool polymorphic_plate_specified_;
+      NarrowStrings ordered_type_;
+      bool ordered_type_specified_;
+      bool ordered_type_derived_;
+      bool ordered_type_mixed_;
+      bool ordered_type_all_;
+      NarrowString order_container_;
+      bool order_container_specified_;
+      bool generate_serialization_;
+      bool generate_ostream_;
+      bool generate_doxygen_;
+      bool generate_comparison_;
+      bool generate_default_ctor_;
+      bool generate_from_base_ctor_;
+      bool suppress_assignment_;
+      bool generate_detach_;
+      bool generate_wildcard_;
+      bool generate_any_type_;
+      NarrowStrings generate_insertion_;
+      bool generate_insertion_specified_;
+      NarrowStrings generate_extraction_;
+      bool generate_extraction_specified_;
+      bool generate_forward_;
+      bool suppress_parsing_;
+      bool generate_element_type_;
+      bool generate_element_map_;
+      bool generate_intellisense_;
+      bool omit_default_attributes_;
+      NarrowString type_naming_;
+      bool type_naming_specified_;
+      NarrowString function_naming_;
+      bool function_naming_specified_;
+      NarrowStrings type_regex_;
+      bool type_regex_specified_;
+      NarrowStrings accessor_regex_;
+      bool accessor_regex_specified_;
+      NarrowStrings one_accessor_regex_;
+      bool one_accessor_regex_specified_;
+      NarrowStrings opt_accessor_regex_;
+      bool opt_accessor_regex_specified_;
+      NarrowStrings seq_accessor_regex_;
+      bool seq_accessor_regex_specified_;
+      NarrowStrings modifier_regex_;
+      bool modifier_regex_specified_;
+      NarrowStrings one_modifier_regex_;
+      bool one_modifier_regex_specified_;
+      NarrowStrings opt_modifier_regex_;
+      bool opt_modifier_regex_specified_;
+      NarrowStrings seq_modifier_regex_;
+      bool seq_modifier_regex_specified_;
+      NarrowStrings parser_regex_;
+      bool parser_regex_specified_;
+      NarrowStrings serializer_regex_;
+      bool serializer_regex_specified_;
+      NarrowStrings const_regex_;
+      bool const_regex_specified_;
+      NarrowStrings enumerator_regex_;
+      bool enumerator_regex_specified_;
+      NarrowStrings element_type_regex_;
+      bool element_type_regex_specified_;
+      bool name_regex_trace_;
+      bool root_element_first_;
+      bool root_element_last_;
+      bool root_element_all_;
+      bool root_element_none_;
+      NarrowStrings root_element_;
+      bool root_element_specified_;
+      NarrowStrings custom_type_;
+      bool custom_type_specified_;
+      NarrowStrings custom_type_regex_;
+      bool custom_type_regex_specified_;
+      std::size_t parts_;
+      bool parts_specified_;
+      NarrowString parts_suffix_;
+      bool parts_suffix_specified_;
+    };
+  }
+}
+
+#include <xsd/cxx/tree/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // XSD_CXX_TREE_OPTIONS_HXX
diff --git a/xsd/pregenerated/xsd/cxx/tree/options.ixx b/xsd/pregenerated/xsd/cxx/tree/options.ixx
new file mode 100644
index 0000000..4d34fd9
--- /dev/null
+++ b/xsd/pregenerated/xsd/cxx/tree/options.ixx
@@ -0,0 +1,504 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  namespace Tree
+  {
+    // options
+    //
+
+    inline const bool& options::
+    generate_polymorphic () const
+    {
+      return this->generate_polymorphic_;
+    }
+
+    inline const NarrowStrings& options::
+    polymorphic_type () const
+    {
+      return this->polymorphic_type_;
+    }
+
+    inline bool options::
+    polymorphic_type_specified () const
+    {
+      return this->polymorphic_type_specified_;
+    }
+
+    inline const bool& options::
+    polymorphic_type_all () const
+    {
+      return this->polymorphic_type_all_;
+    }
+
+    inline const unsigned long& options::
+    polymorphic_plate () const
+    {
+      return this->polymorphic_plate_;
+    }
+
+    inline bool options::
+    polymorphic_plate_specified () const
+    {
+      return this->polymorphic_plate_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    ordered_type () const
+    {
+      return this->ordered_type_;
+    }
+
+    inline bool options::
+    ordered_type_specified () const
+    {
+      return this->ordered_type_specified_;
+    }
+
+    inline const bool& options::
+    ordered_type_derived () const
+    {
+      return this->ordered_type_derived_;
+    }
+
+    inline const bool& options::
+    ordered_type_mixed () const
+    {
+      return this->ordered_type_mixed_;
+    }
+
+    inline const bool& options::
+    ordered_type_all () const
+    {
+      return this->ordered_type_all_;
+    }
+
+    inline const NarrowString& options::
+    order_container () const
+    {
+      return this->order_container_;
+    }
+
+    inline bool options::
+    order_container_specified () const
+    {
+      return this->order_container_specified_;
+    }
+
+    inline const bool& options::
+    generate_serialization () const
+    {
+      return this->generate_serialization_;
+    }
+
+    inline const bool& options::
+    generate_ostream () const
+    {
+      return this->generate_ostream_;
+    }
+
+    inline const bool& options::
+    generate_doxygen () const
+    {
+      return this->generate_doxygen_;
+    }
+
+    inline const bool& options::
+    generate_comparison () const
+    {
+      return this->generate_comparison_;
+    }
+
+    inline const bool& options::
+    generate_default_ctor () const
+    {
+      return this->generate_default_ctor_;
+    }
+
+    inline const bool& options::
+    generate_from_base_ctor () const
+    {
+      return this->generate_from_base_ctor_;
+    }
+
+    inline const bool& options::
+    suppress_assignment () const
+    {
+      return this->suppress_assignment_;
+    }
+
+    inline const bool& options::
+    generate_detach () const
+    {
+      return this->generate_detach_;
+    }
+
+    inline const bool& options::
+    generate_wildcard () const
+    {
+      return this->generate_wildcard_;
+    }
+
+    inline const bool& options::
+    generate_any_type () const
+    {
+      return this->generate_any_type_;
+    }
+
+    inline const NarrowStrings& options::
+    generate_insertion () const
+    {
+      return this->generate_insertion_;
+    }
+
+    inline bool options::
+    generate_insertion_specified () const
+    {
+      return this->generate_insertion_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    generate_extraction () const
+    {
+      return this->generate_extraction_;
+    }
+
+    inline bool options::
+    generate_extraction_specified () const
+    {
+      return this->generate_extraction_specified_;
+    }
+
+    inline const bool& options::
+    generate_forward () const
+    {
+      return this->generate_forward_;
+    }
+
+    inline const bool& options::
+    suppress_parsing () const
+    {
+      return this->suppress_parsing_;
+    }
+
+    inline const bool& options::
+    generate_element_type () const
+    {
+      return this->generate_element_type_;
+    }
+
+    inline const bool& options::
+    generate_element_map () const
+    {
+      return this->generate_element_map_;
+    }
+
+    inline const bool& options::
+    generate_intellisense () const
+    {
+      return this->generate_intellisense_;
+    }
+
+    inline const bool& options::
+    omit_default_attributes () const
+    {
+      return this->omit_default_attributes_;
+    }
+
+    inline const NarrowString& options::
+    type_naming () const
+    {
+      return this->type_naming_;
+    }
+
+    inline bool options::
+    type_naming_specified () const
+    {
+      return this->type_naming_specified_;
+    }
+
+    inline const NarrowString& options::
+    function_naming () const
+    {
+      return this->function_naming_;
+    }
+
+    inline bool options::
+    function_naming_specified () const
+    {
+      return this->function_naming_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    type_regex () const
+    {
+      return this->type_regex_;
+    }
+
+    inline bool options::
+    type_regex_specified () const
+    {
+      return this->type_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    accessor_regex () const
+    {
+      return this->accessor_regex_;
+    }
+
+    inline bool options::
+    accessor_regex_specified () const
+    {
+      return this->accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    one_accessor_regex () const
+    {
+      return this->one_accessor_regex_;
+    }
+
+    inline bool options::
+    one_accessor_regex_specified () const
+    {
+      return this->one_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    opt_accessor_regex () const
+    {
+      return this->opt_accessor_regex_;
+    }
+
+    inline bool options::
+    opt_accessor_regex_specified () const
+    {
+      return this->opt_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    seq_accessor_regex () const
+    {
+      return this->seq_accessor_regex_;
+    }
+
+    inline bool options::
+    seq_accessor_regex_specified () const
+    {
+      return this->seq_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    modifier_regex () const
+    {
+      return this->modifier_regex_;
+    }
+
+    inline bool options::
+    modifier_regex_specified () const
+    {
+      return this->modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    one_modifier_regex () const
+    {
+      return this->one_modifier_regex_;
+    }
+
+    inline bool options::
+    one_modifier_regex_specified () const
+    {
+      return this->one_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    opt_modifier_regex () const
+    {
+      return this->opt_modifier_regex_;
+    }
+
+    inline bool options::
+    opt_modifier_regex_specified () const
+    {
+      return this->opt_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    seq_modifier_regex () const
+    {
+      return this->seq_modifier_regex_;
+    }
+
+    inline bool options::
+    seq_modifier_regex_specified () const
+    {
+      return this->seq_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    parser_regex () const
+    {
+      return this->parser_regex_;
+    }
+
+    inline bool options::
+    parser_regex_specified () const
+    {
+      return this->parser_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    serializer_regex () const
+    {
+      return this->serializer_regex_;
+    }
+
+    inline bool options::
+    serializer_regex_specified () const
+    {
+      return this->serializer_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    const_regex () const
+    {
+      return this->const_regex_;
+    }
+
+    inline bool options::
+    const_regex_specified () const
+    {
+      return this->const_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    enumerator_regex () const
+    {
+      return this->enumerator_regex_;
+    }
+
+    inline bool options::
+    enumerator_regex_specified () const
+    {
+      return this->enumerator_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    element_type_regex () const
+    {
+      return this->element_type_regex_;
+    }
+
+    inline bool options::
+    element_type_regex_specified () const
+    {
+      return this->element_type_regex_specified_;
+    }
+
+    inline const bool& options::
+    name_regex_trace () const
+    {
+      return this->name_regex_trace_;
+    }
+
+    inline const bool& options::
+    root_element_first () const
+    {
+      return this->root_element_first_;
+    }
+
+    inline const bool& options::
+    root_element_last () const
+    {
+      return this->root_element_last_;
+    }
+
+    inline const bool& options::
+    root_element_all () const
+    {
+      return this->root_element_all_;
+    }
+
+    inline const bool& options::
+    root_element_none () const
+    {
+      return this->root_element_none_;
+    }
+
+    inline const NarrowStrings& options::
+    root_element () const
+    {
+      return this->root_element_;
+    }
+
+    inline bool options::
+    root_element_specified () const
+    {
+      return this->root_element_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    custom_type () const
+    {
+      return this->custom_type_;
+    }
+
+    inline bool options::
+    custom_type_specified () const
+    {
+      return this->custom_type_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    custom_type_regex () const
+    {
+      return this->custom_type_regex_;
+    }
+
+    inline bool options::
+    custom_type_regex_specified () const
+    {
+      return this->custom_type_regex_specified_;
+    }
+
+    inline const std::size_t& options::
+    parts () const
+    {
+      return this->parts_;
+    }
+
+    inline bool options::
+    parts_specified () const
+    {
+      return this->parts_specified_;
+    }
+
+    inline const NarrowString& options::
+    parts_suffix () const
+    {
+      return this->parts_suffix_;
+    }
+
+    inline bool options::
+    parts_suffix_specified () const
+    {
+      return this->parts_suffix_specified_;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/pregenerated/xsd/options.cxx b/xsd/pregenerated/xsd/options.cxx
new file mode 100644
index 0000000..3022ec4
--- /dev/null
+++ b/xsd/pregenerated/xsd/options.cxx
@@ -0,0 +1,1297 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <xsd/options-parser.hxx>
+//
+// End prologue.
+
+#include <xsd/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <fstream>
+
+namespace cli
+{
+  // unknown_option
+  //
+  unknown_option::
+  ~unknown_option () noexcept
+  {
+  }
+
+  void unknown_option::
+  print (::std::wostream& os) const
+  {
+    os << "unknown option '" << option ().c_str () << "'";
+  }
+
+  const char* unknown_option::
+  what () const noexcept
+  {
+    return "unknown option";
+  }
+
+  // unknown_argument
+  //
+  unknown_argument::
+  ~unknown_argument () noexcept
+  {
+  }
+
+  void unknown_argument::
+  print (::std::wostream& os) const
+  {
+    os << "unknown argument '" << argument ().c_str () << "'";
+  }
+
+  const char* unknown_argument::
+  what () const noexcept
+  {
+    return "unknown argument";
+  }
+
+  // missing_value
+  //
+  missing_value::
+  ~missing_value () noexcept
+  {
+  }
+
+  void missing_value::
+  print (::std::wostream& os) const
+  {
+    os << "missing value for option '" << option ().c_str () << "'";
+  }
+
+  const char* missing_value::
+  what () const noexcept
+  {
+    return "missing option value";
+  }
+
+  // invalid_value
+  //
+  invalid_value::
+  ~invalid_value () noexcept
+  {
+  }
+
+  void invalid_value::
+  print (::std::wostream& os) const
+  {
+    os << "invalid value '" << value ().c_str () << "' for option '"
+       << option ().c_str () << "'";
+
+    if (!message ().empty ())
+      os << ": " << message ().c_str ();
+  }
+
+  const char* invalid_value::
+  what () const noexcept
+  {
+    return "invalid option value";
+  }
+
+  // eos_reached
+  //
+  void eos_reached::
+  print (::std::wostream& os) const
+  {
+    os << what ();
+  }
+
+  const char* eos_reached::
+  what () const noexcept
+  {
+    return "end of argument stream reached";
+  }
+
+  // file_io_failure
+  //
+  file_io_failure::
+  ~file_io_failure () noexcept
+  {
+  }
+
+  void file_io_failure::
+  print (::std::wostream& os) const
+  {
+    os << "unable to open file '" << file ().c_str () << "' or read failure";
+  }
+
+  const char* file_io_failure::
+  what () const noexcept
+  {
+    return "unable to open file or read failure";
+  }
+
+  // unmatched_quote
+  //
+  unmatched_quote::
+  ~unmatched_quote () noexcept
+  {
+  }
+
+  void unmatched_quote::
+  print (::std::wostream& os) const
+  {
+    os << "unmatched quote in argument '" << argument ().c_str () << "'";
+  }
+
+  const char* unmatched_quote::
+  what () const noexcept
+  {
+    return "unmatched quote";
+  }
+
+  // scanner
+  //
+  scanner::
+  ~scanner ()
+  {
+  }
+
+  // argv_scanner
+  //
+  bool argv_scanner::
+  more ()
+  {
+    return i_ < argc_;
+  }
+
+  const char* argv_scanner::
+  peek ()
+  {
+    if (i_ < argc_)
+      return argv_[i_];
+    else
+      throw eos_reached ();
+  }
+
+  const char* argv_scanner::
+  next ()
+  {
+    if (i_ < argc_)
+    {
+      const char* r (argv_[i_]);
+
+      if (erase_)
+      {
+        for (int i (i_ + 1); i < argc_; ++i)
+          argv_[i - 1] = argv_[i];
+
+        --argc_;
+        argv_[argc_] = 0;
+      }
+      else
+        ++i_;
+
+      ++start_position_;
+      return r;
+    }
+    else
+      throw eos_reached ();
+  }
+
+  void argv_scanner::
+  skip ()
+  {
+    if (i_ < argc_)
+    {
+      ++i_;
+      ++start_position_;
+    }
+    else
+      throw eos_reached ();
+  }
+
+  std::size_t argv_scanner::
+  position ()
+  {
+    return start_position_;
+  }
+
+  // argv_file_scanner
+  //
+  int argv_file_scanner::zero_argc_ = 0;
+  std::string argv_file_scanner::empty_string_;
+
+  bool argv_file_scanner::
+  more ()
+  {
+    if (!args_.empty ())
+      return true;
+
+    while (base::more ())
+    {
+      // See if the next argument is the file option.
+      //
+      const char* a (base::peek ());
+      const option_info* oi = 0;
+      const char* ov = 0;
+
+      if (!skip_)
+      {
+        if ((oi = find (a)) != 0)
+        {
+          base::next ();
+
+          if (!base::more ())
+            throw missing_value (a);
+
+          ov = base::next ();
+        }
+        else if (std::strncmp (a, "-", 1) == 0)
+        {
+          if ((ov = std::strchr (a, '=')) != 0)
+          {
+            std::string o (a, 0, ov - a);
+            if ((oi = find (o.c_str ())) != 0)
+            {
+              base::next ();
+              ++ov;
+            }
+          }
+        }
+      }
+
+      if (oi != 0)
+      {
+        if (oi->search_func != 0)
+        {
+          std::string f (oi->search_func (ov, oi->arg));
+
+          if (!f.empty ())
+            load (f);
+        }
+        else
+          load (ov);
+
+        if (!args_.empty ())
+          return true;
+      }
+      else
+      {
+        if (!skip_)
+          skip_ = (std::strcmp (a, "--") == 0);
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  const char* argv_file_scanner::
+  peek ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    return args_.empty () ? base::peek () : args_.front ().value.c_str ();
+  }
+
+  const std::string& argv_file_scanner::
+  peek_file ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    return args_.empty () ? empty_string_ : *args_.front ().file;
+  }
+
+  std::size_t argv_file_scanner::
+  peek_line ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    return args_.empty () ? 0 : args_.front ().line;
+  }
+
+  const char* argv_file_scanner::
+  next ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    if (args_.empty ())
+      return base::next ();
+    else
+    {
+      hold_[i_ == 0 ? ++i_ : --i_].swap (args_.front ().value);
+      args_.pop_front ();
+      ++start_position_;
+      return hold_[i_].c_str ();
+    }
+  }
+
+  void argv_file_scanner::
+  skip ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    if (args_.empty ())
+      return base::skip ();
+    else
+    {
+      args_.pop_front ();
+      ++start_position_;
+    }
+  }
+
+  const argv_file_scanner::option_info* argv_file_scanner::
+  find (const char* a) const
+  {
+    for (std::size_t i (0); i < options_count_; ++i)
+      if (std::strcmp (a, options_[i].option) == 0)
+        return &options_[i];
+
+    return 0;
+  }
+
+  std::size_t argv_file_scanner::
+  position ()
+  {
+    return start_position_;
+  }
+
+  void argv_file_scanner::
+  load (const std::string& file)
+  {
+    using namespace std;
+
+    ifstream is (file.c_str ());
+
+    if (!is.is_open ())
+      throw file_io_failure (file);
+
+    files_.push_back (file);
+
+    arg a;
+    a.file = &*files_.rbegin ();
+
+    for (a.line = 1; !is.eof (); ++a.line)
+    {
+      string line;
+      getline (is, line);
+
+      if (is.fail () && !is.eof ())
+        throw file_io_failure (file);
+
+      string::size_type n (line.size ());
+
+      // Trim the line from leading and trailing whitespaces.
+      //
+      if (n != 0)
+      {
+        const char* f (line.c_str ());
+        const char* l (f + n);
+
+        const char* of (f);
+        while (f < l && (*f == ' ' || *f == '\t' || *f == '\r'))
+          ++f;
+
+        --l;
+
+        const char* ol (l);
+        while (l > f && (*l == ' ' || *l == '\t' || *l == '\r'))
+          --l;
+
+        if (f != of || l != ol)
+          line = f <= l ? string (f, l - f + 1) : string ();
+      }
+
+      // Ignore empty lines, those that start with #.
+      //
+      if (line.empty () || line[0] == '#')
+        continue;
+
+      string::size_type p (string::npos);
+      if (line.compare (0, 1, "-") == 0)
+      {
+        p = line.find (' ');
+
+        string::size_type q (line.find ('='));
+        if (q != string::npos && q < p)
+          p = q;
+      }
+
+      string s1;
+      if (p != string::npos)
+      {
+        s1.assign (line, 0, p);
+
+        // Skip leading whitespaces in the argument.
+        //
+        if (line[p] == '=')
+          ++p;
+        else
+        {
+          n = line.size ();
+          for (++p; p < n; ++p)
+          {
+            char c (line[p]);
+            if (c != ' ' && c != '\t' && c != '\r')
+              break;
+          }
+        }
+      }
+      else if (!skip_)
+        skip_ = (line == "--");
+
+      string s2 (line, p != string::npos ? p : 0);
+
+      // If the string (which is an option value or argument) is
+      // wrapped in quotes, remove them.
+      //
+      n = s2.size ();
+      char cf (s2[0]), cl (s2[n - 1]);
+
+      if (cf == '"' || cf == '\'' || cl == '"' || cl == '\'')
+      {
+        if (n == 1 || cf != cl)
+          throw unmatched_quote (s2);
+
+        s2 = string (s2, 1, n - 2);
+      }
+
+      if (!s1.empty ())
+      {
+        // See if this is another file option.
+        //
+        const option_info* oi;
+        if (!skip_ && (oi = find (s1.c_str ())))
+        {
+          if (s2.empty ())
+            throw missing_value (oi->option);
+
+          if (oi->search_func != 0)
+          {
+            string f (oi->search_func (s2.c_str (), oi->arg));
+            if (!f.empty ())
+              load (f);
+          }
+          else
+          {
+            // If the path of the file being parsed is not simple and the
+            // path of the file that needs to be loaded is relative, then
+            // complete the latter using the former as a base.
+            //
+#ifndef _WIN32
+            string::size_type p (file.find_last_of ('/'));
+            bool c (p != string::npos && s2[0] != '/');
+#else
+            string::size_type p (file.find_last_of ("/\\"));
+            bool c (p != string::npos && s2[1] != ':');
+#endif
+            if (c)
+              s2.insert (0, file, 0, p + 1);
+
+            load (s2);
+          }
+
+          continue;
+        }
+
+        a.value = s1;
+        args_.push_back (a);
+      }
+
+      a.value = s2;
+      args_.push_back (a);
+    }
+  }
+
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      using namespace std;
+
+      const char* o (s.next ());
+      if (s.more ())
+      {
+        string v (s.next ());
+        istringstream is (v);
+        if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        const char* v (s.next ());
+
+        if (std::strcmp (v, "1")    == 0 ||
+            std::strcmp (v, "true") == 0 ||
+            std::strcmp (v, "TRUE") == 0 ||
+            std::strcmp (v, "True") == 0)
+          x = true;
+        else if (std::strcmp (v, "0")     == 0 ||
+                 std::strcmp (v, "false") == 0 ||
+                 std::strcmp (v, "FALSE") == 0 ||
+                 std::strcmp (v, "False") == 0)
+          x = false;
+        else
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::pair<X, std::size_t> >
+  {
+    static void
+    parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+    {
+      x.second = s.position ();
+      parser<X>::parse (x.first, xs, s);
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X, typename C>
+  struct parser<std::set<X, C> >
+  {
+    static void
+    parse (std::set<X, C>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::map<K, V, C> >
+  {
+    static void
+    parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m[k] = v;
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V, typename C>
+  struct parser<std::multimap<K, V, C> >
+  {
+    static void
+    parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+      {
+        std::size_t pos (s.position ());
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        K k = K ();
+        V v = V ();
+        std::string kstr (ov, 0, p);
+        std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+        int ac (2);
+        char* av[] =
+        {
+          const_cast<char*> (o),
+          0
+        };
+
+        bool dummy;
+        if (!kstr.empty ())
+        {
+          av[1] = const_cast<char*> (kstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<K>::parse (k, dummy, s);
+        }
+
+        if (!vstr.empty ())
+        {
+          av[1] = const_cast<char*> (vstr.c_str ());
+          argv_scanner s (0, ac, av, false, pos);
+          parser<V>::parse (v, dummy, s);
+        }
+
+        m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, bool X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    s.next ();
+    x.*M = true;
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+
+// help_options
+//
+
+help_options::
+help_options ()
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+}
+
+help_options::
+help_options (int& argc,
+              char** argv,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (argc, argv, erase);
+  _parse (s, opt, arg);
+}
+
+help_options::
+help_options (int start,
+              int& argc,
+              char** argv,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (start, argc, argv, erase);
+  _parse (s, opt, arg);
+}
+
+help_options::
+help_options (int& argc,
+              char** argv,
+              int& end,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (argc, argv, erase);
+  _parse (s, opt, arg);
+  end = s.end ();
+}
+
+help_options::
+help_options (int start,
+              int& argc,
+              char** argv,
+              int& end,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (start, argc, argv, erase);
+  _parse (s, opt, arg);
+  end = s.end ();
+}
+
+help_options::
+help_options (::cli::scanner& s,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: build2_metadata_ (),
+  build2_metadata_specified_ (false),
+  help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  _parse (s, opt, arg);
+}
+
+::cli::usage_para help_options::
+print_usage (::std::wostream& os, ::cli::usage_para p)
+{
+  CLI_POTENTIALLY_UNUSED (os);
+
+  return p;
+}
+
+typedef
+std::map<std::string, void (*) (help_options&, ::cli::scanner&)>
+_cli_help_options_map;
+
+static _cli_help_options_map _cli_help_options_map_;
+
+struct _cli_help_options_map_init
+{
+  _cli_help_options_map_init ()
+  {
+    _cli_help_options_map_["--build2-metadata"] =
+    &::cli::thunk< help_options, std::uint64_t, &help_options::build2_metadata_,
+      &help_options::build2_metadata_specified_ >;
+    _cli_help_options_map_["--help"] =
+    &::cli::thunk< help_options, &help_options::help_ >;
+    _cli_help_options_map_["--version"] =
+    &::cli::thunk< help_options, &help_options::version_ >;
+    _cli_help_options_map_["--proprietary-license"] =
+    &::cli::thunk< help_options, &help_options::proprietary_license_ >;
+  }
+};
+
+static _cli_help_options_map_init _cli_help_options_map_init_;
+
+bool help_options::
+_parse (const char* o, ::cli::scanner& s)
+{
+  _cli_help_options_map::const_iterator i (_cli_help_options_map_.find (o));
+
+  if (i != _cli_help_options_map_.end ())
+  {
+    (*(i->second)) (*this, s);
+    return true;
+  }
+
+  return false;
+}
+
+bool help_options::
+_parse (::cli::scanner& s,
+        ::cli::unknown_mode opt_mode,
+        ::cli::unknown_mode arg_mode)
+{
+  // Can't skip combined flags (--no-combined-flags).
+  //
+  assert (opt_mode != ::cli::unknown_mode::skip);
+
+  bool r = false;
+  bool opt = true;
+
+  while (s.more ())
+  {
+    const char* o = s.peek ();
+
+    if (std::strcmp (o, "--") == 0)
+    {
+      opt = false;
+      s.skip ();
+      r = true;
+      continue;
+    }
+
+    if (opt)
+    {
+      if (_parse (o, s))
+      {
+        r = true;
+        continue;
+      }
+
+      if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+      {
+        // Handle combined option values.
+        //
+        std::string co;
+        if (const char* v = std::strchr (o, '='))
+        {
+          co.assign (o, 0, v - o);
+          ++v;
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (co.c_str ()),
+            const_cast<char*> (v)
+          };
+
+          ::cli::argv_scanner ns (0, ac, av);
+
+          if (_parse (co.c_str (), ns))
+          {
+            // Parsed the option but not its value?
+            //
+            if (ns.end () != 2)
+              throw ::cli::invalid_value (co, v);
+
+            s.next ();
+            r = true;
+            continue;
+          }
+          else
+          {
+            // Set the unknown option and fall through.
+            //
+            o = co.c_str ();
+          }
+        }
+
+        // Handle combined flags.
+        //
+        char cf[3];
+        {
+          const char* p = o + 1;
+          for (; *p != '\0'; ++p)
+          {
+            if (!((*p >= 'a' && *p <= 'z') ||
+                  (*p >= 'A' && *p <= 'Z') ||
+                  (*p >= '0' && *p <= '9')))
+              break;
+          }
+
+          if (*p == '\0')
+          {
+            for (p = o + 1; *p != '\0'; ++p)
+            {
+              std::strcpy (cf, "-");
+              cf[1] = *p;
+              cf[2] = '\0';
+
+              int ac (1);
+              char* av[] =
+              {
+                cf
+              };
+
+              ::cli::argv_scanner ns (0, ac, av);
+
+              if (!_parse (cf, ns))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              // All handled.
+              //
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = cf;
+            }
+          }
+        }
+
+        switch (opt_mode)
+        {
+          case ::cli::unknown_mode::skip:
+          {
+            s.skip ();
+            r = true;
+            continue;
+          }
+          case ::cli::unknown_mode::stop:
+          {
+            break;
+          }
+          case ::cli::unknown_mode::fail:
+          {
+            throw ::cli::unknown_option (o);
+          }
+        }
+
+        break;
+      }
+    }
+
+    switch (arg_mode)
+    {
+      case ::cli::unknown_mode::skip:
+      {
+        s.skip ();
+        r = true;
+        continue;
+      }
+      case ::cli::unknown_mode::stop:
+      {
+        break;
+      }
+      case ::cli::unknown_mode::fail:
+      {
+        throw ::cli::unknown_argument (o);
+      }
+    }
+
+    break;
+  }
+
+  return r;
+}
+
+// options
+//
+
+options::
+options ()
+: disable_warning_ (),
+  disable_warning_specified_ (false),
+  options_file_ (),
+  options_file_specified_ (false),
+  show_sloc_ (),
+  sloc_limit_ (),
+  sloc_limit_specified_ (false),
+  proprietary_license_ (),
+  custom_literals_ (),
+  custom_literals_specified_ (false),
+  preserve_anonymous_ (),
+  show_anonymous_ (),
+  anonymous_regex_ (),
+  anonymous_regex_specified_ (false),
+  anonymous_regex_trace_ (),
+  morph_anonymous_ (),
+  location_map_ (),
+  location_map_specified_ (false),
+  location_regex_ (),
+  location_regex_specified_ (false),
+  location_regex_trace_ (),
+  file_per_type_ (),
+  type_file_regex_ (),
+  type_file_regex_specified_ (false),
+  type_file_regex_trace_ (),
+  schema_file_regex_ (),
+  schema_file_regex_specified_ (false),
+  schema_file_regex_trace_ (),
+  fat_type_file_ (),
+  file_list_ (),
+  file_list_specified_ (false),
+  file_list_only_ (),
+  file_list_prologue_ (),
+  file_list_prologue_specified_ (false),
+  file_list_epilogue_ (),
+  file_list_epilogue_specified_ (false),
+  file_list_delim_ ("\n"),
+  file_list_delim_specified_ (false),
+  disable_multi_import_ (),
+  disable_full_check_ ()
+{
+}
+
+::cli::usage_para options::
+print_usage (::std::wostream& os, ::cli::usage_para p)
+{
+  CLI_POTENTIALLY_UNUSED (os);
+
+  if (p == ::cli::usage_para::text)
+    os << ::std::endl;
+
+  os << "--disable-warning <warn>     Disable printing warning with id <warn>." << ::std::endl;
+
+  os << "--options-file <file>        Read additional options from <file>." << ::std::endl;
+
+  os << "--show-sloc                  Show the number of generated physical source lines" << ::std::endl
+     << "                             of code (SLOC)." << ::std::endl;
+
+  os << "--sloc-limit <num>           Check that the number of generated physical source" << ::std::endl
+     << "                             lines of code (SLOC) does not exceed <num>." << ::std::endl;
+
+  os << "--proprietary-license        Indicate that the generated code is licensed under" << ::std::endl
+     << "                             a proprietary license instead of the GPL." << ::std::endl;
+
+  os << "--custom-literals <file>     Load custom XML string to C++ literal mappings" << ::std::endl
+     << "                             from <file>." << ::std::endl;
+
+  os << "--preserve-anonymous         Preserve anonymous types." << ::std::endl;
+
+  os << "--show-anonymous             Show elements and attributes that are of anonymous" << ::std::endl
+     << "                             types." << ::std::endl;
+
+  os << "--anonymous-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to derive names for anonymous types from the" << ::std::endl
+     << "                             enclosing attributes/elements." << ::std::endl;
+
+  os << "--anonymous-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the --anonymous-regex option." << ::std::endl;
+
+  os << "--location-map <ol>=<nl>     Map the original schema location <ol> that is" << ::std::endl
+     << "                             specified in the XML Schema include or import" << ::std::endl
+     << "                             elements to new schema location <nl>." << ::std::endl;
+
+  os << "--location-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to map schema locations that are specified in" << ::std::endl
+     << "                             the XML Schema include or import elements." << ::std::endl;
+
+  os << "--location-regex-trace       Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the --location-regex option." << ::std::endl;
+
+  os << "--file-per-type              Generate a separate set of C++ files for each type" << ::std::endl
+     << "                             defined in XML Schema." << ::std::endl;
+
+  os << "--type-file-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to translate type names to file names when" << ::std::endl
+     << "                             the --file-per-type option is specified." << ::std::endl;
+
+  os << "--type-file-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the --type-file-regex option." << ::std::endl;
+
+  os << "--schema-file-regex <regex>  Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to translate schema file names when the" << ::std::endl
+     << "                             --file-per-type option is specified." << ::std::endl;
+
+  os << "--schema-file-regex-trace    Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the --schema-file-regex option." << ::std::endl;
+
+  os << "--fat-type-file              Generate code corresponding to global elements" << ::std::endl
+     << "                             into type files instead of schema files when the" << ::std::endl
+     << "                             --type-file-regex option is specified." << ::std::endl;
+
+  os << "--file-list <file>           Write a list of generated C++ files to <file> or" << ::std::endl
+     << "                             to stdout if <file> is -." << ::std::endl;
+
+  os << "--file-list-only             Only write the list of C++ files that would be" << ::std::endl
+     << "                             generated without actually generating them." << ::std::endl;
+
+  os << "--file-list-prologue <text>  Insert <text> at the beginning of the file list." << ::std::endl;
+
+  os << "--file-list-epilogue <text>  Insert <text> at the end of the file list." << ::std::endl;
+
+  os << "--file-list-delim <text>     Delimit file names written to the file list with" << ::std::endl
+     << "                             <text> instead of new lines." << ::std::endl;
+
+  p = ::cli::usage_para::option;
+
+  return p;
+}
+
+typedef
+std::map<std::string, void (*) (options&, ::cli::scanner&)>
+_cli_options_map;
+
+static _cli_options_map _cli_options_map_;
+
+struct _cli_options_map_init
+{
+  _cli_options_map_init ()
+  {
+    _cli_options_map_["--disable-warning"] =
+    &::cli::thunk< options, NarrowStrings, &options::disable_warning_,
+      &options::disable_warning_specified_ >;
+    _cli_options_map_["--options-file"] =
+    &::cli::thunk< options, std::string, &options::options_file_,
+      &options::options_file_specified_ >;
+    _cli_options_map_["--show-sloc"] =
+    &::cli::thunk< options, &options::show_sloc_ >;
+    _cli_options_map_["--sloc-limit"] =
+    &::cli::thunk< options, std::size_t, &options::sloc_limit_,
+      &options::sloc_limit_specified_ >;
+    _cli_options_map_["--proprietary-license"] =
+    &::cli::thunk< options, &options::proprietary_license_ >;
+    _cli_options_map_["--custom-literals"] =
+    &::cli::thunk< options, NarrowString, &options::custom_literals_,
+      &options::custom_literals_specified_ >;
+    _cli_options_map_["--preserve-anonymous"] =
+    &::cli::thunk< options, &options::preserve_anonymous_ >;
+    _cli_options_map_["--show-anonymous"] =
+    &::cli::thunk< options, &options::show_anonymous_ >;
+    _cli_options_map_["--anonymous-regex"] =
+    &::cli::thunk< options, NarrowStrings, &options::anonymous_regex_,
+      &options::anonymous_regex_specified_ >;
+    _cli_options_map_["--anonymous-regex-trace"] =
+    &::cli::thunk< options, &options::anonymous_regex_trace_ >;
+    _cli_options_map_["--morph-anonymous"] =
+    &::cli::thunk< options, &options::morph_anonymous_ >;
+    _cli_options_map_["--location-map"] =
+    &::cli::thunk< options, NarrowStrings, &options::location_map_,
+      &options::location_map_specified_ >;
+    _cli_options_map_["--location-regex"] =
+    &::cli::thunk< options, NarrowStrings, &options::location_regex_,
+      &options::location_regex_specified_ >;
+    _cli_options_map_["--location-regex-trace"] =
+    &::cli::thunk< options, &options::location_regex_trace_ >;
+    _cli_options_map_["--file-per-type"] =
+    &::cli::thunk< options, &options::file_per_type_ >;
+    _cli_options_map_["--type-file-regex"] =
+    &::cli::thunk< options, NarrowStrings, &options::type_file_regex_,
+      &options::type_file_regex_specified_ >;
+    _cli_options_map_["--type-file-regex-trace"] =
+    &::cli::thunk< options, &options::type_file_regex_trace_ >;
+    _cli_options_map_["--schema-file-regex"] =
+    &::cli::thunk< options, NarrowStrings, &options::schema_file_regex_,
+      &options::schema_file_regex_specified_ >;
+    _cli_options_map_["--schema-file-regex-trace"] =
+    &::cli::thunk< options, &options::schema_file_regex_trace_ >;
+    _cli_options_map_["--fat-type-file"] =
+    &::cli::thunk< options, &options::fat_type_file_ >;
+    _cli_options_map_["--file-list"] =
+    &::cli::thunk< options, NarrowString, &options::file_list_,
+      &options::file_list_specified_ >;
+    _cli_options_map_["--file-list-only"] =
+    &::cli::thunk< options, &options::file_list_only_ >;
+    _cli_options_map_["--file-list-prologue"] =
+    &::cli::thunk< options, NarrowString, &options::file_list_prologue_,
+      &options::file_list_prologue_specified_ >;
+    _cli_options_map_["--file-list-epilogue"] =
+    &::cli::thunk< options, NarrowString, &options::file_list_epilogue_,
+      &options::file_list_epilogue_specified_ >;
+    _cli_options_map_["--file-list-delim"] =
+    &::cli::thunk< options, NarrowString, &options::file_list_delim_,
+      &options::file_list_delim_specified_ >;
+    _cli_options_map_["--disable-multi-import"] =
+    &::cli::thunk< options, &options::disable_multi_import_ >;
+    _cli_options_map_["--disable-full-check"] =
+    &::cli::thunk< options, &options::disable_full_check_ >;
+  }
+};
+
+static _cli_options_map_init _cli_options_map_init_;
+
+bool options::
+_parse (const char* o, ::cli::scanner& s)
+{
+  _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+  if (i != _cli_options_map_.end ())
+  {
+    (*(i->second)) (*this, s);
+    return true;
+  }
+
+  return false;
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/pregenerated/xsd/options.hxx b/xsd/pregenerated/xsd/options.hxx
new file mode 100644
index 0000000..0f4383c
--- /dev/null
+++ b/xsd/pregenerated/xsd/options.hxx
@@ -0,0 +1,702 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef XSD_OPTIONS_HXX
+#define XSD_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <list>
+#include <deque>
+#include <iosfwd>
+#include <string>
+#include <cstddef>
+#include <exception>
+
+#ifndef CLI_POTENTIALLY_UNUSED
+#  if defined(_MSC_VER) || defined(__xlC__)
+#    define CLI_POTENTIALLY_UNUSED(x) (void*)&x
+#  else
+#    define CLI_POTENTIALLY_UNUSED(x) (void)x
+#  endif
+#endif
+
+namespace cli
+{
+  class usage_para
+  {
+    public:
+    enum value
+    {
+      none,
+      text,
+      option
+    };
+
+    usage_para (value);
+
+    operator value () const 
+    {
+      return v_;
+    }
+
+    private:
+    value v_;
+  };
+
+  class unknown_mode
+  {
+    public:
+    enum value
+    {
+      skip,
+      stop,
+      fail
+    };
+
+    unknown_mode (value);
+
+    operator value () const 
+    {
+      return v_;
+    }
+
+    private:
+    value v_;
+  };
+
+  // Exceptions.
+  //
+
+  class exception: public std::exception
+  {
+    public:
+    virtual void
+    print (::std::wostream&) const = 0;
+  };
+
+  ::std::wostream&
+  operator<< (::std::wostream&, const exception&);
+
+  class unknown_option: public exception
+  {
+    public:
+    virtual
+    ~unknown_option () noexcept;
+
+    unknown_option (const std::string& option);
+
+    const std::string&
+    option () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string option_;
+  };
+
+  class unknown_argument: public exception
+  {
+    public:
+    virtual
+    ~unknown_argument () noexcept;
+
+    unknown_argument (const std::string& argument);
+
+    const std::string&
+    argument () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string argument_;
+  };
+
+  class missing_value: public exception
+  {
+    public:
+    virtual
+    ~missing_value () noexcept;
+
+    missing_value (const std::string& option);
+
+    const std::string&
+    option () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string option_;
+  };
+
+  class invalid_value: public exception
+  {
+    public:
+    virtual
+    ~invalid_value () noexcept;
+
+    invalid_value (const std::string& option,
+                   const std::string& value,
+                   const std::string& message = std::string ());
+
+    const std::string&
+    option () const;
+
+    const std::string&
+    value () const;
+
+    const std::string&
+    message () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string option_;
+    std::string value_;
+    std::string message_;
+  };
+
+  class eos_reached: public exception
+  {
+    public:
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+  };
+
+  class file_io_failure: public exception
+  {
+    public:
+    virtual
+    ~file_io_failure () noexcept;
+
+    file_io_failure (const std::string& file);
+
+    const std::string&
+    file () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string file_;
+  };
+
+  class unmatched_quote: public exception
+  {
+    public:
+    virtual
+    ~unmatched_quote () noexcept;
+
+    unmatched_quote (const std::string& argument);
+
+    const std::string&
+    argument () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const noexcept;
+
+    private:
+    std::string argument_;
+  };
+
+  // Command line argument scanner interface.
+  //
+  // The values returned by next() are guaranteed to be valid
+  // for the two previous arguments up until a call to a third
+  // peek() or next().
+  //
+  // The position() function returns a monotonically-increasing
+  // number which, if stored, can later be used to determine the
+  // relative position of the argument returned by the following
+  // call to next(). Note that if multiple scanners are used to
+  // extract arguments from multiple sources, then the end
+  // position of the previous scanner should be used as the
+  // start position of the next.
+  //
+  class scanner
+  {
+    public:
+    virtual
+    ~scanner ();
+
+    virtual bool
+    more () = 0;
+
+    virtual const char*
+    peek () = 0;
+
+    virtual const char*
+    next () = 0;
+
+    virtual void
+    skip () = 0;
+
+    virtual std::size_t
+    position () = 0;
+  };
+
+  class argv_scanner: public scanner
+  {
+    public:
+    argv_scanner (int& argc,
+                  char** argv,
+                  bool erase = false,
+                  std::size_t start_position = 0);
+
+    argv_scanner (int start,
+                  int& argc,
+                  char** argv,
+                  bool erase = false,
+                  std::size_t start_position = 0);
+
+    int
+    end () const;
+
+    virtual bool
+    more ();
+
+    virtual const char*
+    peek ();
+
+    virtual const char*
+    next ();
+
+    virtual void
+    skip ();
+
+    virtual std::size_t
+    position ();
+
+    protected:
+    std::size_t start_position_;
+    int i_;
+    int& argc_;
+    char** argv_;
+    bool erase_;
+  };
+
+  class argv_file_scanner: public argv_scanner
+  {
+    public:
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase = false,
+                       std::size_t start_position = 0);
+
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase = false,
+                       std::size_t start_position = 0);
+
+    argv_file_scanner (const std::string& file,
+                       const std::string& option,
+                       std::size_t start_position = 0);
+
+    struct option_info
+    {
+      // If search_func is not NULL, it is called, with the arg
+      // value as the second argument, to locate the options file.
+      // If it returns an empty string, then the file is ignored.
+      //
+      const char* option;
+      std::string (*search_func) (const char*, void* arg);
+      void* arg;
+    };
+
+    argv_file_scanner (int& argc,
+                        char** argv,
+                        const option_info* options,
+                        std::size_t options_count,
+                        bool erase = false,
+                        std::size_t start_position = 0);
+
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase = false,
+                       std::size_t start_position = 0);
+
+    argv_file_scanner (const std::string& file,
+                       const option_info* options = 0,
+                       std::size_t options_count = 0,
+                       std::size_t start_position = 0);
+
+    virtual bool
+    more ();
+
+    virtual const char*
+    peek ();
+
+    virtual const char*
+    next ();
+
+    virtual void
+    skip ();
+
+    virtual std::size_t
+    position ();
+
+    // Return the file path if the peeked at argument came from a file and
+    // the empty string otherwise. The reference is guaranteed to be valid
+    // till the end of the scanner lifetime.
+    //
+    const std::string&
+    peek_file ();
+
+    // Return the 1-based line number if the peeked at argument came from
+    // a file and zero otherwise.
+    //
+    std::size_t
+    peek_line ();
+
+    private:
+    const option_info*
+    find (const char*) const;
+
+    void
+    load (const std::string& file);
+
+    typedef argv_scanner base;
+
+    const std::string option_;
+    option_info option_info_;
+    const option_info* options_;
+    std::size_t options_count_;
+
+    struct arg
+    {
+      std::string value;
+      const std::string* file;
+      std::size_t line;
+    };
+
+    std::deque<arg> args_;
+    std::list<std::string> files_;
+
+    // Circular buffer of two arguments.
+    //
+    std::string hold_[2];
+    std::size_t i_;
+
+    bool skip_;
+
+    static int zero_argc_;
+    static std::string empty_string_;
+  };
+
+  template <typename X>
+  struct parser;
+}
+
+#include <cstddef>
+
+#include <cstdint>
+
+#include <xsd/types.hxx>
+
+class help_options
+{
+  public:
+  help_options ();
+
+  help_options (int& argc,
+                char** argv,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int start,
+                int& argc,
+                char** argv,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int& argc,
+                char** argv,
+                int& end,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int start,
+                int& argc,
+                char** argv,
+                int& end,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (::cli::scanner&,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  // Option accessors.
+  //
+  const std::uint64_t&
+  build2_metadata () const;
+
+  bool
+  build2_metadata_specified () const;
+
+  const bool&
+  help () const;
+
+  const bool&
+  version () const;
+
+  const bool&
+  proprietary_license () const;
+
+  // Print usage information.
+  //
+  static ::cli::usage_para
+  print_usage (::std::wostream&,
+               ::cli::usage_para = ::cli::usage_para::none);
+
+  // Implementation details.
+  //
+  protected:
+  bool
+  _parse (const char*, ::cli::scanner&);
+
+  private:
+  bool
+  _parse (::cli::scanner&,
+          ::cli::unknown_mode option,
+          ::cli::unknown_mode argument);
+
+  public:
+  std::uint64_t build2_metadata_;
+  bool build2_metadata_specified_;
+  bool help_;
+  bool version_;
+  bool proprietary_license_;
+};
+
+class options
+{
+  public:
+  // Option accessors.
+  //
+  const NarrowStrings&
+  disable_warning () const;
+
+  bool
+  disable_warning_specified () const;
+
+  const std::string&
+  options_file () const;
+
+  bool
+  options_file_specified () const;
+
+  const bool&
+  show_sloc () const;
+
+  const std::size_t&
+  sloc_limit () const;
+
+  bool
+  sloc_limit_specified () const;
+
+  const bool&
+  proprietary_license () const;
+
+  const NarrowString&
+  custom_literals () const;
+
+  bool
+  custom_literals_specified () const;
+
+  const bool&
+  preserve_anonymous () const;
+
+  const bool&
+  show_anonymous () const;
+
+  const NarrowStrings&
+  anonymous_regex () const;
+
+  bool
+  anonymous_regex_specified () const;
+
+  const bool&
+  anonymous_regex_trace () const;
+
+  const bool&
+  morph_anonymous () const;
+
+  const NarrowStrings&
+  location_map () const;
+
+  bool
+  location_map_specified () const;
+
+  const NarrowStrings&
+  location_regex () const;
+
+  bool
+  location_regex_specified () const;
+
+  const bool&
+  location_regex_trace () const;
+
+  const bool&
+  file_per_type () const;
+
+  const NarrowStrings&
+  type_file_regex () const;
+
+  bool
+  type_file_regex_specified () const;
+
+  const bool&
+  type_file_regex_trace () const;
+
+  const NarrowStrings&
+  schema_file_regex () const;
+
+  bool
+  schema_file_regex_specified () const;
+
+  const bool&
+  schema_file_regex_trace () const;
+
+  const bool&
+  fat_type_file () const;
+
+  const NarrowString&
+  file_list () const;
+
+  bool
+  file_list_specified () const;
+
+  const bool&
+  file_list_only () const;
+
+  const NarrowString&
+  file_list_prologue () const;
+
+  bool
+  file_list_prologue_specified () const;
+
+  const NarrowString&
+  file_list_epilogue () const;
+
+  bool
+  file_list_epilogue_specified () const;
+
+  const NarrowString&
+  file_list_delim () const;
+
+  bool
+  file_list_delim_specified () const;
+
+  const bool&
+  disable_multi_import () const;
+
+  const bool&
+  disable_full_check () const;
+
+  // Print usage information.
+  //
+  static ::cli::usage_para
+  print_usage (::std::wostream&,
+               ::cli::usage_para = ::cli::usage_para::none);
+
+  // Implementation details.
+  //
+  protected:
+  options ();
+
+  bool
+  _parse (const char*, ::cli::scanner&);
+
+  public:
+  NarrowStrings disable_warning_;
+  bool disable_warning_specified_;
+  std::string options_file_;
+  bool options_file_specified_;
+  bool show_sloc_;
+  std::size_t sloc_limit_;
+  bool sloc_limit_specified_;
+  bool proprietary_license_;
+  NarrowString custom_literals_;
+  bool custom_literals_specified_;
+  bool preserve_anonymous_;
+  bool show_anonymous_;
+  NarrowStrings anonymous_regex_;
+  bool anonymous_regex_specified_;
+  bool anonymous_regex_trace_;
+  bool morph_anonymous_;
+  NarrowStrings location_map_;
+  bool location_map_specified_;
+  NarrowStrings location_regex_;
+  bool location_regex_specified_;
+  bool location_regex_trace_;
+  bool file_per_type_;
+  NarrowStrings type_file_regex_;
+  bool type_file_regex_specified_;
+  bool type_file_regex_trace_;
+  NarrowStrings schema_file_regex_;
+  bool schema_file_regex_specified_;
+  bool schema_file_regex_trace_;
+  bool fat_type_file_;
+  NarrowString file_list_;
+  bool file_list_specified_;
+  bool file_list_only_;
+  NarrowString file_list_prologue_;
+  bool file_list_prologue_specified_;
+  NarrowString file_list_epilogue_;
+  bool file_list_epilogue_specified_;
+  NarrowString file_list_delim_;
+  bool file_list_delim_specified_;
+  bool disable_multi_import_;
+  bool disable_full_check_;
+};
+
+#include <xsd/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // XSD_OPTIONS_HXX
diff --git a/xsd/pregenerated/xsd/options.ixx b/xsd/pregenerated/xsd/options.ixx
new file mode 100644
index 0000000..d87e59c
--- /dev/null
+++ b/xsd/pregenerated/xsd/options.ixx
@@ -0,0 +1,555 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cassert>
+
+namespace cli
+{
+  // usage_para
+  //
+  inline usage_para::
+  usage_para (value v)
+  : v_ (v)
+  {
+  }
+
+  // unknown_mode
+  //
+  inline unknown_mode::
+  unknown_mode (value v)
+  : v_ (v)
+  {
+  }
+
+  // exception
+  //
+  inline ::std::wostream&
+  operator<< (::std::wostream& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+  // unknown_option
+  //
+  inline unknown_option::
+  unknown_option (const std::string& option)
+  : option_ (option)
+  {
+  }
+
+  inline const std::string& unknown_option::
+  option () const
+  {
+    return option_;
+  }
+
+  // unknown_argument
+  //
+  inline unknown_argument::
+  unknown_argument (const std::string& argument)
+  : argument_ (argument)
+  {
+  }
+
+  inline const std::string& unknown_argument::
+  argument () const
+  {
+    return argument_;
+  }
+
+  // missing_value
+  //
+  inline missing_value::
+  missing_value (const std::string& option)
+  : option_ (option)
+  {
+  }
+
+  inline const std::string& missing_value::
+  option () const
+  {
+    return option_;
+  }
+
+  // invalid_value
+  //
+  inline invalid_value::
+  invalid_value (const std::string& option,
+                 const std::string& value,
+                 const std::string& message)
+  : option_ (option),
+    value_ (value),
+    message_ (message)
+  {
+  }
+
+  inline const std::string& invalid_value::
+  option () const
+  {
+    return option_;
+  }
+
+  inline const std::string& invalid_value::
+  value () const
+  {
+    return value_;
+  }
+
+  inline const std::string& invalid_value::
+  message () const
+  {
+    return message_;
+  }
+
+  // file_io_failure
+  //
+  inline file_io_failure::
+  file_io_failure (const std::string& file)
+  : file_ (file)
+  {
+  }
+
+  inline const std::string& file_io_failure::
+  file () const
+  {
+    return file_;
+  }
+
+  // unmatched_quote
+  //
+  inline unmatched_quote::
+  unmatched_quote (const std::string& argument)
+  : argument_ (argument)
+  {
+  }
+
+  inline const std::string& unmatched_quote::
+  argument () const
+  {
+    return argument_;
+  }
+
+  // argv_scanner
+  //
+  inline argv_scanner::
+  argv_scanner (int& argc,
+                char** argv,
+                bool erase,
+                std::size_t sp)
+  : start_position_ (sp + 1),
+    i_ (1),
+    argc_ (argc),
+    argv_ (argv),
+    erase_ (erase)
+  {
+  }
+
+  inline argv_scanner::
+  argv_scanner (int start,
+                int& argc,
+                char** argv,
+                bool erase,
+                std::size_t sp)
+  : start_position_ (sp + static_cast<std::size_t> (start)),
+    i_ (start),
+    argc_ (argc),
+    argv_ (argv),
+    erase_ (erase)
+  {
+  }
+
+  inline int argv_scanner::
+  end () const
+  {
+    return i_;
+  }
+
+  // argv_file_scanner
+  //
+  inline argv_file_scanner::
+  argv_file_scanner (int& argc,
+                     char** argv,
+                     const std::string& option,
+                     bool erase,
+                     std::size_t sp)
+  : argv_scanner (argc, argv, erase, sp),
+    option_ (option),
+    options_ (&option_info_),
+    options_count_ (1),
+    i_ (1),
+    skip_ (false)
+  {
+    option_info_.option = option_.c_str ();
+    option_info_.search_func = 0;
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int start,
+                     int& argc,
+                     char** argv,
+                     const std::string& option,
+                     bool erase,
+                     std::size_t sp)
+  : argv_scanner (start, argc, argv, erase, sp),
+    option_ (option),
+    options_ (&option_info_),
+    options_count_ (1),
+    i_ (1),
+    skip_ (false)
+  {
+    option_info_.option = option_.c_str ();
+    option_info_.search_func = 0;
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (const std::string& file,
+                     const std::string& option,
+                     std::size_t sp)
+  : argv_scanner (0, zero_argc_, 0, sp),
+    option_ (option),
+    options_ (&option_info_),
+    options_count_ (1),
+    i_ (1),
+    skip_ (false)
+  {
+    option_info_.option = option_.c_str ();
+    option_info_.search_func = 0;
+
+    load (file);
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int& argc,
+                     char** argv,
+                     const option_info* options,
+                     std::size_t options_count,
+                     bool erase,
+                     std::size_t sp)
+  : argv_scanner (argc, argv, erase, sp),
+    options_ (options),
+    options_count_ (options_count),
+    i_ (1),
+    skip_ (false)
+  {
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int start,
+                     int& argc,
+                     char** argv,
+                     const option_info* options,
+                     std::size_t options_count,
+                     bool erase,
+                     std::size_t sp)
+  : argv_scanner (start, argc, argv, erase, sp),
+    options_ (options),
+    options_count_ (options_count),
+    i_ (1),
+    skip_ (false)
+  {
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (const std::string& file,
+                     const option_info* options,
+                     std::size_t options_count,
+                     std::size_t sp)
+  : argv_scanner (0, zero_argc_, 0, sp),
+    options_ (options),
+    options_count_ (options_count),
+    i_ (1),
+    skip_ (false)
+  {
+    load (file);
+  }
+}
+
+// help_options
+//
+
+inline const std::uint64_t& help_options::
+build2_metadata () const
+{
+  return this->build2_metadata_;
+}
+
+inline bool help_options::
+build2_metadata_specified () const
+{
+  return this->build2_metadata_specified_;
+}
+
+inline const bool& help_options::
+help () const
+{
+  return this->help_;
+}
+
+inline const bool& help_options::
+version () const
+{
+  return this->version_;
+}
+
+inline const bool& help_options::
+proprietary_license () const
+{
+  return this->proprietary_license_;
+}
+
+// options
+//
+
+inline const NarrowStrings& options::
+disable_warning () const
+{
+  return this->disable_warning_;
+}
+
+inline bool options::
+disable_warning_specified () const
+{
+  return this->disable_warning_specified_;
+}
+
+inline const std::string& options::
+options_file () const
+{
+  return this->options_file_;
+}
+
+inline bool options::
+options_file_specified () const
+{
+  return this->options_file_specified_;
+}
+
+inline const bool& options::
+show_sloc () const
+{
+  return this->show_sloc_;
+}
+
+inline const std::size_t& options::
+sloc_limit () const
+{
+  return this->sloc_limit_;
+}
+
+inline bool options::
+sloc_limit_specified () const
+{
+  return this->sloc_limit_specified_;
+}
+
+inline const bool& options::
+proprietary_license () const
+{
+  return this->proprietary_license_;
+}
+
+inline const NarrowString& options::
+custom_literals () const
+{
+  return this->custom_literals_;
+}
+
+inline bool options::
+custom_literals_specified () const
+{
+  return this->custom_literals_specified_;
+}
+
+inline const bool& options::
+preserve_anonymous () const
+{
+  return this->preserve_anonymous_;
+}
+
+inline const bool& options::
+show_anonymous () const
+{
+  return this->show_anonymous_;
+}
+
+inline const NarrowStrings& options::
+anonymous_regex () const
+{
+  return this->anonymous_regex_;
+}
+
+inline bool options::
+anonymous_regex_specified () const
+{
+  return this->anonymous_regex_specified_;
+}
+
+inline const bool& options::
+anonymous_regex_trace () const
+{
+  return this->anonymous_regex_trace_;
+}
+
+inline const bool& options::
+morph_anonymous () const
+{
+  return this->morph_anonymous_;
+}
+
+inline const NarrowStrings& options::
+location_map () const
+{
+  return this->location_map_;
+}
+
+inline bool options::
+location_map_specified () const
+{
+  return this->location_map_specified_;
+}
+
+inline const NarrowStrings& options::
+location_regex () const
+{
+  return this->location_regex_;
+}
+
+inline bool options::
+location_regex_specified () const
+{
+  return this->location_regex_specified_;
+}
+
+inline const bool& options::
+location_regex_trace () const
+{
+  return this->location_regex_trace_;
+}
+
+inline const bool& options::
+file_per_type () const
+{
+  return this->file_per_type_;
+}
+
+inline const NarrowStrings& options::
+type_file_regex () const
+{
+  return this->type_file_regex_;
+}
+
+inline bool options::
+type_file_regex_specified () const
+{
+  return this->type_file_regex_specified_;
+}
+
+inline const bool& options::
+type_file_regex_trace () const
+{
+  return this->type_file_regex_trace_;
+}
+
+inline const NarrowStrings& options::
+schema_file_regex () const
+{
+  return this->schema_file_regex_;
+}
+
+inline bool options::
+schema_file_regex_specified () const
+{
+  return this->schema_file_regex_specified_;
+}
+
+inline const bool& options::
+schema_file_regex_trace () const
+{
+  return this->schema_file_regex_trace_;
+}
+
+inline const bool& options::
+fat_type_file () const
+{
+  return this->fat_type_file_;
+}
+
+inline const NarrowString& options::
+file_list () const
+{
+  return this->file_list_;
+}
+
+inline bool options::
+file_list_specified () const
+{
+  return this->file_list_specified_;
+}
+
+inline const bool& options::
+file_list_only () const
+{
+  return this->file_list_only_;
+}
+
+inline const NarrowString& options::
+file_list_prologue () const
+{
+  return this->file_list_prologue_;
+}
+
+inline bool options::
+file_list_prologue_specified () const
+{
+  return this->file_list_prologue_specified_;
+}
+
+inline const NarrowString& options::
+file_list_epilogue () const
+{
+  return this->file_list_epilogue_;
+}
+
+inline bool options::
+file_list_epilogue_specified () const
+{
+  return this->file_list_epilogue_specified_;
+}
+
+inline const NarrowString& options::
+file_list_delim () const
+{
+  return this->file_list_delim_;
+}
+
+inline bool options::
+file_list_delim_specified () const
+{
+  return this->file_list_delim_specified_;
+}
+
+inline const bool& options::
+disable_multi_import () const
+{
+  return this->disable_multi_import_;
+}
+
+inline const bool& options::
+disable_full_check () const
+{
+  return this->disable_full_check_;
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/processing/cardinality/processor.cxx b/xsd/processing/cardinality/processor.cxx
new file mode 100644
index 0000000..c8c5dc5
--- /dev/null
+++ b/xsd/processing/cardinality/processor.cxx
@@ -0,0 +1,407 @@
+// file      : xsd/processing/cardinality/processor.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <map>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+#include <xsd/elements.hxx>
+
+#include <xsd/processing/cardinality/processor.hxx>
+
+using namespace std;
+
+namespace Processing
+{
+  namespace SemanticGraph = XSDFrontend::SemanticGraph;
+  namespace Traversal = XSDFrontend::Traversal;
+
+  namespace Cardinality
+  {
+    namespace
+    {
+      //
+      //
+      struct ElementInfo
+      {
+        ElementInfo ()
+            : min (0), max (0), e_ (0)
+        {
+        }
+
+        ElementInfo (SemanticGraph::Element& e)
+            : min (1), max (1), e_ (&e)
+        {
+        }
+
+        ElementInfo (SemanticGraph::Element& e, size_t min_, size_t max_)
+            : min (min_), max (max_), e_ (&e)
+        {
+        }
+
+        SemanticGraph::Element&
+        element ()
+        {
+          assert (e_ != 0);
+          return *e_;
+        }
+
+      public:
+        size_t min, max;
+
+      private:
+        SemanticGraph::Element* e_;
+      };
+
+      typedef map<String, ElementInfo> ElementInfoMap;
+
+      //
+      //
+      struct AnyInfo
+      {
+        AnyInfo ()
+            : min (0), max (0), a_ (0)
+        {
+        }
+
+        AnyInfo (SemanticGraph::Any& a)
+            : min (1), max (1), a_ (&a)
+        {
+        }
+
+        AnyInfo (SemanticGraph::Any& a, size_t min_, size_t max_)
+            : min (min_), max (max_), a_ (&a)
+        {
+        }
+
+        SemanticGraph::Any&
+        any ()
+        {
+          assert (a_ != 0);
+          return *a_;
+        }
+
+      public:
+        size_t min, max;
+
+      private:
+        SemanticGraph::Any* a_;
+      };
+
+      typedef map<String, AnyInfo> AnyInfoMap;
+
+      //
+      //
+      struct Particle: Traversal::All,
+                       Traversal::Choice,
+                       Traversal::Sequence,
+                       Traversal::Element,
+                       Traversal::Any
+      {
+        virtual void
+        traverse (SemanticGraph::All& a)
+        {
+          traverse_sequence (a);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Choice& c)
+        {
+          using SemanticGraph::Compositor;
+
+          // Go over all particles we contain and add them to the map.
+          //
+          for (Compositor::ContainsIterator ci (c.contains_begin ());
+               ci != c.contains_end (); ++ci)
+          {
+            Particle t;
+            t.dispatch (ci->particle ());
+
+            // Handle elements.
+            //
+            if (ci == c.contains_begin ())
+              el_map = t.el_map; // First arm.
+            else
+            {
+              // For elements that are in the map but not in this
+              // arm of choice, we need to set min to 0 while for
+              // those that are we need to choose minimum between
+              // the two for min and maximum for max.
+              //
+              for (ElementInfoMap::iterator i (el_map.begin ());
+                   i != el_map.end (); ++i)
+              {
+                String const& name (i->first);
+                ElementInfo& ei (i->second);
+
+                ElementInfoMap::iterator j (t.el_map.find (name));
+
+                if (j == t.el_map.end ())
+                  ei.min = 0;
+                else
+                {
+                  ei.min = j->second.min < ei.min ? j->second.min : ei.min;
+
+                  // Unbounded is encoded as 0.
+                  //
+                  if (j->second.max == 0 || ei.max == 0)
+                    ei.max = 0;
+                  else
+                    ei.max = j->second.max > ei.max ? j->second.max : ei.max;
+                }
+              }
+
+              // Now elements that are in this arm of choice but are
+              // not in the map, we need to add to the map and set their
+              // min to 0.
+              //
+              for (ElementInfoMap::iterator i (t.el_map.begin ());
+                   i != t.el_map.end (); ++i)
+              {
+                String const& name (i->first);
+                ElementInfo& ei (i->second);
+
+                ElementInfoMap::iterator j (el_map.find (name));
+
+                if (j == el_map.end ())
+                  el_map[name] = ElementInfo (ei.element (), 0, ei.max);
+              }
+            }
+
+            // Handle wildcards. Since each wildcard is treated as unique,
+            // we need to copy them from each arm of choice and set min to
+            // 0.
+            //
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
+                 i != t.any_map.end (); ++i)
+            {
+              String const& name (i->first);
+              AnyInfo& ai (i->second);
+
+              assert (any_map.find (name) == any_map.end ());
+
+              any_map[name] = AnyInfo (ai.any (), 0, ai.max);
+            }
+          }
+
+          // Choice's min and max.
+          //
+          size_t cmin (c.min ()), cmax (c.max ());
+
+          // Iterate over elements and wildcards in the maps and multiply
+          // their cardinality by cmin and cmax.
+          //
+          for (ElementInfoMap::iterator i (el_map.begin ());
+               i != el_map.end (); ++i)
+          {
+            i->second.min *= cmin;
+            i->second.max *= cmax;
+          }
+
+          for (AnyInfoMap::iterator i (any_map.begin ());
+               i != any_map.end (); ++i)
+          {
+            i->second.min *= cmin; // Not really necessary since min == 0.
+            i->second.max *= cmax;
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Sequence& s)
+        {
+          traverse_sequence (s);
+        }
+
+        void
+        traverse_sequence (SemanticGraph::Compositor& c)
+        {
+          using SemanticGraph::Compositor;
+
+          // Sequence's min and max.
+          //
+          size_t smin (c.min ()), smax (c.max ());
+
+          // Go over all particles we contain and add them to the map.
+          //
+          for (Compositor::ContainsIterator ci (c.contains_begin ());
+               ci != c.contains_end (); ++ci)
+          {
+            Particle t;
+            t.dispatch (ci->particle ());
+
+            // Handle elements.
+            //
+            for (ElementInfoMap::iterator i (t.el_map.begin ());
+                 i != t.el_map.end (); ++i)
+            {
+              String const& name (i->first);
+              ElementInfo& ei (i->second);
+              size_t min (ei.min * smin);
+              size_t max (ei.max * smax);
+              ElementInfoMap::iterator j (el_map.find (name));
+
+              if (j != el_map.end ())
+              {
+                // Add i's cardinality to j
+                //
+                j->second.min += min;
+                j->second.max = (j->second.max == 0 || max == 0) ?
+                  0 : (j->second.max + max);
+              }
+              else
+                el_map[name] = ElementInfo (ei.element (), min, max);
+            }
+
+            // Handle wildcards.
+            //
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
+                 i != t.any_map.end (); ++i)
+            {
+              String const& name (i->first);
+              AnyInfo& ai (i->second);
+              size_t min (ai.min * smin);
+              size_t max (ai.max * smax);
+
+              assert (any_map.find (name) == any_map.end ());
+
+              any_map[name] = AnyInfo (ai.any (), min, max);
+            }
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          SemanticGraph::ContainsParticle& cp (e.contained_particle ());
+
+          String name (e.qualified_p ()
+                       ? e.namespace_ ().name () + L" " + e.name ()
+                       : e.name ());
+
+          el_map[name] = ElementInfo (e, cp.min (), cp.max ());
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          SemanticGraph::ContainsParticle& cp (a.contained_particle ());
+
+          any_map[a.name ()] = AnyInfo (a, cp.min (), cp.max ());
+        }
+
+      public:
+        AnyInfoMap any_map;
+        ElementInfoMap el_map;
+      };
+
+
+      //
+      //
+      struct Complex: Traversal::Complex
+      {
+        virtual void
+        traverse (Type& c)
+        {
+          if (c.contains_compositor_p ())
+          {
+            Particle t;
+            t.dispatch (c.contains_compositor ().compositor ());
+
+            for (ElementInfoMap::iterator i (t.el_map.begin ());
+                 i != t.el_map.end (); ++i)
+            {
+              ElementInfo& ei (i->second);
+              SemanticGraph::Context& ctx (ei.element ().context ());
+
+              ctx.set ("min", ei.min);
+              ctx.set ("max", ei.max);
+            }
+
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
+                 i != t.any_map.end (); ++i)
+            {
+              AnyInfo& ai (i->second);
+              SemanticGraph::Context& ctx (ai.any ().context ());
+
+              ctx.set ("min", ai.min);
+              ctx.set ("max", ai.max);
+            }
+          }
+
+          // Traverse attributes and anonymous types (via elements).
+          //
+          Complex::names (c);
+        }
+      };
+
+
+      //
+      //
+      struct Attribute: Traversal::Attribute
+      {
+        virtual void
+        traverse (Type& a)
+        {
+          SemanticGraph::Context& ctx (a.context ());
+
+          ctx.set ("min", size_t (a.optional_p () ? 0 : 1));
+          ctx.set ("max", size_t (1));
+        }
+      };
+
+      // Go into implied/included/imported schemas while making sure
+      // we don't process the same stuff more than once.
+      //
+      struct Uses: Traversal::Uses
+      {
+        virtual void
+        traverse (Type& u)
+        {
+          SemanticGraph::Schema& s (u.schema ());
+
+          if (!s.context ().count ("processing-cardinality-seen"))
+          {
+            s.context ().set ("processing-cardinality-seen", true);
+            Traversal::Uses::traverse (u);
+          }
+        }
+      };
+    }
+
+    void Processor::
+    process (SemanticGraph::Schema& tu, SemanticGraph::Path const&)
+    {
+      Traversal::Schema schema;
+      Uses uses;
+
+      schema >> uses >> schema;
+
+      Traversal::Names schema_names;
+      Traversal::Namespace ns;
+      Traversal::Names ns_names;
+
+      schema >> schema_names >> ns >> ns_names;
+
+      Complex complex_type;
+      AnonymousBase anonymous (complex_type);
+
+      ns_names >> complex_type;
+      ns_names >> anonymous;
+
+      Attribute attribute;
+      Traversal::Names names;
+
+      complex_type >> names;
+
+      names >> attribute;
+      names >> anonymous;
+
+      // Some twisted schemas do recusive inclusions.
+      //
+      tu.context ().set ("processing-cardinality-seen", true);
+
+      schema.dispatch (tu);
+    }
+  }
+}
diff --git a/xsd/processing/cardinality/processor.hxx b/xsd/processing/cardinality/processor.hxx
new file mode 100644
index 0000000..93a85fb
--- /dev/null
+++ b/xsd/processing/cardinality/processor.hxx
@@ -0,0 +1,28 @@
+// file      : xsd/processing/cardinality/processor.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_PROCESSING_CARDINALITY_PROCESSOR_HXX
+#define XSD_PROCESSING_CARDINALITY_PROCESSOR_HXX
+
+#include <libxsd-frontend/semantic-graph/elements.hxx> // Path
+#include <libxsd-frontend/semantic-graph/schema.hxx>
+
+#include <xsd/types.hxx>
+
+namespace Processing
+{
+  namespace Cardinality
+  {
+    class Processor
+    {
+    public:
+      struct Failed {};
+
+      void
+      process (XSDFrontend::SemanticGraph::Schema&,
+               XSDFrontend::SemanticGraph::Path const& file);
+    };
+  }
+}
+
+#endif // XSD_PROCESSING_CARDINALITY_PROCESSOR_HXX
diff --git a/xsd/processing/inheritance/processor.cxx b/xsd/processing/inheritance/processor.cxx
new file mode 100644
index 0000000..6c0e40e
--- /dev/null
+++ b/xsd/processing/inheritance/processor.cxx
@@ -0,0 +1,492 @@
+// file      : xsd/processing/inheritance/processor.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <set>
+#include <iostream>
+
+#include <xsd/processing/inheritance/processor.hxx>
+
+#include <xsd/elements.hxx>
+
+#include <libxsd-frontend/semantic-graph.hxx>
+#include <libxsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace Processing
+{
+  namespace SemanticGraph = XSDFrontend::SemanticGraph;
+  namespace Traversal = XSDFrontend::Traversal;
+
+  namespace Inheritance
+  {
+    namespace
+    {
+      struct Dep
+      {
+        Dep (SemanticGraph::Type& t,
+             SemanticGraph::Member* m = 0,
+             String const& xpath = L"")
+            : type (t), member (m), member_xpath (xpath)
+        {
+        }
+
+        SemanticGraph::Type& type;
+        SemanticGraph::Member* member; // Member if type is anonymous.
+        String member_xpath;
+      };
+
+      inline bool
+      operator< (Dep const& a, Dep const& b)
+      {
+        return &a.type < &b.type;
+      }
+
+      typedef set<Dep> DepSet;
+      typedef set<SemanticGraph::Type*> TypeSet;
+
+      String
+      xpath (SemanticGraph::Nameable& n)
+      {
+        if (dynamic_cast<SemanticGraph::Namespace*> (&n) != 0)
+          return L"<namespace-level>"; // There is a bug if you see this.
+
+        if (n.named_p ())
+        {
+          SemanticGraph::Scope& scope (n.scope ());
+
+          if (dynamic_cast<SemanticGraph::Namespace*> (&scope) != 0)
+            return n.name ();
+
+          return xpath (scope) + L"/" + n.name ();
+        }
+        else
+        {
+          return L"(anonymous type for " +
+            n.context ().get<String> ("instance-name") + L")";
+        }
+      }
+
+
+      // Calculate the list of dependencies for this complex
+      // type.
+      //
+      struct ComplexType: Traversal::Complex,
+                          Traversal::Member
+      {
+        ComplexType (DepSet& dep_set)
+            : dep_set_ (dep_set), last_ (0)
+        {
+          *this >> names_ >> *this;
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          using SemanticGraph::Complex;
+
+          if (c.inherits_p ())
+            dep_set_.insert (Dep (c.inherits ().base (), last_, last_xpath_));
+
+          types_seen_.insert (&c);
+
+          // Go after anonymous types.
+          //
+          names (c);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          SemanticGraph::Type& t (m.type ());
+
+          if (!t.named_p () && types_seen_.find (&t) == types_seen_.end ())
+          {
+            SemanticGraph::Context& ctx (t.context ());
+
+            last_xpath_ = xpath (m);
+
+            String prev_xpath;
+
+            if (ctx.count ("instance-name"))
+              prev_xpath = ctx.get<String> ("instance-name");
+
+            ctx.set ("instance-name", last_xpath_);
+
+            last_ = &m;
+            dispatch (t);
+
+            if (prev_xpath)
+              ctx.set ("instance-name", prev_xpath);
+            else
+              ctx.remove ("instance-name");
+          }
+        }
+
+      private:
+        DepSet& dep_set_;
+        TypeSet types_seen_;
+
+        SemanticGraph::Member* last_;
+        String last_xpath_;
+
+        Traversal::Names names_;
+      };
+
+
+      //
+      //
+      template <typename N, typename A>
+      struct NodeArgs
+      {
+        NodeArgs (N& node, A arg)
+            : node_ (node), arg_ (arg)
+        {
+        }
+
+        operator N& () const
+        {
+          return node_;
+        }
+
+        template <typename E>
+        void
+        add_edge_left (E& e)
+        {
+          node_.add_edge_left (e, arg_);
+        }
+
+        template <typename E>
+        void
+        add_edge_right (E& e)
+        {
+          node_.add_edge_right (e, arg_);
+        }
+
+      private:
+        N& node_;
+        A arg_;
+      };
+
+
+      //
+      //
+      struct Global: Traversal::Type,
+                     Traversal::Complex,
+                     Traversal::Element
+      {
+        Global (SemanticGraph::Schema& root,
+                SemanticGraph::Schema& schema,
+                bool& failed)
+            : root_ (root), schema_ (schema), failed_ (failed)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Type& t)
+        {
+          if (t.named_p ())
+            types_seen_.insert (&t);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          check_dep (c, c);
+          types_seen_.insert (&c);
+        };
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          SemanticGraph::Type& t (e.type ());
+
+          if (!t.named_p ())
+          {
+            t.context ().set ("instance-name", xpath (e));
+            check_dep (e, t);
+            t.context ().remove ("instance-name");
+          }
+        };
+
+      private:
+        void
+        check_dep (SemanticGraph::Nameable& global,
+                   SemanticGraph::Type& type)
+        {
+          using SemanticGraph::Type;
+          using SemanticGraph::Scope;
+          using SemanticGraph::Names;
+          using SemanticGraph::Schema;
+
+          DepSet prereqs;
+
+          // Calculate our prerequisistes.
+          //
+          {
+            ComplexType complex (prereqs);
+            complex.dispatch (type);
+          }
+
+          for (DepSet::const_iterator i (prereqs.begin ());
+               i != prereqs.end (); ++i)
+          {
+            Dep const& dep (*i);
+            Type& t (dep.type);
+
+            // Ignore IDREF templates.
+            //
+            if (!t.named_p () &&
+                (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+                 t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+              continue;
+
+            // We won't be able to generate compilable code in case of a
+            // dependency on ourselves (e.g., a member element with
+            // anonymous type that inherits from us).
+            //
+            if (&t == &type)
+            {
+              assert (dep.member != 0);
+
+              SemanticGraph::Member& m (*dep.member);
+
+              wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                    << " error: nested anonymous type for '"
+                    << dep.member_xpath << "' cyclicly inherits from '"
+                    << t.name () << "'" << endl;
+
+              wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                    << " error: unable to generate valid code for such "
+                    << "cyclic inheritance" << endl;
+
+              wcerr << m.file () << ":" << m.line () << ":" << m.column ()
+                    << " info: '" << m.name () << "' element is declared here"
+                    << endl;
+
+              wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                    << ": info: consider explicitly naming this type "
+                    << "or remove the --preserve-anonymous option"
+                    << endl;
+
+              failed_ = true;
+              continue;
+            }
+
+            if (types_seen_.find (&t) == types_seen_.end ())
+            {
+              Scope& scope (t.scope ());
+              Schema& schema (dynamic_cast<Schema&> (scope.scope ()));
+
+              // Don't worry about types that are in included/imported
+              // schemas.
+              //
+              if (&schema != &schema_ && !sources_p (schema_, schema))
+                continue;
+
+              if (t.context ().count ("seen"))
+              {
+                wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                      << " error: nested anonymous type in '" << t.name ()
+                      << "' or '" << type.name () << "' inherits from one of "
+                      << "these types and makes them mutually dependant"
+                      << endl;
+
+                wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                      << " error: unable to generate valid code for such "
+                      << "cyclic dependency" << endl;
+
+                wcerr << type.file () << ":" << type.line () << ":"
+                      << type.column () << " info: '" << type.name ()
+                      << "' type is defined here"
+                      << endl;
+
+                wcerr << t.file () << ":" << t.line () << ":" << t.column ()
+                      << ": info: consider explicitly naming the anonymous "
+                      << "type or remove the --preserve-anonymous option"
+                      << endl;
+
+                failed_ = true;
+                continue;
+              }
+
+              //wcerr << "type '" << t.name () << "' needs to be moved " <<
+              //  "before " << (global.is_a<Type> () ? "type" : "element") <<
+              //  " '" << global.name () << "'" << endl;
+
+
+              // Delete current Names edge.
+              //
+              String name (t.name ());
+              {
+                Names& n (t.named ());
+                root_.delete_edge (scope, t, n);
+              }
+
+              // Insert a new Names edge before global.
+              //
+              {
+                // t.scope () and global.scope () can be different in
+                // case of the chameleon inclusion.
+                //
+                Scope& scope (global.scope ());
+
+                // Convert to the insert-after call.
+                //
+                Scope::NamesIterator i (scope.find (global.named ()));
+
+                if (i == scope.names_begin ())
+                  i = scope.names_end ();
+                else
+                  --i;
+
+                NodeArgs<Scope, Scope::NamesIterator> na (scope, i);
+                root_.new_edge<Names> (na, t, name);
+              }
+
+              // Recursively process the moved type.
+              //
+              global.context ().set ("seen", true);
+              dispatch (t);
+              global.context ().remove ("seen");
+            }
+          }
+        }
+
+      private:
+        // 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<Sources> ())
+            {
+              if (&i->schema () == &s || sources_p (i->schema (), s))
+                return true;
+            }
+          }
+
+          return false;
+        }
+
+      private:
+        SemanticGraph::Schema& root_;
+        SemanticGraph::Schema& schema_;
+        TypeSet types_seen_;
+        bool& failed_;
+      };
+
+
+      // 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:
+        set<SemanticGraph::Schema*> schemas_;
+      };
+
+      // Go into included/imported schemas while making sure we don't
+      // process the same stuff more than once.
+      //
+      struct Uses: Traversal::Includes, Traversal::Imports
+      {
+        Uses (SemanticGraph::Schema& root, bool& failed)
+            : root_ (root), failed_ (failed)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Includes& i)
+        {
+          traverse (i.schema ());
+        }
+
+        virtual void
+        traverse (SemanticGraph::Imports& i)
+        {
+          traverse (i.schema ());
+        }
+
+      private:
+        void
+        traverse (SemanticGraph::Schema& s)
+        {
+          if (!s.context ().count ("processing-inheritance-seen"))
+          {
+            Traversal::Schema schema;
+            Sources sources;
+
+            schema >> sources >> schema;
+            schema >> *this;
+
+            Traversal::Names schema_names;
+            Traversal::Namespace ns;
+            Traversal::Names ns_names;
+
+            schema >> schema_names >> ns >> ns_names;
+
+            Global global (root_, s, failed_);
+
+            ns_names >> global;
+
+            s.context ().set ("processing-inheritance-seen", true);
+            schema.dispatch (s);
+          }
+        }
+
+      private:
+        SemanticGraph::Schema& root_;
+        bool& failed_;
+      };
+    }
+
+    void Processor::
+    process (SemanticGraph::Schema& tu, SemanticGraph::Path const&)
+    {
+      bool failed (false);
+
+      // We need to process include/imported schemas since other
+      // parts of the process, for example, name processors can
+      // rely on the order of types in the schema.
+      //
+      Traversal::Schema schema;
+      Sources sources;
+      Uses uses (tu, failed);
+
+      schema >> sources >> schema;
+      schema >> uses;
+
+      Traversal::Names schema_names;
+      Traversal::Namespace ns;
+      Traversal::Names ns_names;
+
+      schema >> schema_names >> ns >> ns_names;
+
+      Global global (tu, tu, failed);
+
+      ns_names >> global;
+
+      // Some twisted schemas do recusive self-inclusion.
+      //
+      tu.context ().set ("processing-inheritance-seen", true);
+
+      schema.dispatch (tu);
+
+      if (failed)
+        throw Failed ();
+    }
+  }
+}
diff --git a/xsd/processing/inheritance/processor.hxx b/xsd/processing/inheritance/processor.hxx
new file mode 100644
index 0000000..2a70e02
--- /dev/null
+++ b/xsd/processing/inheritance/processor.hxx
@@ -0,0 +1,28 @@
+// file      : xsd/processing/inheritance/processor.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_PROCESSING_INHERITANCE_PROCESSOR_HXX
+#define XSD_PROCESSING_INHERITANCE_PROCESSOR_HXX
+
+#include <libxsd-frontend/semantic-graph/elements.hxx> // Path
+#include <libxsd-frontend/semantic-graph/schema.hxx>
+
+#include <xsd/types.hxx>
+
+namespace Processing
+{
+  namespace Inheritance
+  {
+    class Processor
+    {
+    public:
+      struct Failed {};
+
+      void
+      process (XSDFrontend::SemanticGraph::Schema&,
+               XSDFrontend::SemanticGraph::Path const& file);
+    };
+  }
+}
+
+#endif // XSD_PROCESSING_INHERITANCE_PROCESSOR_HXX
diff --git a/xsd/type-map/lexer.cxx b/xsd/type-map/lexer.cxx
new file mode 100644
index 0000000..ae318d1
--- /dev/null
+++ b/xsd/type-map/lexer.cxx
@@ -0,0 +1,131 @@
+// file      : xsd/type-map/lexer.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <iostream>
+
+#include <xsd/type-map/lexer.hxx>
+
+using std::wcerr;
+using std::endl;
+
+namespace TypeMap
+{
+  Lexer::Lexer (std::istream& is, String const& path)
+      : locale_ ("C"), is_ (is), path_ (path), line_ (1), comment_ (false)
+  {
+    is_.exceptions (std::ios_base::badbit);
+  }
+
+  Lexer::Token Lexer::
+  next ()
+  {
+    if (held_lexeme_)
+    {
+      Token t (Token::punct, held_lexeme_, line_);
+      held_lexeme_.clear ();
+      return t;
+    }
+
+    typedef std::char_traits<char> Traits;
+    typedef Traits::char_type CharType;
+    typedef Traits::int_type IntType;
+
+    IntType i;
+    CharType c ('\0');
+    NarrowString lexeme;
+
+    // Skip all whitespaces including comments.
+    //
+    while (!is_.eof ())
+    {
+      i = is_.get ();
+
+      if (i == Traits::eof ())
+        break;
+
+      c = Traits::to_char_type (i);
+
+      if (comment_)
+      {
+        if (c == '\n')
+          comment_ = false;
+      }
+      else
+      {
+        if (!(std::isspace (c, locale_) || c == '#'))
+          break;
+
+        if (c == '#')
+          comment_ = true;
+      }
+
+      if (c == '\n')
+        ++line_;
+    }
+
+    if (is_.eof ())
+      return Token (Token::eos, L"<end-of-stream>", line_);
+
+    bool quote (c == '"');
+
+    if (!quote)
+      lexeme += c;
+
+    if (c != ';' && c != '{' && c != '}')
+    {
+      // Accumulate non-whitespace character sequence.
+      //
+
+      while (!is_.eof ())
+      {
+        i = is_.get ();
+
+        if (i == Traits::eof ())
+          break;
+
+        c = Traits::to_char_type (i);
+
+        if (!quote && c == '#')
+        {
+          comment_ = true;
+          break;
+        }
+
+        if (std::isspace (c, locale_))
+        {
+          if (c == '\n')
+            ++line_;
+
+          if (!quote)
+            break;
+        }
+
+        if (!quote && (c == ';' || c == '{' || c == '}'))
+        {
+          held_lexeme_ += c;
+          break;
+        }
+
+        if (quote && c == '"')
+          break;
+
+        lexeme += c;
+      }
+
+      if (quote && c != '"')
+      {
+        wcerr << path_ << ":" << line_ << ": error: closing '\"' expected"
+              << endl;
+
+        throw Failed ();
+      }
+    }
+
+    if (!quote && (lexeme == ";" || lexeme == "{" || lexeme == "}"))
+    {
+      return Token (Token::punct, lexeme, line_);
+    }
+    else
+      return Token (Token::token, lexeme, line_);
+  }
+}
diff --git a/xsd/type-map/lexer.hxx b/xsd/type-map/lexer.hxx
new file mode 100644
index 0000000..a0e1e44
--- /dev/null
+++ b/xsd/type-map/lexer.hxx
@@ -0,0 +1,74 @@
+// file      : xsd/type-map/lexer.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_TYPE_MAP_LEXER_HXX
+#define XSD_TYPE_MAP_LEXER_HXX
+
+#include <locale>
+#include <iosfwd>
+
+#include <xsd/types.hxx>
+
+namespace TypeMap
+{
+  class Lexer
+  {
+  public:
+    class Token
+    {
+    public:
+      enum Type
+      {
+        token,
+        punct,
+        eos
+      };
+
+      Token (Type type, String const& lexeme, size_t line)
+          : type_ (type), lexeme_ (lexeme), line_ (line)
+      {
+      }
+
+      Type
+      type () const
+      {
+        return type_;
+      }
+
+      String const&
+      lexeme () const
+      {
+        return lexeme_;
+      }
+
+      size_t
+      line () const
+      {
+        return line_;
+      }
+
+    private:
+      Type type_;
+      String lexeme_;
+      size_t line_;
+    };
+
+    Lexer (std::istream&, String const& path);
+
+    struct Failed {};
+
+    Token
+    next ();
+
+  private:
+    std::locale locale_;
+    std::istream& is_;
+    String path_;
+    size_t line_;
+    String held_lexeme_;
+    bool comment_;
+  };
+
+}
+
+#endif // XSD_TYPE_MAP_LEXER_HXX
diff --git a/xsd/type-map/parser.cxx b/xsd/type-map/parser.cxx
new file mode 100644
index 0000000..f11fac3
--- /dev/null
+++ b/xsd/type-map/parser.cxx
@@ -0,0 +1,279 @@
+// file      : xsd/type-map/parser.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <iostream>
+
+#include <libcutl/re.hxx>
+
+#include <xsd/type-map/parser.hxx>
+
+using std::endl;
+
+namespace TypeMap
+{
+  typedef Lexer::Token Token;
+  typedef cutl::re::wformat Format;
+
+  Parser::Parser (Lexer& lex, String const& path)
+      : lex_ (lex), path_ (path), e (std::wcerr)
+  {
+  }
+
+  bool Parser::
+  parse (Namespaces& ns)
+  {
+    try
+    {
+      Namespace* global = 0;
+
+      for (Token t (lex_.next ()); t.type () != Token::eos; t = lex_.next ())
+      {
+        String l (t.lexeme ());
+
+        if (l == L"namespace")
+        {
+          global = 0;
+
+          if (!namespace_ (ns))
+            return false;
+        }
+        else if (l == L"include")
+        {
+          if (global == 0)
+          {
+            ns.push_back (Namespace (Pattern ()));
+            global = &(*ns.rbegin ());
+          }
+
+          if (!include (*global))
+            return false;
+        }
+        else if (l == L"type" || t.type () == Token::token)
+        {
+          // Type mapping can have 'type' specifier omitted.
+          //
+          if (l == L"type")
+            t = lex_.next ();
+
+          if (global == 0)
+          {
+            ns.push_back (Namespace (Pattern ()));
+            global = &(*ns.rbegin ());
+          }
+
+          if (!type (t, *global))
+            return false;
+        }
+        else
+        {
+          e << path_ << ":" << t.line () << ": unexpected '" << l << "'"
+            << endl;
+
+          return false;
+        }
+      }
+    }
+    catch (Lexer::Failed const&)
+    {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Parser::
+  namespace_ (Namespaces& ns)
+  {
+    // First get XML namespace.
+    //
+    Token t (lex_.next ());
+
+    Pattern xsd_name;
+
+    try
+    {
+      xsd_name = t.lexeme ();
+    }
+    catch (Format const& ex)
+    {
+      e << path_ << ":" << t.line () << ": invalid namespace pattern: "
+        << ex.description ().c_str () << endl;
+      return false;
+    }
+
+    if (t.type () != Token::token)
+    {
+      e << path_ << ":" << t.line () << ": expected XML namespace "
+        << "instead of '" << xsd_name << "'" << endl;
+      return false;
+    }
+
+
+    // See if we've got optional C++ mapping.
+    //
+    t = lex_.next ();
+
+    bool has_cxx_name (false);
+    String cxx_name;
+
+    if (t.type () != Token::token)
+    {
+      if (t.lexeme () != L"{")
+      {
+        e << path_ << ":" << t.line () << ": expected C++ namespace or '{' "
+          << "instead of '" << t.lexeme () << "'" << endl;
+        return false;
+      }
+    }
+    else
+    {
+      has_cxx_name = true;
+      cxx_name = t.lexeme ();
+    }
+
+    // Swallow '{' if needed.
+    //
+    if (has_cxx_name)
+    {
+      t = lex_.next ();
+
+      if (t.type () != Token::punct || t.lexeme () != L"{")
+      {
+        e << path_ << ":" << t.line () << ": expected '{' instead of '"
+          << t.lexeme () << "'" << endl;
+        return false;
+      }
+    }
+
+    Namespace n (xsd_name, has_cxx_name, cxx_name);
+
+    // Parse namespace body.
+    //
+    for (t = lex_.next ();; t = lex_.next ())
+    {
+      String l (t.lexeme ());
+
+      if (l == L"include")
+      {
+        if (!include (n))
+          return false;
+      }
+      else if (l == L"type" || t.type () == Token::token)
+      {
+        // Type mapping can have 'type' specifier omitted.
+        //
+        if (l == L"type")
+          t = lex_.next ();
+
+        if (!type (t, n))
+          return false;
+      }
+      else if (t.type () == Token::punct && l == L"}")
+      {
+        break;
+      }
+      else
+      {
+        e << path_ << ":" << t.line () << ": unexpected '" << l << "'"
+          << endl;
+        return false;
+      }
+    }
+
+    if (cxx_name || n.types_begin () != n.types_end () ||
+        n.includes_begin () != n.includes_end ())
+    {
+      ns.push_back (n);
+    }
+
+    return true;
+  }
+
+  bool Parser::
+  include (Namespace& n)
+  {
+    Token t (lex_.next ());
+
+    String path (t.lexeme ());
+
+    if (t.type () != Token::token)
+    {
+      e << path_ << ":" << t.line () << ": expected include path "
+        << "instead of '" << path << "'" << endl;
+      return false;
+    }
+
+    if (path && path[0] == L'<')
+      n.includes_push_back (path);
+    else
+      n.includes_push_back (L'"' + path + L'"');
+
+    t = lex_.next ();
+
+    if (t.type () != Token::punct || t.lexeme () != L";")
+    {
+      e << path_ << ":" << t.line () << ": expected ';' after '"
+        << path << "'" << endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Parser::
+  type (Token t, Namespace& n)
+  {
+    Pattern xsd_name;
+
+    try
+    {
+      xsd_name = t.lexeme ();
+    }
+    catch (Format const& ex)
+    {
+      e << path_ << ":" << t.line () << ": invalid namespace pattern: "
+        << ex.description ().c_str () << endl;
+      return false;
+    }
+
+    if (t.type () != Token::token)
+    {
+      e << path_ << ":" << t.line () << ": expected XML Schema type name "
+        << "instead of '" << xsd_name << "'" << endl;
+      return false;
+    }
+
+    t = lex_.next ();
+    String cxx_ret_name (t.lexeme ());
+
+    if (t.type () != Token::token)
+    {
+      e << path_ << ":" << t.line () << ": expected C++ type name "
+        << "instead of '" << cxx_ret_name << "'" << endl;
+      return false;
+    }
+
+    t = lex_.next ();
+
+    String cxx_arg_name;
+
+    // See if we've got optional argument type.
+    //
+    if (t.type () == Token::token)
+    {
+      cxx_arg_name = t.lexeme ();
+      t = lex_.next ();
+    }
+
+    if (t.type () != Token::punct || t.lexeme () != L";")
+    {
+      e << path_ << ":" << t.line () << ": expected ';' after '"
+        << cxx_arg_name << "'" << endl;
+      return false;
+    }
+
+    n.types_push_back (xsd_name, cxx_ret_name, cxx_arg_name);
+
+    return true;
+  }
+}
diff --git a/xsd/type-map/parser.hxx b/xsd/type-map/parser.hxx
new file mode 100644
index 0000000..ec9ea49
--- /dev/null
+++ b/xsd/type-map/parser.hxx
@@ -0,0 +1,41 @@
+// file      : xsd/type-map/parser.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_TYPE_MAP_PARSER_HXX
+#define XSD_TYPE_MAP_PARSER_HXX
+
+#include <xsd/types.hxx>
+
+#include <xsd/type-map/type-map.hxx>
+#include <xsd/type-map/lexer.hxx>
+
+namespace TypeMap
+{
+  class Parser
+  {
+  public:
+    Parser (Lexer&, String const& path);
+
+    // Merge parsed namespaces.
+    //
+    bool
+    parse (Namespaces&);
+
+  private:
+    bool
+    namespace_ (Namespaces&);
+
+    bool
+    include (Namespace&);
+
+    bool
+    type (Lexer::Token, Namespace&);
+
+  private:
+    Lexer& lex_;
+    String path_;
+    std::wostream& e;
+  };
+}
+
+#endif // XSD_TYPE_MAP_PARSER_HXX
diff --git a/xsd/type-map/type-map.hxx b/xsd/type-map/type-map.hxx
new file mode 100644
index 0000000..dd2ec2c
--- /dev/null
+++ b/xsd/type-map/type-map.hxx
@@ -0,0 +1,178 @@
+// file      : xsd/type-map/type-map.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_XSD_TYPE_MAP_TYPE_MAP_HXX
+#define XSD_XSD_TYPE_MAP_TYPE_MAP_HXX
+
+#include <vector>
+
+#include <libcutl/re.hxx>
+
+#include <xsd/types.hxx>
+
+namespace TypeMap
+{
+  typedef cutl::re::wregex Pattern;
+
+  class Type
+  {
+  public:
+    Type (String const& xsd_name,
+          String const& cxx_ret_name,
+          String const& cxx_arg_name)
+        : xsd_name_ (xsd_name),
+          cxx_ret_name_ (cxx_ret_name),
+          cxx_arg_name_ (cxx_arg_name)
+    {
+    }
+
+    Type (Pattern const& xsd_name,
+          String const& cxx_ret_name,
+          String const& cxx_arg_name)
+        : xsd_name_ (xsd_name),
+          cxx_ret_name_ (cxx_ret_name),
+          cxx_arg_name_ (cxx_arg_name)
+    {
+    }
+
+    Pattern const&
+    xsd_name () const
+    {
+      return xsd_name_;
+    }
+
+    String const&
+    cxx_ret_name () const
+    {
+      return cxx_ret_name_;
+    }
+
+    String const&
+    cxx_arg_name () const
+    {
+      return cxx_arg_name_;
+    }
+
+  private:
+    Pattern xsd_name_;
+    String cxx_ret_name_;
+    String cxx_arg_name_;
+  };
+
+  class Namespace
+  {
+  public:
+    Namespace (String const& xsd_name)
+        : xsd_name_ (xsd_name), has_cxx_name_ (false)
+    {
+    }
+
+    Namespace (Pattern const& xsd_name)
+        : xsd_name_ (xsd_name), has_cxx_name_ (false)
+    {
+    }
+
+    Namespace (Pattern const& xsd_name, String const& cxx_name)
+        : xsd_name_ (xsd_name), has_cxx_name_ (true), cxx_name_ (cxx_name)
+    {
+    }
+
+    Namespace (Pattern const& xsd_name,
+               bool has_cxx_name,
+               String const& cxx_name)
+        : xsd_name_ (xsd_name),
+          has_cxx_name_ (has_cxx_name),
+          cxx_name_ (cxx_name)
+    {
+    }
+
+    //
+    //
+    typedef std::vector<String> Includes;
+    typedef Includes::const_iterator IncludesIterator;
+
+    IncludesIterator
+    includes_begin () const
+    {
+      return includes_.begin ();
+    }
+
+    IncludesIterator
+    includes_end () const
+    {
+      return includes_.end ();
+    }
+
+    void
+    includes_push_back (String const& i)
+    {
+      includes_.push_back (i);
+    }
+
+    //
+    //
+    typedef std::vector<Type> Types;
+    typedef Types::const_iterator TypesIterator;
+
+    TypesIterator
+    types_begin () const
+    {
+      return types_.begin ();
+    }
+
+    TypesIterator
+    types_end () const
+    {
+      return types_.end ();
+    }
+
+    void
+    types_push_back (String const& xsd_type,
+                     String const& cxx_ret_type,
+                     String const& cxx_arg_type = L"")
+    {
+      types_.push_back (Type (xsd_type, cxx_ret_type, cxx_arg_type));
+    }
+
+    void
+    types_push_back (Pattern const& xsd_type,
+                     String const& cxx_ret_type,
+                     String const& cxx_arg_type = L"")
+    {
+      types_.push_back (Type (xsd_type, cxx_ret_type, cxx_arg_type));
+    }
+
+    //
+    //
+    Pattern const&
+    xsd_name () const
+    {
+      return xsd_name_;
+    }
+
+    //
+    //
+    bool
+    has_cxx_name () const
+    {
+      return has_cxx_name_;
+    }
+
+    String const&
+    cxx_name () const
+    {
+      return cxx_name_;
+    }
+
+  private:
+    Includes includes_;
+    Types types_;
+    Pattern xsd_name_;
+    bool has_cxx_name_;
+    String cxx_name_;
+  };
+
+  typedef std::vector<Namespace> Namespaces;
+}
+
+#endif // XSD_XSD_TYPE_MAP_TYPE_MAP_HXX
diff --git a/xsd/types.hxx b/xsd/types.hxx
new file mode 100644
index 0000000..b3306dd
--- /dev/null
+++ b/xsd/types.hxx
@@ -0,0 +1,19 @@
+// file      : xsd/types.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_TYPES_HXX
+#define XSD_TYPES_HXX
+
+#include <vector>
+#include <cstddef> // std::size_t
+
+#include <libxsd-frontend/types.hxx>
+
+using std::size_t;
+
+using XSDFrontend::String;
+using XSDFrontend::NarrowString;
+
+typedef std::vector<NarrowString> NarrowStrings;
+
+#endif // XSD_TYPES_HXX
diff --git a/xsd/version.hxx.in b/xsd/version.hxx.in
new file mode 100644
index 0000000..9bfd8a8
--- /dev/null
+++ b/xsd/version.hxx.in
@@ -0,0 +1,55 @@
+// file      : xsd/version.hxx.in
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_VERSION // Note: using the version macro itself.
+
+// The numeric version format is AAAAABBBBBCCCCCDDDE where:
+//
+// AAAAA - major version number
+// BBBBB - minor version number
+// CCCCC - bugfix version number
+// DDD   - alpha / beta (DDD + 500) version number
+// E     - final (0) / snapshot (1)
+//
+// When DDDE is not 0, 1 is subtracted from AAAAABBBBBCCCCC. For example:
+//
+// Version      AAAAABBBBBCCCCCDDDE
+//
+// 0.1.0        0000000001000000000
+// 0.1.2        0000000001000020000
+// 1.2.3        0000100002000030000
+// 2.2.0-a.1    0000200001999990010
+// 3.0.0-b.2    0000299999999995020
+// 2.2.0-a.1.z  0000200001999990011
+//
+#define XSD_VERSION       $xsd.version.project_number$ULL
+#define XSD_VERSION_STR   "$xsd.version.project$"
+#define XSD_VERSION_ID    "$xsd.version.project_id$"
+#define XSD_VERSION_FULL  "$xsd.version$"
+
+#define XSD_VERSION_MAJOR $xsd.version.major$
+#define XSD_VERSION_MINOR $xsd.version.minor$
+#define XSD_VERSION_PATCH $xsd.version.patch$
+
+#define XSD_PRE_RELEASE   $xsd.version.pre_release$
+
+#define XSD_SNAPSHOT      $xsd.version.snapshot_sn$ULL
+#define XSD_SNAPSHOT_ID   "$xsd.version.snapshot_id$"
+
+#include <xercesc/util/XercesVersion.hpp>
+
+// Check that we have a compatible Xerces version (3.0.0 or later).
+//
+#if _XERCES_VERSION < 30000
+#  error Xerces-C++ 2-series is not supported
+#endif
+
+#include <libcutl/version.hxx>
+
+$libcutl.check(LIBCUTL_VERSION, LIBCUTL_SNAPSHOT)$
+
+#include <libxsd-frontend/version.hxx>
+
+$libxsd_frontend.check(LIBXSD_FRONTEND_VERSION, LIBXSD_FRONTEND_SNAPSHOT)$
+
+#endif // XSD_VERSION
diff --git a/xsd/xsd.cxx b/xsd/xsd.cxx
new file mode 100644
index 0000000..d2b0faf
--- /dev/null
+++ b/xsd/xsd.cxx
@@ -0,0 +1,1157 @@
+// file      : xsd/xsd.cxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <map>
+#include <vector>
+#include <memory>  // std::unique_ptr
+#include <cstddef> // std::size_t
+#include <iostream>
+#include <fstream>
+
+#include <xercesc/util/PlatformUtils.hpp>
+
+#include <libcutl/re.hxx>
+
+#include <libxsd-frontend/parser.hxx>
+#include <libxsd-frontend/transformations/anonymous.hxx>
+#include <libxsd-frontend/transformations/enum-synthesis.hxx>
+#include <libxsd-frontend/transformations/restriction.hxx>
+#include <libxsd-frontend/transformations/schema-per-type.hxx>
+#include <libxsd-frontend/transformations/simplifier.hxx>
+
+#include <xsd/version.hxx>
+
+#include <xsd/cxx/tree/options.hxx>
+#include <xsd/cxx/parser/options.hxx>
+
+#include <xsd/cxx/tree/generator.hxx>
+#include <xsd/cxx/parser/generator.hxx>
+
+#include <xsd/processing/cardinality/processor.hxx>
+#include <xsd/processing/inheritance/processor.hxx>
+
+#include <xsd/xsd.hxx>
+#include <xsd/types.hxx>
+#include <xsd/options.hxx>
+
+namespace SemanticGraph = XSDFrontend::SemanticGraph;
+namespace Transformations = XSDFrontend::Transformations;
+
+using namespace std;
+
+//
+//
+struct LocationTranslator: XSDFrontend::LocationTranslator
+{
+  struct Failed {};
+
+  LocationTranslator (NarrowStrings const& map,
+                      NarrowStrings const& regex,
+                      bool trace);
+
+  virtual NarrowString
+  translate (NarrowString const&);
+
+private:
+  typedef map<NarrowString, NarrowString> Map;
+
+  typedef cutl::re::regexsub Regex;
+  typedef cutl::re::format RegexFormat;
+  typedef vector<Regex> RegexVector;
+
+  typedef map<NarrowString, NarrowString> Cache;
+
+  Map map_;
+  RegexVector regex_;
+  Cache cache_;
+  bool trace_;
+};
+
+//
+//
+struct AnonymousNameTranslator: Transformations::AnonymousNameTranslator
+{
+  struct Failed {};
+
+  AnonymousNameTranslator (NarrowStrings const& regex, bool trace);
+
+  virtual String
+  translate (String const& file,
+             String const& ns,
+             String const& name,
+             String const& xpath);
+
+private:
+  typedef cutl::re::wregexsub Regex;
+  typedef cutl::re::wformat RegexFormat;
+  typedef vector<Regex> RegexVector;
+
+  RegexVector regex_;
+  bool trace_;
+
+};
+
+//
+//
+struct SchemaPerTypeTranslator: Transformations::SchemaPerTypeTranslator
+{
+  struct Failed {};
+
+  SchemaPerTypeTranslator (NarrowStrings const& type_regex,
+                           bool type_trace,
+                           NarrowStrings const& schema_regex,
+                           bool schema_trace);
+
+  virtual String
+  translate_type (String const& ns, String const& name);
+
+  virtual NarrowString
+  translate_schema (NarrowString const& file);
+
+private:
+  typedef cutl::re::wregexsub TypeRegex;
+  typedef cutl::re::wformat TypeRegexFormat;
+  typedef vector<TypeRegex> TypeRegexVector;
+
+  TypeRegexVector type_regex_;
+  bool type_trace_;
+
+  typedef cutl::re::regexsub SchemaRegex;
+  typedef cutl::re::format SchemaRegexFormat;
+  typedef vector<SchemaRegex> SchemaRegexVector;
+
+  SchemaRegexVector schema_regex_;
+  bool schema_trace_;
+};
+
+//
+//
+struct XercesInitializer
+{
+  XercesInitializer ()
+  {
+    xercesc::XMLPlatformUtils::Initialize ();
+  }
+
+  ~XercesInitializer ()
+  {
+    xercesc::XMLPlatformUtils::Terminate ();
+  }
+};
+
+// Expand the \n escape sequence.
+//
+void
+expand_nl (NarrowString& s);
+
+int
+main (int argc, char* argv[])
+{
+  wostream& e (wcerr);
+
+  try
+  {
+    cli::argv_file_scanner args (argc, argv, "--options-file");
+    help_options help_ops (args, cli::unknown_mode::stop);
+
+    // Handle --build2-metadata (see also buildfile).
+    //
+    if (help_ops.build2_metadata_specified ())
+    {
+      wostream& o (wcout);
+
+      // Note that the export.metadata variable should be the first non-
+      // blank/comment line.
+      //
+      o << "# build2 buildfile xsd" << endl
+        << "export.metadata = 1 xsd" << endl
+        << "xsd.name = [string] xsd" << endl
+        << "xsd.version = [string] '" << XSD_VERSION_FULL << '\'' << endl
+        << "xsd.checksum = [string] '" << XSD_VERSION_FULL << '\'' << endl;
+
+      return 0;
+    }
+
+    NarrowString cmd;
+    if (args.more ())
+      cmd = args.next ();
+
+    if (help_ops.version () || cmd == "version")
+    {
+      wostream& o (wcout);
+
+      o << "CodeSynthesis XSD XML Schema to C++ compiler " <<
+        XSD_VERSION_STR << endl
+        << "Copyright (c) " << XSD_COPYRIGHT << "." << endl;
+
+      if (!help_ops.proprietary_license () && cmd == "version")
+      {
+        // Parse the options after the command to detect trailing
+        // --proprietary-license.
+        //
+        help_ops = help_options (args, cli::unknown_mode::stop);
+      }
+
+      if (help_ops.proprietary_license ())
+      {
+        o << "The compiler was invoked in the Proprietary License mode. You "
+          << "should have\nreceived a proprietary license from Code Synthesis "
+          << "that entitles you to\nuse it in this mode." << endl;
+      }
+      else
+      {
+        o << "This is free software; see the source for copying conditions. "
+          << "There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS "
+          << "FOR A PARTICULAR PURPOSE." << endl;
+      }
+
+      return 0;
+    }
+
+    if (help_ops.help () || cmd == "help")
+    {
+      wostream& o (wcout);
+
+      if (cmd == "help" && args.more ())
+      {
+        NarrowString arg (args.next ());
+
+        if (arg == "cxx-tree")
+        {
+          o << "Usage: " << argv[0] << " cxx-tree [options] file [file ...]"
+            << endl
+            << "Options:" << endl;
+
+          CXX::Tree::Generator::usage ();
+        }
+        else if (arg == "cxx-parser")
+        {
+          o << "Usage: " << argv[0] << " cxx-parser [options] file [file ...]"
+            << endl
+            << "Options:" << endl;
+
+          CXX::Parser::Generator::usage ();
+        }
+        else
+        {
+          o << "error: unknown command '" << arg.c_str () << "'" << endl
+            << "info: try '" << argv[0] << " help' for the list of commands"
+            << endl;
+
+          return 1;
+        }
+
+        // Add frontend options at the end.
+        //
+        options::print_usage (o);
+      }
+      else
+      {
+        o << "Usage: " << argv[0] << " <cmd> ..." << endl
+          << "Commands:" << endl;
+
+        o << "  help            Print usage information and exit. Use\n"
+          << "                  'help <cmd>' for command-specific options."
+          << endl;
+
+        o << "  version         Print version and exit."
+          << endl;
+
+        o << "  cxx-tree        Generate the C++/Tree mapping."
+          << endl;
+
+        o << "  cxx-parser      Generate the C++/Parser mapping."
+          << endl;
+      }
+
+      return 0;
+    }
+
+    if (cmd.empty ())
+    {
+      e << "error: no command specified" << endl
+        << "info: try '" << argv[0] << " help' for usage information" << endl;
+
+      return 1;
+    }
+
+    if (cmd != "cxx-tree" && cmd != "cxx-parser")
+    {
+      e << "error: unknown command '" << cmd.c_str () << "'" << endl
+        << "info: try '" << argv[0] << " help' for the list of commands"
+        << endl;
+
+      return 1;
+    }
+
+    // We need to parse command line options before we can get to
+    // the arguments.
+    //
+    unique_ptr<CXX::Tree::options> tree_ops (
+      cmd == "cxx-tree" ? new CXX::Tree::options (args) : 0);
+
+    unique_ptr<CXX::Parser::options> parser_ops (
+      cmd == "cxx-parser" ? new CXX::Parser::options (args) : 0);
+
+    CXX::options& common_ops (
+      cmd == "cxx-tree"
+      ? static_cast<CXX::options&> (*tree_ops)
+      : static_cast<CXX::options&> (*parser_ops));
+
+    // Validate options.
+    //
+    if (common_ops.file_list_only () && !common_ops.file_list_specified ())
+    {
+      e << "error: --file-list-only specified without --file-list" << endl;
+      return 1;
+    }
+
+    // Disabled warnings.
+    //
+    WarningSet disabled_w;
+    {
+      NarrowStrings const& w (common_ops.disable_warning ());
+
+      for (NarrowStrings::const_iterator i (w.begin ()); i != w.end (); ++i)
+        disabled_w.insert (*i);
+    }
+
+    bool disabled_w_all (disabled_w.find ("all") != disabled_w.end ());
+
+    if (common_ops.morph_anonymous () &&
+        !disabled_w_all &&
+        disabled_w.find ("D001") == disabled_w.end ())
+    {
+      e << "warning D001: the --morph-anonymous option is on by default and "
+        << "no longer required"
+        << endl;
+    }
+
+    // Collect all the files to compile in a vector.
+    //
+    NarrowStrings files;
+
+    while (args.more ())
+      files.push_back (args.next ());
+
+    if (files.empty ())
+    {
+      e << "error: no input file specified" << endl;
+      return 1;
+    }
+
+    bool fpt (common_ops.file_per_type ());
+
+    if (cmd == "cxx-tree" || cmd == "cxx-parser")
+    {
+      bool gen (common_ops.generate_xml_schema ());
+      bool use (common_ops.extern_xml_schema ());
+
+      // Things get complicated when we are compiling several schemas at
+      // once (non-file-per-type mode) and use the --generate-xml-schema/
+      // --extern-xml-schema options. The only way we can figure out which
+      // file corresponds to XML Schema is if the --extern-xml-schema option
+      // is also present. So we are going to require it for this case,
+      // especially since it generally makes sense.
+      //
+      if (!fpt)
+      {
+        if (files.size () > 1 && gen && !use)
+        {
+          e << "error: --extern-xml-schema is required when compiling more "
+            << "than one schema and --generate-xml-schema is specified"
+            << endl;
+
+          return 1;
+        }
+
+        if (files.size () == 1 && gen && use)
+        {
+          e << "error: --generate-xml-schema and --extern-xml-schema are "
+            << "mutually exclusive when compiling a single schema" << endl;
+
+          return 1;
+        }
+      }
+      else
+      {
+        // The --file-per-type and --generate-xml-schema options are
+        // incompatible. It also makes sense to use --file-per-type
+        // and --extern-xml-schema.
+        //
+        if (gen)
+        {
+          e << "error: --file-per-type and --generate-xml-schema are "
+            << "incompatible" << endl
+            << "info: use --generate-xml-schema in a separate invocation "
+            << "of the compiler" << endl;
+
+          return 1;
+        }
+
+        if (!use &&
+            !disabled_w_all && disabled_w.find ("D002") == disabled_w.end ())
+        {
+          e << "warning D002: --extern-xml-schema is recommended when "
+            << "--file-per-type is specified to reduce generated code size"
+            << endl;
+        }
+      }
+    }
+
+    //
+    //
+    FileList file_list;
+    AutoUnlinks unlinks;
+    size_t sloc (0);
+
+    LocationTranslator loc_translator (
+      common_ops.location_map (),
+      common_ops.location_regex (),
+      common_ops.location_regex_trace ());
+
+    AnonymousNameTranslator anon_translator (
+      common_ops.anonymous_regex (),
+      common_ops.anonymous_regex_trace ());
+
+    // Load custom string literals, if any.
+    //
+    CXX::StringLiteralMap string_literal_map;
+
+    if (NarrowString file = common_ops.custom_literals ())
+    {
+      XercesInitializer xerces_init;
+
+      if (!CXX::read_literal_map (file, string_literal_map))
+      {
+        // Diagnostics has already been issued.
+        //
+        return 1;
+      }
+    }
+
+    if (!fpt)
+    {
+      // File-per-schema compilation mode.
+      //
+
+      for (size_t i (0); i < files.size (); ++i)
+      {
+        // Parse schema.
+        //
+        SemanticGraph::Path tu;
+
+        try
+        {
+          tu = SemanticGraph::Path (files[i]);
+        }
+        catch (SemanticGraph::InvalidPath const&)
+        {
+          e << "error: '" << files[i].c_str () << "' is not a valid "
+            << "filesystem path" << endl;
+
+          return 1;
+        }
+
+        XSDFrontend::Parser parser (
+          cmd != "cxx-tree",
+          !common_ops.disable_multi_import (),
+          !common_ops.disable_full_check (),
+          loc_translator,
+          disabled_w);
+
+        unique_ptr<SemanticGraph::Schema> schema;
+
+        if (cmd == "cxx-tree" || cmd == "cxx-parser")
+        {
+          // See if we are generating code for the XML Schema namespace.
+          // 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.
+          //
+          bool gen_xml_schema (common_ops.generate_xml_schema ());
+
+          if (gen_xml_schema)
+          {
+            if (NarrowString name = common_ops.extern_xml_schema ())
+            {
+              if (tu.string () != name)
+                gen_xml_schema = false;
+            }
+          }
+
+          if (gen_xml_schema)
+            schema = parser.xml_schema (tu);
+          else
+            schema = parser.parse (tu);
+        }
+        else
+          schema = parser.parse (tu);
+
+        // Morph anonymous types.
+        //
+        if (!common_ops.preserve_anonymous ())
+        {
+          try
+          {
+            Transformations::Anonymous trans (anon_translator);
+            trans.transform (*schema, tu, true);
+          }
+          catch (Transformations::Anonymous::Failed const&)
+          {
+            return 1; // Diagnostic has already been issued.
+          }
+        }
+
+        // Synthesize enumerations from unions.
+        //
+        if (cmd == "cxx-tree")
+        {
+          Transformations::EnumSynthesis trans;
+          trans.transform (*schema, tu);
+        }
+
+        // Simplify the schema graph.
+        //
+        if (cmd == "cxx-parser")
+        {
+          Transformations::Simplifier trans;
+          trans.transform (*schema, tu);
+        }
+
+        // Try to rearrange definitions so that there is no forward
+        // inheritance.
+        //
+        try
+        {
+          Processing::Inheritance::Processor proc;
+          proc.process (*schema, tu);
+        }
+        catch (Processing::Inheritance::Processor::Failed const&)
+        {
+          return 1; // Diagnostic has already been issued.
+        }
+
+        // Normalize and annotate complex content restrictions.
+        //
+        if (cmd == "cxx-parser")
+        {
+          try
+          {
+            Transformations::Restriction trans;
+            trans.transform (*schema, tu);
+          }
+          catch (Transformations::Restriction::Failed const&)
+          {
+            return 1; // Diagnostic has already been issued.
+          }
+        }
+
+        // Calculate cardinality.
+        //
+        {
+          Processing::Cardinality::Processor proc;
+          proc.process (*schema, tu);
+        }
+
+        // Generate mapping.
+        //
+        if (cmd == "cxx-tree")
+        {
+          try
+          {
+            sloc += CXX::Tree::Generator::generate (
+              *tree_ops,
+              *schema,
+              tu,
+              false,
+              string_literal_map,
+              disabled_w,
+              file_list,
+              unlinks);
+          }
+          catch (CXX::Tree::Generator::Failed const&)
+          {
+            // Diagnostic has already been issued.
+            //
+            return 1;
+          }
+        }
+        else if (cmd == "cxx-parser")
+        {
+          try
+          {
+            sloc += CXX::Parser::Generator::generate (
+              *parser_ops,
+              *schema,
+              tu,
+              false,
+              string_literal_map,
+              true,
+              disabled_w,
+              file_list,
+              unlinks);
+          }
+          catch (CXX::Parser::Generator::Failed const&)
+          {
+            // Diagnostic has already been issued.
+            //
+            return 1;
+          }
+        }
+      }
+    }
+    else
+    {
+      // File-per-type compilation mode.
+      //
+      SemanticGraph::Paths paths;
+
+      for (size_t i (0); i < files.size (); ++i)
+      {
+        try
+        {
+          paths.push_back (SemanticGraph::Path (files[i]));
+        }
+        catch (SemanticGraph::InvalidPath const&)
+        {
+          e << "error: '" << files[i].c_str () << "' is not a valid "
+            << "filesystem path" << endl;
+
+          return 1;
+        }
+      }
+
+      if (cmd == "cxx-parser" &&
+          paths.size () > 1 &&
+          parser_ops->generate_test_driver ())
+      {
+        e << "info: generating test driver for the first schema only: '" <<
+          paths[0] << "'" << endl;
+      }
+
+      XSDFrontend::Parser parser (
+        cmd != "cxx-tree",
+        !common_ops.disable_multi_import (),
+        !common_ops.disable_full_check (),
+        loc_translator,
+        disabled_w);
+
+      unique_ptr<SemanticGraph::Schema> schema (parser.parse (paths));
+
+      // Morph anonymous types.
+      //
+      if (!common_ops.preserve_anonymous ())
+      {
+        try
+        {
+          Transformations::Anonymous trans (anon_translator);
+          trans.transform (*schema, SemanticGraph::Path (), false);
+        }
+        catch (Transformations::Anonymous::Failed const&)
+        {
+          return 1; // Diagnostic has already been issued.
+        }
+      }
+
+      // Synthesize enumerations from unions.
+      //
+      if (cmd == "cxx-tree")
+      {
+        Transformations::EnumSynthesis trans;
+        trans.transform (*schema, SemanticGraph::Path ());
+      }
+
+      // Simplify the schema graph.
+      //
+      if (cmd == "cxx-parser")
+      {
+        Transformations::Simplifier trans;
+        trans.transform (*schema, SemanticGraph::Path ());
+      }
+
+      // Normalize and annotate complex content restrictions.
+      //
+      if (cmd == "cxx-parser")
+      {
+        try
+        {
+          Transformations::Restriction trans;
+          trans.transform (*schema, SemanticGraph::Path ());
+        }
+        catch (Transformations::Restriction::Failed const&)
+        {
+          return 1; // Diagnostic has already been issued.
+        }
+      }
+
+      // Calculate cardinality.
+      //
+      {
+        Processing::Cardinality::Processor proc;
+        proc.process (*schema, SemanticGraph::Path ());
+      }
+
+      // Rearrange the graph so that each type is in a seperate
+      // schema file.
+      //
+      typedef vector<SemanticGraph::Schema*> Schemas;
+
+      SchemaPerTypeTranslator type_translator (
+        common_ops.type_file_regex (),
+        common_ops.type_file_regex_trace (),
+        common_ops.schema_file_regex (),
+        common_ops.schema_file_regex_trace ());
+
+      Transformations::SchemaPerType trans (
+        type_translator,
+        common_ops.fat_type_file ());
+
+      Schemas schemas (trans.transform (*schema));
+
+      // Generate code.
+      //
+      for (Schemas::iterator b (schemas.begin ()), i (b), e (schemas.end ());
+           i != e; ++i)
+      {
+        SemanticGraph::Schema& s (**i);
+        SemanticGraph::Path path (
+          s.context ().count ("renamed")
+          ? s.context ().get<SemanticGraph::Path> ("renamed")
+          : s.used_begin ()->path ());
+
+        if (cmd == "cxx-tree")
+        {
+          try
+          {
+            sloc += CXX::Tree::Generator::generate (
+              *tree_ops,
+              s,
+              path,
+              true,
+              string_literal_map,
+              disabled_w,
+              file_list,
+              unlinks);
+          }
+          catch (CXX::Tree::Generator::Failed const&)
+          {
+            // Diagnostic has already been issued.
+            //
+            return 1;
+          }
+        }
+        else if (cmd == "cxx-parser")
+        {
+          try
+          {
+            // Only generate driver for the first schema.
+            //
+            sloc += CXX::Parser::Generator::generate (
+              *parser_ops,
+              s,
+              path,
+              true,
+              string_literal_map,
+              i == b,
+              disabled_w,
+              file_list,
+              unlinks);
+          }
+          catch (CXX::Parser::Generator::Failed const&)
+          {
+            // Diagnostic has already been issued.
+            //
+            return 1;
+          }
+        }
+      }
+    }
+
+    // See if we need to produce the file list.
+    //
+    if (NarrowString fl = common_ops.file_list ())
+    {
+      typedef std::ofstream OutputFileStream;
+
+      try
+      {
+        OutputFileStream ofs;
+        if (fl != "-")
+        {
+          SemanticGraph::Path path (fl);
+
+          ofs.open (path.string ().c_str (), ios_base::out);
+
+          if (!ofs.is_open ())
+          {
+            wcerr << path << ": error: unable to open in write mode" << endl;
+            return 1;
+          }
+        }
+
+        std::ostream& os (ofs.is_open () ? ofs : cout);
+
+        NarrowString d (common_ops.file_list_delim ());
+        expand_nl (d);
+
+        if (NarrowString p = common_ops.file_list_prologue ())
+        {
+          expand_nl (p);
+          os << p;
+        }
+
+        for (FileList::iterator i (file_list.begin ()), e (file_list.end ());
+             i != e;)
+        {
+          os << *i;
+
+          if (++i != e)
+            os << d;
+        }
+
+        if (NarrowString e = common_ops.file_list_epilogue ())
+        {
+          expand_nl (e);
+          os << e;
+        }
+      }
+      catch (SemanticGraph::InvalidPath const&)
+      {
+        wcerr << "error: '" << fl.c_str () << "' is not a valid "
+              << "filesystem path" << endl;
+        return 1;
+      }
+    }
+
+    if (common_ops.show_sloc ())
+      e << "total: " << sloc << endl;
+
+    if (size_t sloc_limit = common_ops.sloc_limit ())
+    {
+      if (sloc_limit < sloc)
+      {
+        e << "error: SLOC limit of " << sloc_limit
+          << " lines has been exceeded" << endl;
+
+        return 1;
+      }
+    }
+
+    unlinks.cancel ();
+
+    return 0;
+  }
+  catch (LocationTranslator::Failed const&)
+  {
+    // Diagnostic has already been issued.
+  }
+  catch (AnonymousNameTranslator::Failed const&)
+  {
+    // Diagnostic has already been issued.
+  }
+  catch (SchemaPerTypeTranslator::Failed const&)
+  {
+    // Diagnostic has already been issued.
+  }
+  catch (Transformations::SchemaPerType::Failed const&)
+  {
+    // Diagnostic has already been issued.
+  }
+  catch (XSDFrontend::InvalidSchema const&)
+  {
+    // Diagnostic has already been issued.
+  }
+  catch (cli::exception const& ex)
+  {
+    wcerr << ex << endl;
+    wcerr << "try '" << argv[0] << " help' for usage information" << endl;
+  }
+
+  return 1;
+}
+
+// LocationTranslator
+//
+
+LocationTranslator::
+LocationTranslator (NarrowStrings const& map,
+                    NarrowStrings const& regex,
+                    bool trace)
+    : trace_ (trace)
+{
+  // Map.
+  //
+  for (NarrowStrings::const_iterator i (map.begin ()); i != map.end (); ++i)
+  {
+    // Split the string in two parts at the last '='.
+    //
+    size_t pos (i->rfind ('='));
+
+    if (pos == NarrowString::npos)
+    {
+      wcerr << "error: invalid location map: '" << i->c_str () <<
+        "': delimiter ('=') not found" << endl;
+
+      throw Failed ();
+    }
+
+    map_[NarrowString (*i, 0, pos)] = NarrowString (*i, pos + 1);
+  }
+
+  // Regex.
+  //
+  for (NarrowStrings::const_iterator i (regex.begin ()); i != regex.end (); ++i)
+  {
+    try
+    {
+      regex_.push_back (Regex (*i));
+    }
+    catch (RegexFormat const& e)
+    {
+      wcerr << "error: invalid location regex: '" <<
+        e.regex ().c_str () << "': " <<
+        e.description ().c_str () << endl;
+
+      throw Failed ();
+    }
+  }
+}
+
+NarrowString LocationTranslator::
+translate (NarrowString const& l)
+{
+  // First check the cache.
+  //
+  Cache::const_iterator ci (cache_.find (l));
+
+  if (ci != cache_.end ())
+    return ci->second;
+
+  // Then check the direct map.
+  //
+  Map::const_iterator mi (map_.find (l));
+
+  if (mi != map_.end ())
+  {
+    cache_[l] = mi->second;
+    return mi->second;
+  }
+
+  // Finally try regex.
+  //
+  if (trace_)
+    wcerr << "location: '" << l.c_str () << "'" << endl;
+
+  for (RegexVector::reverse_iterator i (regex_.rbegin ());
+       i != regex_.rend (); ++i)
+  {
+    if (trace_)
+      wcerr << "try: '" << i->regex ().str ().c_str () << "' : ";
+
+    if (i->match (l))
+    {
+      NarrowString r (i->replace (l));
+
+      if (trace_)
+        wcerr << "'" << r.c_str () << "' : +" << endl;
+
+      cache_[l] = r;
+      return r;
+    }
+
+    if (trace_)
+      wcerr << '-' << endl;
+  }
+
+  // No match - return the original location.
+  //
+  cache_[l] = l;
+  return l;
+}
+
+// AnonymousNameTranslator
+//
+
+AnonymousNameTranslator::
+AnonymousNameTranslator (NarrowStrings const& regex, bool trace)
+    : trace_ (trace)
+{
+  for (NarrowStrings::const_iterator i (regex.begin ()); i != regex.end (); ++i)
+  {
+    try
+    {
+      regex_.push_back (Regex (String (*i)));
+    }
+    catch (RegexFormat const& e)
+    {
+      wcerr << "error: invalid anonymous type regex: '" <<
+        e.regex () << "': " << e.description ().c_str () << endl;
+
+      throw Failed ();
+    }
+  }
+}
+
+String AnonymousNameTranslator::
+translate (String const& file,
+           String const& ns,
+           String const& name,
+           String const& xpath)
+{
+  String s (file + L' ' + ns + L' ' + xpath);
+
+  if (trace_)
+    wcerr << "anonymous type: '" << s << "'" << endl;
+
+  for (RegexVector::reverse_iterator i (regex_.rbegin ());
+       i != regex_.rend (); ++i)
+  {
+    if (trace_)
+      wcerr << "try: '" << i->regex () << "' : ";
+
+    if (i->match (s))
+    {
+      String r (i->replace (s));
+
+      if (trace_)
+        wcerr << "'" << r << "' : +" << endl;
+
+      return r;
+    }
+
+    if (trace_)
+      wcerr << '-' << endl;
+  }
+
+  // No match - return the name.
+  //
+  return name;
+}
+
+// SchemaPerTypeTranslator
+//
+
+SchemaPerTypeTranslator::
+SchemaPerTypeTranslator (NarrowStrings const& type_regex,
+                         bool type_trace,
+                         NarrowStrings const& schema_regex,
+                         bool schema_trace)
+    : type_trace_ (type_trace), schema_trace_ (schema_trace)
+{
+  for (NarrowStrings::const_iterator i (type_regex.begin ());
+       i != type_regex.end (); ++i)
+  {
+    try
+    {
+      type_regex_.push_back (TypeRegex (String (*i)));
+    }
+    catch (TypeRegexFormat const& e)
+    {
+      wcerr << "error: invalid type file regex: '" <<
+        e.regex () << "': " << e.description ().c_str () << endl;
+
+      throw Failed ();
+    }
+  }
+
+  for (NarrowStrings::const_iterator i (schema_regex.begin ());
+       i != schema_regex.end (); ++i)
+  {
+    try
+    {
+      schema_regex_.push_back (SchemaRegex (*i));
+    }
+    catch (SchemaRegexFormat const& e)
+    {
+      wcerr << "error: invalid type file regex: '" <<
+        e.regex ().c_str () << "': " << e.description ().c_str () << endl;
+
+      throw Failed ();
+    }
+  }
+}
+
+String SchemaPerTypeTranslator::
+translate_type (String const& ns, String const& name)
+{
+  String s (ns + L' ' + name);
+
+  if (type_trace_)
+    wcerr << "type: '" << s << "'" << endl;
+
+  for (TypeRegexVector::reverse_iterator i (type_regex_.rbegin ());
+       i != type_regex_.rend (); ++i)
+  {
+    if (type_trace_)
+      wcerr << "try: '" << i->regex () << "' : ";
+
+    if (i->match (s))
+    {
+      String r (i->replace (s));
+
+      if (type_trace_)
+        wcerr << "'" << r << "' : +" << endl;
+
+      return r;
+    }
+
+    if (type_trace_)
+      wcerr << '-' << endl;
+  }
+
+  // No match - return empty string.
+  //
+  return L"";
+}
+
+NarrowString SchemaPerTypeTranslator::
+translate_schema (NarrowString const& file)
+{
+  if (schema_trace_)
+    wcerr << "schema: '" << file.c_str () << "'" << endl;
+
+  for (SchemaRegexVector::reverse_iterator i (schema_regex_.rbegin ());
+       i != schema_regex_.rend (); ++i)
+  {
+    if (schema_trace_)
+      wcerr << "try: '" << i->regex ().str ().c_str () << "' : ";
+
+    if (i->match (file))
+    {
+      NarrowString r (i->replace (file));
+
+      if (schema_trace_)
+        wcerr << "'" << r.c_str () << "' : +" << endl;
+
+      return r;
+    }
+
+    if (schema_trace_)
+      wcerr << '-' << endl;
+  }
+
+  // No match - return empty string.
+  //
+  return "";
+}
+
+//
+//
+void
+expand_nl (NarrowString& s)
+{
+  for (size_t i (0); i < s.size ();)
+  {
+    if (s[i] == '\\' && (i + 1) < s.size () && s[i + 1] == 'n')
+    {
+      NarrowString tmp (s, 0, i);
+      tmp += '\n';
+      tmp.append (s.c_str () + i + 2);
+      s = tmp;
+    }
+    else
+      ++i;
+  }
+}
diff --git a/xsd/xsd.hxx b/xsd/xsd.hxx
new file mode 100644
index 0000000..5ce2926
--- /dev/null
+++ b/xsd/xsd.hxx
@@ -0,0 +1,24 @@
+// file      : xsd/xsd.hxx
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_XSD_HXX
+#define XSD_XSD_HXX
+
+#include <set>
+#include <vector>
+#include <cstdio> // std::remove
+
+#include <libcutl/shared-ptr.hxx>
+#include <libcutl/fs/auto-remove.hxx>
+
+#include <libxsd-frontend/semantic-graph/elements.hxx> // Path
+
+#include <xsd/types.hxx>
+
+typedef std::set<NarrowString> WarningSet;
+typedef std::vector<NarrowString> FileList;
+
+typedef cutl::fs::auto_remove AutoUnlink;
+typedef cutl::fs::auto_removes AutoUnlinks;
+
+#endif // XSD_XSD_HXX