[med-svn] [camp] 01/02: Imported Upstream version 0.7.1.1

Corentin Desfarges corentin-guest at moszumanska.debian.org
Thu Aug 28 14:30:50 UTC 2014


This is an automated email from the git hooks/post-receive script.

corentin-guest pushed a commit to branch master
in repository camp.

commit 7ca9d329b0930f8c3d3fce60d87a8401f242015c
Author: root <root at debian>
Date:   Thu Aug 28 16:14:16 2014 +0200

    Imported Upstream version 0.7.1.1
---
 .gitignore                                 |   34 +
 CMakeLists.txt                             |  213 +++
 COPYING.txt                                |   18 +
 INSTALL.txt                                |   47 +
 LICENSE.GPL3.txt                           |  674 +++++++++
 LICENSE.LGPL3.txt                          |  165 +++
 README.txt                                 |   22 +
 cmake/Config.cmake                         |   46 +
 cmake/MacOSX.cmake                         |   71 +
 cmake/Modules/FindCAMP.cmake               |   48 +
 cmake/PackageFilename.cmake                |   69 +
 cmake/Packaging.cmake                      |  112 ++
 doc/CMakeLists.txt                         |   82 ++
 doc/api/Doxyfile.in                        | 1542 +++++++++++++++++++
 doc/api/footer.html                        |    7 +
 doc/api/header.html                        |   16 +
 doc/api/images/logo_camp.png               |  Bin 0 -> 9391 bytes
 doc/api/images/tegesoft-bg.png             |  Bin 0 -> 220 bytes
 doc/api/images/tegesoft.png                |  Bin 0 -> 16552 bytes
 doc/api/mainpage.hpp                       |  143 ++
 doc/images/logo_camp.ai                    | 2207 ++++++++++++++++++++++++++++
 doc/images/logo_camp.svg                   |  101 ++
 doc/images/logo_package.bmp                |  Bin 0 -> 25818 bytes
 include/camp-xml/common.hpp                |   79 +
 include/camp-xml/common.inl                |  158 ++
 include/camp-xml/libxml.hpp                |  146 ++
 include/camp-xml/qtxml.hpp                 |  129 ++
 include/camp-xml/rapidxml.hpp              |  129 ++
 include/camp-xml/tinyxml.hpp               |  126 ++
 include/camp-xml/xerces.hpp                |  162 ++
 include/camp/args.hpp                      |  166 +++
 include/camp/arraymapper.hpp               |  301 ++++
 include/camp/arrayproperty.hpp             |  250 ++++
 include/camp/camptype.hpp                  |  228 +++
 include/camp/class.hpp                     |  372 +++++
 include/camp/class.inl                     |   44 +
 include/camp/classbuilder.hpp              |  485 ++++++
 include/camp/classbuilder.inl              |  375 +++++
 include/camp/classcast.hpp                 |   50 +
 include/camp/classget.hpp                  |  116 ++
 include/camp/classget.inl                  |   65 +
 include/camp/classvisitor.hpp              |  159 ++
 include/camp/config.hpp                    |   71 +
 include/camp/constructor.hpp               |   76 +
 include/camp/detail/arraypropertyimpl.hpp  |  121 ++
 include/camp/detail/arraypropertyimpl.inl  |   98 ++
 include/camp/detail/callhelper.hpp         |   98 ++
 include/camp/detail/classmanager.hpp       |  189 +++
 include/camp/detail/constructorimpl.hpp    |  299 ++++
 include/camp/detail/enummanager.hpp        |  186 +++
 include/camp/detail/enumpropertyimpl.hpp   |   93 ++
 include/camp/detail/enumpropertyimpl.inl   |   67 +
 include/camp/detail/functionimpl.hpp       |  514 +++++++
 include/camp/detail/functiontraits.hpp     |   97 ++
 include/camp/detail/getter.hpp             |  151 ++
 include/camp/detail/getter.inl             |   80 +
 include/camp/detail/issmartpointer.hpp     |   92 ++
 include/camp/detail/objectholder.hpp       |  198 +++
 include/camp/detail/objectholder.inl       |  116 ++
 include/camp/detail/objecttraits.hpp       |  176 +++
 include/camp/detail/observernotifier.hpp   |  115 ++
 include/camp/detail/propertyfactory.hpp    |  434 ++++++
 include/camp/detail/rawtype.hpp            |  101 ++
 include/camp/detail/returntype.hpp         |   51 +
 include/camp/detail/simplepropertyimpl.hpp |   93 ++
 include/camp/detail/simplepropertyimpl.inl |   67 +
 include/camp/detail/typeid.hpp             |  183 +++
 include/camp/detail/userpropertyimpl.hpp   |   93 ++
 include/camp/detail/userpropertyimpl.inl   |  106 ++
 include/camp/detail/valueimpl.hpp          |  120 ++
 include/camp/detail/valueprovider.hpp      |   94 ++
 include/camp/detail/yesnotype.hpp          |   51 +
 include/camp/enum.hpp                      |  230 +++
 include/camp/enum.inl                      |   34 +
 include/camp/enumbuilder.hpp               |   74 +
 include/camp/enumget.hpp                   |  118 ++
 include/camp/enumget.inl                   |   65 +
 include/camp/enumobject.hpp                |  110 ++
 include/camp/enumobject.inl                |   34 +
 include/camp/enumproperty.hpp              |   78 +
 include/camp/error.hpp                     |  118 ++
 include/camp/error.inl                     |   41 +
 include/camp/errors.hpp                    |  326 ++++
 include/camp/function.hpp                  |  165 +++
 include/camp/observer.hpp                  |  106 ++
 include/camp/property.hpp                  |  185 +++
 include/camp/qt/qlist.hpp                  |   76 +
 include/camp/qt/qstring.hpp                |   79 +
 include/camp/qt/qt.hpp                     |   42 +
 include/camp/qt/qtfunction.hpp             |  197 +++
 include/camp/qt/qthelper.hpp               |  204 +++
 include/camp/qt/qtmapper.hpp               |  176 +++
 include/camp/qt/qtsimpleproperty.hpp       |  112 ++
 include/camp/qt/qvector.hpp                |   76 +
 include/camp/simpleproperty.hpp            |   69 +
 include/camp/tagholder.hpp                 |  134 ++
 include/camp/type.hpp                      |   63 +
 include/camp/userobject.hpp                |  313 ++++
 include/camp/userobject.inl                |  109 ++
 include/camp/userproperty.hpp              |   78 +
 include/camp/value.hpp                     |  228 +++
 include/camp/value.inl                     |  102 ++
 include/camp/valuemapper.hpp               |  405 +++++
 include/camp/valuevisitor.hpp              |  104 ++
 src/args.cpp                               |  111 ++
 src/arrayproperty.cpp                      |  168 +++
 src/camptype.cpp                           |   47 +
 src/class.cpp                              |  227 +++
 src/classcast.cpp                          |   36 +
 src/classmanager.cpp                       |  147 ++
 src/classvisitor.cpp                       |   77 +
 src/enum.cpp                               |  112 ++
 src/enumbuilder.cpp                        |   51 +
 src/enummanager.cpp                        |  147 ++
 src/enumobject.cpp                         |   67 +
 src/enumproperty.cpp                       |   54 +
 src/error.cpp                              |   53 +
 src/errors.cpp                             |  156 ++
 src/function.cpp                           |  100 ++
 src/observer.cpp                           |   81 +
 src/observernotifier.cpp                   |   90 ++
 src/outofrange.cpp                         |   40 +
 src/property.cpp                           |  110 ++
 src/simpleproperty.cpp                     |   47 +
 src/tagholder.cpp                          |   87 ++
 src/userobject.cpp                         |  244 +++
 src/userproperty.cpp                       |   54 +
 src/value.cpp                              |   83 ++
 test/CMakeLists.txt                        |   96 ++
 test/arrayproperty.cpp                     |  178 +++
 test/arrayproperty.hpp                     |   92 ++
 test/class.cpp                             |  137 ++
 test/class.hpp                             |   97 ++
 test/classvisitor.cpp                      |   47 +
 test/classvisitor.hpp                      |  119 ++
 test/constructor.cpp                       |  163 ++
 test/constructor.hpp                       |  114 ++
 test/enum.cpp                              |  134 ++
 test/enum.hpp                              |   66 +
 test/enumobject.cpp                        |  120 ++
 test/enumobject.hpp                        |   68 +
 test/enumproperty.cpp                      |   77 +
 test/enumproperty.hpp                      |   62 +
 test/function.cpp                          |  221 +++
 test/function.hpp                          |  177 +++
 test/functionaccess.cpp                    |   75 +
 test/functionaccess.hpp                    |   65 +
 test/inheritance.cpp                       |  174 +++
 test/inheritance.hpp                       |  115 ++
 test/main.cpp                              |   30 +
 test/mapper.cpp                            |  105 ++
 test/mapper.hpp                            |  148 ++
 test/property.cpp                          |  251 ++++
 test/property.hpp                          |  187 +++
 test/propertyaccess.cpp                    |  110 ++
 test/propertyaccess.hpp                    |   74 +
 test/qt/CMakeLists.txt                     |   71 +
 test/qt/functionmapping.cpp                |   92 ++
 test/qt/functionmapping.hpp                |   86 ++
 test/qt/main.cpp                           |   30 +
 test/qt/propertymapping.cpp                |  111 ++
 test/qt/propertymapping.hpp                |  119 ++
 test/qt/qstringmapping.cpp                 |   66 +
 test/tagholder.cpp                         |  103 ++
 test/tagholder.hpp                         |   90 ++
 test/userobject.cpp                        |  216 +++
 test/userobject.hpp                        |  144 ++
 test/userproperty.cpp                      |   79 +
 test/userproperty.hpp                      |   55 +
 test/value.cpp                             |  530 +++++++
 test/value.hpp                             |  113 ++
 version.in                                 |   34 +
 172 files changed, 25268 insertions(+)

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6c298c4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,34 @@
+Thumbs.db
+
+# Text editors temporary files
+*~
+.~*
+~*
+*.swp
+
+# IDE temporary files
+*.ncb
+*.pdb
+*.suo
+*.obj
+*.lnk
+*.user
+qtc-gdbmacros/
+
+# LaTeX temporary files
+*.aux
+*.log
+*.out
+*.toc
+*.lof
+*.blg
+*.bbl
+
+# Temporary build files
+*.o
+*.a
+moc_*
+
+# Auto-generated documentation files
+doc/api/*/*
+
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..2872c05
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,213 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+cmake_minimum_required(VERSION 2.6)
+
+# set project's name
+project(CAMP)
+
+# include project configuration
+include(${CMAKE_SOURCE_DIR}/cmake/Config.cmake)
+include(${CMAKE_SOURCE_DIR}/cmake/PackageFilename.cmake)
+
+# all source files
+set(CAMP_SRCS
+    include/camp/userproperty.hpp
+    src/userproperty.cpp
+    include/camp/userobject.hpp
+    include/camp/userobject.inl
+    src/userobject.cpp
+    include/camp/tagholder.hpp
+    src/tagholder.cpp
+    include/camp/simpleproperty.hpp
+    src/simpleproperty.cpp
+    include/camp/property.hpp
+    src/property.cpp
+    include/camp/observer.hpp
+    src/observer.cpp
+    include/camp/errors.hpp
+    src/errors.cpp
+    include/camp/function.hpp
+    src/function.cpp
+    include/camp/error.hpp
+    src/error.cpp
+    include/camp/enumproperty.hpp
+    src/enumproperty.cpp
+    include/camp/enumobject.hpp
+    include/camp/enumobject.inl
+    src/enumobject.cpp
+    include/camp/enumbuilder.hpp
+    src/enumbuilder.cpp
+    include/camp/enum.hpp
+    include/camp/enum.inl
+    src/enum.cpp
+    include/camp/classvisitor.hpp
+    src/classvisitor.cpp
+    include/camp/class.hpp
+    include/camp/class.inl
+    src/class.cpp
+    include/camp/arrayproperty.hpp
+    src/arrayproperty.cpp
+    include/camp/args.hpp
+    src/args.cpp
+    include/camp/value.hpp
+    include/camp/value.inl
+    src/value.cpp
+    include/camp/detail/classmanager.hpp
+    src/classmanager.cpp
+    include/camp/detail/enummanager.hpp
+    src/enummanager.cpp
+    include/camp/detail/observernotifier.hpp
+    src/observernotifier.cpp
+    include/camp/camptype.hpp
+    src/camptype.cpp
+    include/camp/classcast.hpp
+    src/classcast.cpp
+    include/camp/type.hpp
+    include/camp/enumget.hpp
+    include/camp/enumget.inl
+    include/camp/constructor.hpp
+    include/camp/config.hpp
+    include/camp/classget.hpp
+    include/camp/classget.inl
+    include/camp/classbuilder.hpp
+    include/camp/classbuilder.inl
+    include/camp/arraymapper.hpp
+    include/camp/valuemapper.hpp
+    include/camp/valuevisitor.hpp
+    include/camp/detail/valueimpl.hpp
+    include/camp/detail/userpropertyimpl.hpp
+    include/camp/detail/userpropertyimpl.inl
+    include/camp/detail/typeid.hpp
+    include/camp/detail/simplepropertyimpl.hpp
+    include/camp/detail/simplepropertyimpl.inl
+    include/camp/detail/returntype.hpp
+    include/camp/detail/rawtype.hpp
+    include/camp/detail/propertyfactory.hpp
+    include/camp/detail/objecttraits.hpp
+    include/camp/detail/issmartpointer.hpp
+    include/camp/detail/getter.hpp
+    include/camp/detail/getter.inl
+    include/camp/detail/functiontraits.hpp
+    include/camp/detail/functionimpl.hpp
+    include/camp/detail/enumpropertyimpl.hpp
+    include/camp/detail/enumpropertyimpl.inl
+    include/camp/detail/constructorimpl.hpp
+    include/camp/detail/callhelper.hpp
+    include/camp/detail/arraypropertyimpl.hpp
+    include/camp/detail/arraypropertyimpl.inl
+    include/camp/detail/yesnotype.hpp
+    include/camp/detail/objectholder.hpp
+    include/camp/detail/objectholder.inl
+    include/camp/detail/valueprovider.hpp
+    include/camp/qt/qthelper.hpp
+    include/camp/qt/qtsimpleproperty.hpp
+    include/camp/qt/qtmapper.hpp
+    include/camp/qt/qt.hpp
+    include/camp/qt/qstring.hpp
+    include/camp/qt/qlist.hpp
+    include/camp/qt/qvector.hpp
+    include/camp/qt/qtfunction.hpp
+)
+
+# find Boost
+find_package(Boost 1.38.0 REQUIRED)
+
+# include files search paths
+include_directories(
+    ${CAMP_SOURCE_DIR}/include
+    ${Boost_INCLUDE_DIRS}
+)
+
+# generate version.hpp
+message("Generate version.hpp")
+configure_file(${CMAKE_SOURCE_DIR}/version.in ${CMAKE_BINARY_DIR}/version.hpp @ONLY)
+
+# instruct CMake to build a shared library from all of the source files
+add_library(camp ${CAMP_SRCS})
+
+# define the export macro
+if(BUILD_SHARED_LIBS)
+    set_target_properties(camp PROPERTIES DEFINE_SYMBOL CAMP_EXPORTS)
+else()
+    add_definitions(-DCAMP_STATIC)
+endif()
+
+# define d suffix on windows
+if(WIN32)
+    set_target_properties(camp PROPERTIES DEBUG_POSTFIX d)
+endif()
+
+# gcc 4.x on Windows requires the -static-libgcc linker option to get rid of an extra DLL
+if (WIN32 AND CMAKE_COMPILER_IS_GNUCXX)
+    if(${GCC_VERSION} MATCHES "4\\..*")
+        set_target_properties(camp PROPERTIES LINK_FLAGS -static-libgcc)
+    endif()
+endif()
+
+# add the test subdirectory, but do not build it by default
+if(BUILD_TEST)
+    add_subdirectory(test)
+endif()
+
+###############################
+# doc
+###############################
+
+add_subdirectory(doc)
+
+###############################
+# installing
+###############################
+
+install(DIRECTORY include
+    DESTINATION .
+    COMPONENT devel
+)
+
+install(FILES ${CMAKE_BINARY_DIR}/version.hpp
+    DESTINATION include/camp
+    COMPONENT devel
+)
+
+install(TARGETS camp
+    RUNTIME DESTINATION bin COMPONENT bin
+    LIBRARY DESTINATION lib COMPONENT bin 
+    ARCHIVE DESTINATION lib COMPONENT devel
+)
+
+install(FILES README.txt COPYING.txt LICENSE.LGPL3.txt
+    DESTINATION ${INSTALL_MISC_DIR}
+)
+
+install(DIRECTORY cmake
+    DESTINATION ${INSTALL_MISC_DIR}
+    COMPONENT utils
+)
+
+###############################
+# packaging
+###############################
+
+include(${CAMP_SOURCE_DIR}/cmake/Packaging.cmake OPTIONAL)
+
diff --git a/COPYING.txt b/COPYING.txt
new file mode 100644
index 0000000..c72e553
--- /dev/null
+++ b/COPYING.txt
@@ -0,0 +1,18 @@
+Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+Contact: Technogerma Systems France Information (contact at technogerma.fr)
+
+This file is part of the CAMP library.
+
+CAMP is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+CAMP 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+
diff --git a/INSTALL.txt b/INSTALL.txt
new file mode 100644
index 0000000..387b687
--- /dev/null
+++ b/INSTALL.txt
@@ -0,0 +1,47 @@
+
+Building CAMP
+-------------
+
+The build system used for CAMP is CMake (http://cmake.org/).
+
+Moreover, the CAMP library depends on Boost (http://www.boost.org/).
+
+CMake will find Boost automatically if it is properly installed. If not, the BOOST_ROOT CMake variable can
+be defined to locate it.
+
+Once you have generated the project files / makefiles for your favorite compiler (please refer to http://cmake.org/
+if you do not know how to do it), you can use them to compile the CAMP binaries.
+ 
+The following targets are defined:
+ 
+(empty)
+    builds everything
+
+camp
+    builds the CAMP library
+
+camptest
+    builds the CAMP unit tests
+
+doc
+    generates the API documentation in HTML format; on Windows, if the HTML Help Workshop program
+    is available, the CHM documentation is generated as well; requires doxygen to be installed
+
+install
+    installs all the generated components to the standard path
+
+
+Installing CAMP
+---------------
+
+There are three ways to install CAMP:
+- Running the installer (on Windows and Mac OS X) and following the instructions
+- Uncompressing the binary archive to a standard path (C:\Program Files, /usr/local/, ...)
+- Using CMake and calling the "install" target (see above)
+
+This will create the following directories:
+- <INSTALL_PATH>/bin contains the CAMP binary files
+- <INSTALL_PATH>/doc contains the API documentation
+- <INSTALL_PATH>/include contains the CAMP header files
+- <INSTALL_PATH>/lib contains the CAMP library files
+- <INSTALL_PATH>/utils contains various utilities related to CAMP
diff --git a/LICENSE.GPL3.txt b/LICENSE.GPL3.txt
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/LICENSE.GPL3.txt
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  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
+them 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 prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  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.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey 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;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If 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 convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  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.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+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.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     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
+state 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 3 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, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program 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, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU 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 Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/LICENSE.LGPL3.txt b/LICENSE.LGPL3.txt
new file mode 100644
index 0000000..65c5ca8
--- /dev/null
+++ b/LICENSE.LGPL3.txt
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..c86c26f
--- /dev/null
+++ b/README.txt
@@ -0,0 +1,22 @@
+
+CAMP is a multi-purpose reflection library developped by Technogerma Systems France
+(http://www.tegesoft.com).
+
+It provides an abstraction for most of the high-level concepts of C++:
+- Classes
+- Enumerations
+- Properties
+- Functions
+- Objects
+- Variables
+
+By wrapping all these concepts into abstract structures, CAMP provides an extra layer of
+flexibility to programs, and allow them to fully expose their data structures at runtime.
+
+Many applications can take advantage of CAMP, in order to automate tasks which would
+otherwise require a huge amount of work. For example, CAMP can be used to expose and edit
+objects' attributes into a graphical user interface. It can also be used to do
+automatic binding of C++ classes to script languages such as Python or Lua.
+Another possible application would be the serialization of objects to XML, text or
+binary formats. Or you can even combine all these examples to provide a powerful
+and consistent interface for manipulating your objects outside C++ code.
diff --git a/cmake/Config.cmake b/cmake/Config.cmake
new file mode 100644
index 0000000..69fddca
--- /dev/null
+++ b/cmake/Config.cmake
@@ -0,0 +1,46 @@
+
+# setup version numbers
+set(VERSION_MAJOR 0)
+set(VERSION_MINOR 7)
+set(VERSION_PATCH 1)
+set(VERSION_STR "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
+message("Project version: ${VERSION_STR}")
+
+# Set the default build type to release with debug info
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo
+        CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+    )
+endif()
+
+# Add an option for choosing the build type (shared or static)
+if(NOT BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS TRUE
+        CACHE BOOL "TRUE to build CAMP as a shared library, FALSE to build it as a static library."
+    )
+endif()
+
+# Set the default test build option to false
+if(NOT BUILD_TEST)
+    set(BUILD_TEST FALSE
+        CACHE BOOL "TRUE to build the unit tests (requires the Boost Test Library), FALSE otherwise."
+    )
+endif()
+
+# Set the default test build option to false
+if(NOT BUILD_TEST_QT)
+    set(BUILD_TEST_QT FALSE
+        CACHE BOOL "TRUE to build the Qt-specific unit tests (requires the Boost Test Library and Qt 4.5), FALSE otherwise."
+    )
+endif()
+
+# define install directory for miscelleneous files
+if(WIN32 AND NOT UNIX)
+    set(INSTALL_MISC_DIR .)
+elseif(UNIX)
+    set(INSTALL_MISC_DIR share/camp)
+endif()
+
+# setup MacOSX build environment if necessary
+include(${CMAKE_SOURCE_DIR}/cmake/MacOSX.cmake)
+
diff --git a/cmake/MacOSX.cmake b/cmake/MacOSX.cmake
new file mode 100644
index 0000000..d066c32
--- /dev/null
+++ b/cmake/MacOSX.cmake
@@ -0,0 +1,71 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+# Apple MacOS X
+# Configure to build universal binaries.
+# Build intel 32-bit on 10.4 and intel 32/64-bit on >= 10.5
+
+if(APPLE AND NOT NON_NATIVE_TARGET)
+    if(NOT OSX_CONFIG_HAS_BEEN_RUN_BEFORE)
+    
+        # Make sure the version of CMake is compatible with this script
+    
+        if(${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4 
+            AND ${CMAKE_PATCH_VERSION} LESS 7)
+            message(STATUS
+                        "Warning: A critical CMake bug exists in 2.4.6 and below.  "
+                        "Trying to build Universal Binaries will result in a compile "
+                        "error that seems unrelated.  Either avoid building Universal "
+                        "Binaries by changing the CMAKE_OSX_ARCHITECTURES field to list "
+                        "only your architecture, or upgrade to a newer version of CMake.")
+        endif()
+            
+        # Determine the correct SDK
+            
+        if(NOT FORCE_32BIT AND (EXISTS /Developer/SDKs/10.5.sdk OR EXISTS /Developer/SDKs/MacOSX10.6.sdk))
+            set(CMAKE_OSX_ARCHITECTURES "i386;x86_64" 
+                 CACHE STRING "Build architectures for OSX" FORCE)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.5"
+                 CACHE STRING "Flags used by the compiler during all build types." FORCE)
+        else()
+            if(EXISTS /Developer/SDKs/MacOSX10.4u.sdk OR FORCE_32BIT)
+                set(CMAKE_OSX_ARCHITECTURES "i386" 
+                     CACHE STRING "Build architectures for OSX" FORCE)
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4 -m32"
+                     CACHE STRING "Flags used by the compiler during all build types." FORCE)
+            else()
+                # No Universal Binary support
+            endif()
+        endif()
+        set(OSX_CONFIG_HAS_BEEN_RUN_BEFORE TRUE)
+    endif(NOT OSX_CONFIG_HAS_BEEN_RUN_BEFORE)
+endif(APPLE AND NOT NON_NATIVE_TARGET)
+
+if(OSX_ARCHITECTURES_OVERRIDE)
+    set(CMAKE_OSX_ARCHITECTURES ${OSX_ARCHITECTURES_OVERRIDE})
+endif()
+
+if(APPLE)
+    message(STATUS "Compiling for Mac OS X architecture(s): " ${CMAKE_OSX_ARCHITECTURES})
+endif()
+
diff --git a/cmake/Modules/FindCAMP.cmake b/cmake/Modules/FindCAMP.cmake
new file mode 100644
index 0000000..e2c4bf9
--- /dev/null
+++ b/cmake/Modules/FindCAMP.cmake
@@ -0,0 +1,48 @@
+# Locate CAMP library
+# This module defines
+#  CAMP_FOUND, if false, do not try to link to CAMP
+#  CAMP_LIBRARIES
+#  CAMP_INCLUDE_DIR, where to find camp/version.hpp
+
+FIND_PATH(CAMP_INCLUDE_DIR camp/version.hpp
+  HINTS
+  $ENV{CAMP_DIR}
+  PATH_SUFFIXES include
+  PATHS
+  [HKEY_LOCAL_MACHINE\\SOFTWARE\\Tegesoft\\CAMP]
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+FIND_LIBRARY(CAMP_LIBRARY 
+  NAMES camp
+  HINTS
+  $ENV{CAMP_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  [HKEY_LOCAL_MACHINE\\SOFTWARE\\Tegesoft\\CAMP]
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+SET(CAMP_LIBRARIES "${CAMP_LIBRARY}" CACHE STRING "CAMP Libraries")
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set CAMP_FOUND to TRUE if 
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CAMP DEFAULT_MSG CAMP_LIBRARIES CAMP_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(CAMP_INCLUDE_DIR CAMP_LIBRARIES CAMP_LIBRARY)
+
diff --git a/cmake/PackageFilename.cmake b/cmake/PackageFilename.cmake
new file mode 100644
index 0000000..203d800
--- /dev/null
+++ b/cmake/PackageFilename.cmake
@@ -0,0 +1,69 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+###############################
+# generate package filename
+# setup CPACK_PACKAGE_FILE_NAME and CPACK_SOURCE_PACKAGE_FILE_NAME according to
+# the current build architecture, system and compiler
+# Note that CPACK_PACKAGE_NAME and VERSION_STR must be defined
+###############################
+
+# detect architecture
+include(CheckTypeSize)
+check_type_size(void* SIZEOF_VOID_PTR)
+if(${SIZEOF_VOID_PTR} MATCHES "^8$")
+    set(NATIVE_ARCH 64)
+else()
+    set(NATIVE_ARCH 32)
+endif()
+
+# detect system
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    set(PACKAGE_SYSTEM_NAME "linux${NATIVE_ARCH}")
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    set(PACKAGE_SYSTEM_NAME "win${NATIVE_ARCH}")
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    set(PACKAGE_SYSTEM_NAME "osx")
+else()
+    message(WARNING "Unsupported system for package generation")
+    return()
+endif()
+
+#detect compiler
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(PACKAGE_COMPILER_NAME "gcc")
+    if(WIN32)
+        execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-dumpversion" OUTPUT_VARIABLE GCC_VERSION_OUTPUT)
+        string(REGEX REPLACE "([0-9]+\\.[0-9]+).*" "\\1" GCC_VERSION "${GCC_VERSION_OUTPUT}")
+        set(PACKAGE_COMPILER_NAME ${PACKAGE_COMPILER_NAME}${GCC_VERSION})
+    endif()
+elseif(MSVC_VERSION EQUAL 1400)
+    set(PACKAGE_COMPILER_NAME "vc2005")
+elseif(MSVC_VERSION EQUAL 1500)
+    set(PACKAGE_COMPILER_NAME "vc2008")
+elseif(MSVC_VERSION EQUAL 1600)
+    set(PACKAGE_COMPILER_NAME "vc2010")
+else()
+    message(WARNING "Unsupported compiler for package generation")
+    return()
+endif()
diff --git a/cmake/Packaging.cmake b/cmake/Packaging.cmake
new file mode 100644
index 0000000..689de28
--- /dev/null
+++ b/cmake/Packaging.cmake
@@ -0,0 +1,112 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+###############################
+# packaging
+###############################
+
+# Components setup
+set(CPACK_COMPONENTS_ALL bin devel apidoc utils)
+set(CPACK_ALL_INSTALL_TYPES Runtime Development)
+
+set(CPACK_COMPONENT_BIN_DISPLAY_NAME "CAMP library")
+set(CPACK_COMPONENT_BIN_DESCRIPTION "The CAMP library binaries")
+set(CPACK_COMPONENT_BIN_INSTALL_TYPES Runtime Development)
+
+set(CPACK_COMPONENT_DEVEL_DISPLAY_NAME "CAMP development files")
+set(CPACK_COMPONENT_DEVEL_DESCRIPTION "C++ header files, import library")
+set(CPACK_COMPONENT_DEVEL_DEPENDS bin)
+set(CPACK_COMPONENT_DEVEL_GROUP "Development")
+set(CPACK_COMPONENT_DEVEL_INSTALL_TYPES Development)
+
+set(CPACK_COMPONENT_APIDOC_DISPLAY_NAME "CAMP API documentation")
+set(CPACK_COMPONENT_APIDOC_DESCRIPTION "Documentation for developers")
+set(CPACK_COMPONENT_APIDOC_GROUP "Development")
+set(CPACK_COMPONENT_APIDOC_INSTALL_TYPES Development)
+
+set(CPACK_COMPONENT_UTILS_DISPLAY_NAME "CAMP utilities")
+set(CPACK_COMPONENT_UTILS_DESCRIPTION
+    "Provides a FindCAMP.cmake file to be used with project based on CMake"
+)
+set(CPACK_COMPONENT_UTILS_GROUP "Development")
+set(CPACK_COMPONENT_UTILS_DISABLED TRUE)
+
+set(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION "Components related to software development based on CAMP")
+set(CPACK_COMPONENT_GROUP_DEVELOPMENT_EXPANDED TRUE)
+
+# Package setup
+set(CPACK_PACKAGE_NAME CAMP)
+set(CPACK_PACKAGE_VENDOR Tegesoft)
+set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})
+set(CPACK_PACKAGE_DESCRIPTION_FILE ${CAMP_SOURCE_DIR}/README.txt)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CAMP is a multi-purpose C++ reflection library")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_VENDOR}\\\\camp)
+set(CPACK_RESOURCE_FILE_LICENSE ${CAMP_SOURCE_DIR}/COPYING.txt)
+set(CPACK_RESOURCE_FILE_README ${CAMP_SOURCE_DIR}/README.txt)
+set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY CAMP)
+
+# Package filename setup
+include(${CMAKE_SOURCE_DIR}/cmake/PackageFilename.cmake)
+
+# set package file name
+string(TOLOWER ${CPACK_PACKAGE_NAME} LOWER_PACKAGE_NAME)
+set(CPACK_PACKAGE_FILE_NAME
+    ${LOWER_PACKAGE_NAME}-${VERSION_STR}-${PACKAGE_SYSTEM_NAME}-${PACKAGE_COMPILER_NAME})
+set(CPACK_SOURCE_PACKAGE_FILE_NAME
+    ${LOWER_PACKAGE_NAME}-${VERSION_STR}-src)
+
+if(WIN32 AND NOT UNIX)
+    set(CPACK_GENERATOR ZIP;NSIS)
+elseif(UNIX AND NOT APPLE)
+    set(CPACK_GENERATOR TGZ;TBZ2)
+elseif(APPLE)
+    set(CPACK_GENERATOR TGZ;TBZ2;PackageMaker)
+endif()
+
+set(CPACK_SOURCE_GENERATOR TGZ;ZIP)
+
+file(GLOB IGNORED_DOT_FILES ".*")
+set(CPACK_SOURCE_IGNORE_FILES
+    ${IGNORED_DOT_FILES}
+)
+
+# NSIS setup
+#set(CPACK_NSIS_MUI_ICON ${CAMP_SOURCE_DIR}/doc/images\\\\logo.ico)
+#set(CPACK_NSIS_MUI_UNIICON ${CAMP_SOURCE_DIR}/doc/images\\\\logo.ico)
+set(CPACK_PACKAGE_ICON ${CAMP_SOURCE_DIR}/doc/images\\\\logo_package.bmp)
+#set(CPACK_NSIS_EXTRA_INSTALL_COMMANDS)
+#set(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS)
+#set(CPACK_NSIS_COMPRESSOR)
+#set(CPACK_NSIS_MODIFY_PATH)
+set(CPACK_NSIS_DISPLAY_NAME CAMP)
+#set(CPACK_NSIS_INSTALLED_ICON_NAME)
+set(CPACK_NSIS_HELP_LINK "http://dev.tegesoft.com")
+set(CPACK_NSIS_URL_INFO_ABOUT "http://dev.tegesoft.com")
+set(CPACK_NSIS_CONTACT "contact at tegesoft.com")
+#set(CPACK_NSIS_CREATE_ICONS_EXTRA)
+#set(CPACK_NSIS_DELETE_ICONS_EXTRA)
+
+include(CPack)
+
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
new file mode 100644
index 0000000..1503cd0
--- /dev/null
+++ b/doc/CMakeLists.txt
@@ -0,0 +1,82 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+###############################
+# doc
+###############################
+
+find_package(Doxygen)
+if(DOXYGEN_FOUND)
+    # setup variables to be replaced in the source Doxyfile
+    set(DOXYGEN_INPUT_DIR ${CMAKE_SOURCE_DIR})
+   
+    ###################################
+    # local documentation
+    ###################################
+
+    set(DOXYGEN_OUTPUT_TYPE html)
+    set(DOXYGEN_CONFIGURED_INPUT ${CMAKE_BINARY_DIR}/doc/campapi.doxy)
+    set(DOXYGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/doc/api)
+
+    if(WIN32)
+        set(DOXYGEN_GENERATE_MAN NO)
+        find_program(HHC_PROGRAM 
+            NAMES hhc.exe 
+            PATHS "c:/Program Files/HTML Help Workshop"
+            DOC "HTML Help Compiler program")
+        if(HHC_PROGRAM)
+            set(DOXYGEN_GENERATE_HTMLHELP YES)
+        else()
+            set(DOXYGEN_GENERATE_HTMLHELP NO)
+        endif()
+    else()
+        set(DOXYGEN_GENERATE_MAN NO)
+        set(DOXYGEN_GENERATE_HTMLHELP NO)
+        set(HHC_PROGRAM)
+    endif()
+
+    # configure the source Doxyfile by copying it and replacing all @variables@
+    configure_file(${DOXYGEN_INPUT_DIR}/doc/api/Doxyfile.in ${DOXYGEN_CONFIGURED_INPUT} @ONLY)
+
+    # copy necessary doc files
+    file(GLOB image_files ${DOXYGEN_INPUT_DIR}/doc/api/images/*)
+    foreach(file ${image_files})
+        get_filename_component(filename ${file} NAME)
+        configure_file(${file} ${DOXYGEN_OUTPUT_DIR}/${DOXYGEN_OUTPUT_TYPE}/${filename} COPYONLY)
+    endforeach()
+
+    # target setup
+    add_custom_target(doc
+        COMMAND ${CMAKE_COMMAND} -E echo_append "Building API Documentation..."
+        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CONFIGURED_INPUT}
+        COMMAND ${CMAKE_COMMAND} -E echo "Done."
+        WORKING_DIRECTORY ${DOXYGEN_INPUT_DIR}
+    )
+
+    # install
+    install(DIRECTORY ${DOXYGEN_OUTPUT_DIR}
+        DESTINATION ${INSTALL_MISC_DIR}/doc
+        COMPONENT apidoc
+    )
+endif()
+
diff --git a/doc/api/Doxyfile.in b/doc/api/Doxyfile.in
new file mode 100644
index 0000000..00b51e7
--- /dev/null
+++ b/doc/api/Doxyfile.in
@@ -0,0 +1,1542 @@
+# Doxyfile 1.5.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file 
+# that follow. The default is UTF-8 which is also the encoding used for all 
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the 
+# iconv built into libc) for the transcoding. See 
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = CAMP
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = @VERSION_MAJOR at .@VERSION_MINOR@
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "@DOXYGEN_OUTPUT_DIR@"
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, 
+# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), 
+# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, 
+# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene, 
+# Spanish, Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = YES
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like regular Qt-style comments 
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will 
+# interpret the first line (until the first dot) of a Qt-style 
+# comment as the brief description. If set to NO, the comments 
+# will behave just like regular Qt-style comments (thus requiring 
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Java. For instance, namespaces will be presented as packages, qualified 
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL 
+# sources. Doxygen will then generate output that is tailored for 
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it parses. 
+# With this tag you can assign which parser to use for a given extension. 
+# Doxygen has a built-in mapping, but you can override or extend it using this tag. 
+# The format is ext=language, where ext is a file extension, and language is one of 
+# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, 
+# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat 
+# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), 
+# use: inc=Fortran f=C
+
+EXTENSION_MAPPING      = 
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want 
+# to include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also make the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to 
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. 
+# Doxygen will parse them like normal C++ but will assume all classes use public 
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter 
+# and setter methods for a property. Setting this option to YES (the default) 
+# will make doxygen to replace the get and set methods by a property in the 
+# documentation. This will only work if the methods are indeed getting or 
+# setting a simple type. If this is not the case, or you want to show the 
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum 
+# is documented as struct, union, or enum with the name of the typedef. So 
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct 
+# with name TypeT. When disabled the typedef will appear as a member of a file, 
+# namespace, or class. And the struct will be named TypeS. This can typically 
+# be useful for C code in case the coding convention dictates that all compound 
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to 
+# determine which symbols to keep in memory and which to flush to disk. 
+# When the cache is full, less often used symbols will be written to disk. 
+# For small to medium size projects (<1000 input files) the default value is 
+# probably good enough. For larger projects a too small cache size can cause 
+# doxygen to be busy swapping symbols to and from disk most of the time 
+# causing a significant performance penality. 
+# If the system has enough physical memory increasing the cache will improve the 
+# performance by keeping more symbols in memory. Note that the value works on 
+# a logarithmic scale so increasing the size by one will rougly double the 
+# memory usage. The cache size is given by this formula: 
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = NO
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be 
+# extracted and appear in the documentation as a namespace called 
+# 'anonymous_namespace{file}', where file will be replaced with the base 
+# name of the file that contains the anonymous namespace. By default 
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = YES
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = YES
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = NO
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the 
+# hierarchy of group names into alphabetical order. If set to NO (the default) 
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. 
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = NO
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = NO
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = NO
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= NO
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. 
+# This will remove the Files entry from the Quick Index and from the 
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the 
+# Namespaces page.  This will remove the Namespaces entry from the Quick Index 
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from 
+# the version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by 
+# doxygen. The layout file controls the global structure of the generated output files 
+# in an output format independent way. The create the layout file that represents 
+# doxygen's defaults, run doxygen with the -l option. You can optionally specify a 
+# file name after the option, if omitted DoxygenLayout.xml will be used as the name 
+# of the layout file.
+
+LAYOUT_FILE            = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = "@DOXYGEN_INPUT_DIR@/include/camp" \
+                         "@DOXYGEN_INPUT_DIR@/doc/api/mainpage.hpp"
+
+# This tag can be used to specify the character encoding of the source files 
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
+# also the default input encoding. Doxygen uses libiconv (or the iconv built 
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for 
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.d \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.idl \
+                         *.odl \
+                         *.cs \
+                         *.php \
+                         *.php3 \
+                         *.inc \
+                         *.m \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.f90 \
+                         *.f \
+                         *.vhd \
+                         *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = detail
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names 
+# (namespaces, classes, functions, etc.) that should be excluded from the 
+# output. The symbol name can be a fully qualified name, a word, or if the 
+# wildcard * is used, a substring. Examples: ANamespace, AClass, 
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        = detail
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = "@DOXYGEN_INPUT_DIR@/doc/api/images"
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) 
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from 
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will 
+# link to the source code.  Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = @DOXYGEN_OUTPUT_TYPE@
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = . at DOXYGEN_OUTPUT_TYPE@
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = "@DOXYGEN_INPUT_DIR@/doc/api/header. at DOXYGEN_OUTPUT_TYPE@"
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = "@DOXYGEN_INPUT_DIR@/doc/api/footer. at DOXYGEN_OUTPUT_TYPE@"
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML 
+# documentation will contain sections that can be hidden and shown after the 
+# page has loaded. For this to work a browser that supports 
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox 
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files 
+# will be generated that can be used as input for Apple's Xcode 3 
+# integrated development environment, introduced with OSX 10.5 (Leopard). 
+# To create a documentation set, doxygen will generate a Makefile in the 
+# HTML output directory. Running make will produce the docset in that 
+# directory and running "make install" will install the docset in 
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find 
+# it at startup. 
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the 
+# feed. A documentation feed provides an umbrella under which multiple 
+# documentation sets from a single provider (such as a company or product suite) 
+# can be grouped.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that 
+# should uniquely identify the documentation set bundle. This should be a 
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen 
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = @DOXYGEN_GENERATE_HTMLHELP@
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = ../camp.chm
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = "@HHC_PROGRAM@"
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING 
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file 
+# content.
+
+CHM_INDEX_ENCODING     = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER 
+# are set, an additional index file will be generated that can be used as input for 
+# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated 
+# HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can 
+# be used to specify the file name of the resulting .qch file. 
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               = 
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = camp
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = camp
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. 
+# For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   = 
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see 
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  = 
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's 
+# filter section matches. 
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  = 
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can 
+# be used to specify the location of Qt's qhelpgenerator. 
+# If non-empty doxygen will try to run qhelpgenerator on the generated 
+# .qhp file.
+
+QHG_LOCATION           = 
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 1
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index 
+# structure should be generated to display hierarchical information. 
+# If the tag value is set to FRAME, a side panel will be generated 
+# containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature. Other possible values 
+# for this tag are: HIERARCHIES, which will generate the Groups, Directories, 
+# and Class Hierarchy pages using a tree view instead of an ordered list; 
+# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which 
+# disables this behavior completely. For backwards compatibility with previous 
+# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE 
+# respectively.
+
+GENERATE_TREEVIEW      = NONE
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# Use this tag to change the font size of Latex formulas included 
+# as images in the HTML documentation. The default is 10. Note that 
+# when you change the font size after a successful doxygen run you need 
+# to manually remove any form_*.png images from the HTML output directory 
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = @DOXYGEN_GENERATE_MAN@
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = CAMP_API=
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse 
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links. 
+# Note that each tag file must have a unique name 
+# (where the name does NOT include the path) 
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option is superseded by the HAVE_DOT option below. This is only a 
+# fallback. It is recommended to install and use dot, since it yields more 
+# powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc 
+# command. Doxygen will then run the mscgen tool (see 
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the 
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where 
+# the mscgen tool resides. If left empty the tool is assumed to be found in the 
+# default search path.
+
+MSCGEN_PATH            = 
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# By default doxygen will write a font called FreeSans.ttf to the output 
+# directory and reference it in all dot files that doxygen generates. This 
+# font does not include all possible unicode characters however, so when you need 
+# these (or just want a differently looking font) you can specify the font name 
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font, 
+# which can be done by putting it in a standard location or by setting the 
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
+# containing the font.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. 
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the 
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a 
+# different font using DOT_FONTNAME you can set the path where dot 
+# can find it using this tag.
+
+DOT_FONTPATH           = 
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then 
+# doxygen will generate a call dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable call graphs 
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then 
+# doxygen will generate a caller dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable caller 
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include 
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif 
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of 
+# nodes that will be shown in the graph. If the number of nodes in a graph 
+# becomes larger than this value, doxygen will truncate the graph, which is 
+# visualized by representing a node as a red box. Note that doxygen if the 
+# number of direct children of the root node in a graph is already larger than 
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note 
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that the size of a graph can be further restricted by 
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, because dot on Windows does not 
+# seem to support this out of the box. Warning: Depending on the platform used, 
+# enabling this option may lead to badly anti-aliased labels on the edges of 
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Options related to the search engine
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = NO
diff --git a/doc/api/footer.html b/doc/api/footer.html
new file mode 100644
index 0000000..78823ff
--- /dev/null
+++ b/doc/api/footer.html
@@ -0,0 +1,7 @@
+            <p style="text-align: center; font-family: monospace">
+                 ::  Copyright © 2009-2010 TechnoGerma Systems France, all rights reserved  :: 
+            </p>
+        </div>
+  </body>
+</html>
+
diff --git a/doc/api/header.html b/doc/api/header.html
new file mode 100644
index 0000000..3f54d91
--- /dev/null
+++ b/doc/api/header.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+    <head>
+        <title>CAMP  reference documentation</title>
+        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
+        <link href="./doxygen.css" rel="stylesheet" type="text/css" />
+        <link href="./tabs.css" rel="stylesheet" type="text/css" />
+    </head>
+    <body>
+        <div class="apidoc">
+            <div class="header">
+                <div style="background: url('./tegesoft-bg.png') repeat-x center; margin-bottom: 2em">
+                    <img src="./tegesoft.png" />
+                </div>
+            </div>
+
diff --git a/doc/api/images/logo_camp.png b/doc/api/images/logo_camp.png
new file mode 100644
index 0000000..ecead3b
Binary files /dev/null and b/doc/api/images/logo_camp.png differ
diff --git a/doc/api/images/tegesoft-bg.png b/doc/api/images/tegesoft-bg.png
new file mode 100644
index 0000000..4ea7b6b
Binary files /dev/null and b/doc/api/images/tegesoft-bg.png differ
diff --git a/doc/api/images/tegesoft.png b/doc/api/images/tegesoft.png
new file mode 100644
index 0000000..4295c70
Binary files /dev/null and b/doc/api/images/tegesoft.png differ
diff --git a/doc/api/mainpage.hpp b/doc/api/mainpage.hpp
new file mode 100644
index 0000000..8ebf8e8
--- /dev/null
+++ b/doc/api/mainpage.hpp
@@ -0,0 +1,143 @@
+/*! \mainpage CAMP C++ library documentation
+ *
+ * \htmlonly
+ * <div class="logo">
+ * \endhtmlonly
+ * \image html logo_camp.png
+ * \htmlonly
+ * </div>
+ * \endhtmlonly
+ *
+ * \section overview Overview
+ *
+ * CAMP is a C++ library which provides runtime reflection for types.
+ * It provides an abstraction for most of the high-level concepts of C++:
+ *
+ * \li Classes
+ * \li Enumerations
+ * \li Properties
+ * \li Functions
+ * \li Objects
+ * \li Variables
+ *
+ * By wrapping all these concepts into abstract structures, CAMP provides an extra layer of
+ * flexibility to programs, and allow them to fully expose their data structures at runtime.
+ *
+ * Many applications can take advantage of CAMP, in order to automate tasks which would
+ * otherwise require a huge amount of work. For example, CAMP can be used to expose and edit
+ * objects' attributes into a graphical user interface. It can also be used to do
+ * automatic binding of C++ classes to script languages such as Python or Lua.
+ * Another possible application would be the serialization of objects to XML, text or
+ * binary formats. Or you can even combine all these examples to provide a powerful
+ * and consistent interface for manipulating your objects outside C++ code.
+ *
+ * \section example Quick example
+ * 
+ * Here is a simple example of how to use CAMP:
+ *
+ * \code
+ * #include <camp/camptype.hpp>
+ * #include <camp/class.hpp>
+ * #include <string>
+ * #include <iostream>
+ * 
+ * // Let's define a class for handling persons
+ * class Person
+ * {
+ * public:
+ * 
+ *     // Construct a person from its name
+ *     Person(const std::string& name) : m_name(name), m_age(0)
+ *     {
+ *     }
+ * 
+ *     // Retrieve the name of a person
+ *     std::string name() const
+ *     {
+ *         return m_name;
+ *     }
+ * 
+ *     // Retrieve the age of a person
+ *     unsigned int age() const
+ *     {
+ *         return m_age;
+ *     }
+ * 
+ *     // Set the age of a person
+ *     void setAge(unsigned int age)
+ *     {
+ *         m_age = age;
+ *     }
+ * 
+ *     // Make a person speak (tell about its name and age)
+ *     void speak()
+ *     {
+ *         std::cout << "Hi! My name is " << m_name << " and I'm " << m_age << " years old." << std::endl;
+ *     }
+ * 
+ * private:
+ * 
+ *     std::string m_name;
+ *     unsigned int m_age;
+ * };
+ * 
+ * // Make the Person type available to CAMP
+ * CAMP_TYPE(Person)
+ * 
+ * 
+ * int main()
+ * {
+ *     // Bind our Person class to CAMP
+ *     camp::Class::declare<Person>("Person")
+ *         .constructor1<std::string>()
+ *         .property("name", &Person::name)
+ *         .property("age", &Person::age, &Person::setAge)
+ *         .function("speak", &Person::speak);
+ * 
+ *     // Retrieve the metaclass by its name
+ *     const camp::Class& metaclass = camp::classByName("Person");
+ * 
+ *     // Use the metaclass to construct a new person named John
+ *     camp::UserObject john = metaclass.construct(camp::Args("John"));
+ *
+ *     // Print its name
+ *     std::cout << "John's name is: " << john.get("name") << std::endl;
+ *
+ *     // Set its age to 24
+ *     john.set("age", 24);
+ *
+ *     // Make John say something
+ *     john.call("speak");
+ * 
+ *     // Kill John
+ *     metaclass.destroy(john);
+ * 
+ *     return 0;
+ * }
+ * \endcode
+ *
+ * \section license License
+ *
+ * CAMP is distributed under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version of the License, or (at your option) any later version.
+ *
+ * \verbatim
+ * Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+ * Contact: Technogerma Systems France Information (contact at technogerma.fr)
+ * 
+ * This file is part of the CAMP library.
+ * 
+ * CAMP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * CAMP 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 Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+ * \endverbatim
+ *
+ */
diff --git a/doc/images/logo_camp.ai b/doc/images/logo_camp.ai
new file mode 100644
index 0000000..8cd5c41
--- /dev/null
+++ b/doc/images/logo_camp.ai
@@ -0,0 +1,2207 @@
+%PDF-1.5
%����
+1 0 obj
<</Metadata 2 0 R/OCProperties<</D<</ON[5 0 R 6 0 R]/Order 7 0 R/RBGroups[]>>/OCGs[5 0 R 6 0 R]>>/Pages 3 0 R/Type/Catalog>>
endobj
2 0 obj
<</Length 38723/Subtype/XML/Type/Metadata>>stream
+<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
+<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 4.2.2-c063 53.351735, 2008/07/22-18:11:12        ">
+   <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+      <rdf:Description rdf:about=""
+            xmlns:xmp="http://ns.adobe.com/xap/1.0/"
+            xmlns:xmpGImg="http://ns.adobe.com/xap/1.0/g/img/">
+         <xmp:CreateDate>2009-07-09T14:37:09+02:00</xmp:CreateDate>
+         <xmp:ModifyDate>2009-07-09T14:37:09+02:00</xmp:ModifyDate>
+         <xmp:CreatorTool>Adobe Illustrator CS4</xmp:CreatorTool>
+         <xmp:MetadataDate>2009-07-09T14:37:09+02:00</xmp:MetadataDate>
+         <xmp:Thumbnails>
+            <rdf:Alt>
+               <rdf:li rdf:parseType="Resource">
+                  <xmpGImg:width>256</xmpGImg:width>
+                  <xmpGImg:height>84</xmpGImg:height>
+                  <xmpGImg:format>JPEG</xmpGImg:format>
+                  <xmpGImg:image>/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA&#xA;AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK&#xA;DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f&#xA;Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgAVAEAAwER&#xA;AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA&#xA;AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQV [...]
+               </rdf:li>
+            </rdf:Alt>
+         </xmp:Thumbnails>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:dc="http://purl.org/dc/elements/1.1/">
+         <dc:format>application/pdf</dc:format>
+         <dc:title>
+            <rdf:Alt>
+               <rdf:li xml:lang="x-default">logo_camp</rdf:li>
+            </rdf:Alt>
+         </dc:title>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:xmpMM="http://ns.adobe.com/xap/1.0/mm/"
+            xmlns:stRef="http://ns.adobe.com/xap/1.0/sType/ResourceRef#"
+            xmlns:stEvt="http://ns.adobe.com/xap/1.0/sType/ResourceEvent#">
+         <xmpMM:InstanceID>uuid:3dbdbe8b-bf1e-4dff-871e-1be14201f344</xmpMM:InstanceID>
+         <xmpMM:DocumentID>xmp.did:A75B6832856CDE11819AEBADE2D71138</xmpMM:DocumentID>
+         <xmpMM:OriginalDocumentID>uuid:77d8ee78-6a30-11de-ae5b-0014513219d8</xmpMM:OriginalDocumentID>
+         <xmpMM:RenditionClass>proof:pdf</xmpMM:RenditionClass>
+         <xmpMM:DerivedFrom rdf:parseType="Resource">
+            <stRef:instanceID>uuid:d3c8b5db-b334-47b7-bfe5-94bbb74fa14a</stRef:instanceID>
+            <stRef:documentID>xmp.did:0BD1F0892A6ADE11A971ABF2B6B780D9</stRef:documentID>
+            <stRef:originalDocumentID>uuid:77d8ee78-6a30-11de-ae5b-0014513219d8</stRef:originalDocumentID>
+            <stRef:renditionClass>proof:pdf</stRef:renditionClass>
+         </xmpMM:DerivedFrom>
+         <xmpMM:History>
+            <rdf:Seq>
+               <rdf:li rdf:parseType="Resource">
+                  <stEvt:action>saved</stEvt:action>
+                  <stEvt:instanceID>xmp.iid:0AD1F0892A6ADE11A971ABF2B6B780D9</stEvt:instanceID>
+                  <stEvt:when>2009-07-06T15:57:48+02:00</stEvt:when>
+                  <stEvt:softwareAgent>Adobe Illustrator CS4</stEvt:softwareAgent>
+                  <stEvt:changed>/</stEvt:changed>
+               </rdf:li>
+               <rdf:li rdf:parseType="Resource">
+                  <stEvt:action>saved</stEvt:action>
+                  <stEvt:instanceID>xmp.iid:0BD1F0892A6ADE11A971ABF2B6B780D9</stEvt:instanceID>
+                  <stEvt:when>2009-07-06T16:00:35+02:00</stEvt:when>
+                  <stEvt:softwareAgent>Adobe Illustrator CS4</stEvt:softwareAgent>
+                  <stEvt:changed>/</stEvt:changed>
+               </rdf:li>
+               <rdf:li rdf:parseType="Resource">
+                  <stEvt:action>saved</stEvt:action>
+                  <stEvt:instanceID>xmp.iid:A75B6832856CDE11819AEBADE2D71138</stEvt:instanceID>
+                  <stEvt:when>2009-07-09T14:36:59+02:00</stEvt:when>
+                  <stEvt:softwareAgent>Adobe Illustrator CS4</stEvt:softwareAgent>
+                  <stEvt:changed>/</stEvt:changed>
+               </rdf:li>
+            </rdf:Seq>
+         </xmpMM:History>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:xmpTPg="http://ns.adobe.com/xap/1.0/t/pg/"
+            xmlns:stDim="http://ns.adobe.com/xap/1.0/sType/Dimensions#"
+            xmlns:xmpG="http://ns.adobe.com/xap/1.0/g/">
+         <xmpTPg:NPages>1</xmpTPg:NPages>
+         <xmpTPg:HasVisibleTransparency>False</xmpTPg:HasVisibleTransparency>
+         <xmpTPg:HasVisibleOverprint>False</xmpTPg:HasVisibleOverprint>
+         <xmpTPg:MaxPageSize rdf:parseType="Resource">
+            <stDim:w>209.999929</stDim:w>
+            <stDim:h>296.999959</stDim:h>
+            <stDim:unit>Millimeters</stDim:unit>
+         </xmpTPg:MaxPageSize>
+         <xmpTPg:PlateNames>
+            <rdf:Seq>
+               <rdf:li>Cyan</rdf:li>
+               <rdf:li>Magenta</rdf:li>
+               <rdf:li>Yellow</rdf:li>
+               <rdf:li>Black</rdf:li>
+            </rdf:Seq>
+         </xmpTPg:PlateNames>
+         <xmpTPg:SwatchGroups>
+            <rdf:Seq>
+               <rdf:li rdf:parseType="Resource">
+                  <xmpG:groupName>Default Swatch Group</xmpG:groupName>
+                  <xmpG:groupType>0</xmpG:groupType>
+                  <xmpG:Colorants>
+                     <rdf:Seq>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Blanc</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Noir</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>100.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Magenta</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>100.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Rouge</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>100.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Cramoisi</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>26.999998</xmpG:cyan>
+                           <xmpG:magenta>94.000000</xmpG:magenta>
+                           <xmpG:yellow>94.000000</xmpG:yellow>
+                           <xmpG:black>25.999999</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Orange</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Pche</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>2.999997</xmpG:cyan>
+                           <xmpG:magenta>25.999999</xmpG:magenta>
+                           <xmpG:yellow>81.000000</xmpG:yellow>
+                           <xmpG:black>4.000002</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Crme anglaise</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>13.000000</xmpG:magenta>
+                           <xmpG:yellow>63.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Jaune</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Citron vert</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>32.999998</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>72.999996</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Sauge sŽchŽe</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>36.000001</xmpG:cyan>
+                           <xmpG:magenta>10.000002</xmpG:magenta>
+                           <xmpG:yellow>47.000003</xmpG:yellow>
+                           <xmpG:black>1.999998</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Vert</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>80.000001</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Fort</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>90.000004</xmpG:cyan>
+                           <xmpG:magenta>30.000001</xmpG:magenta>
+                           <xmpG:yellow>90.000004</xmpG:yellow>
+                           <xmpG:black>17.000002</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>MŽditerranŽen</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>100.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>30.000001</xmpG:yellow>
+                           <xmpG:black>5.000001</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Bleu intense</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>45.999998</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Cyan pur</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>100.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Bleu nuit</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>100.000000</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Ardoise</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>30.000001</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>42.999995</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Petite pervenche</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>42.999995</xmpG:cyan>
+                           <xmpG:magenta>27.999997</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Prune</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>50.000000</xmpG:cyan>
+                           <xmpG:magenta>90.000004</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Lavande</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>18.000001</xmpG:cyan>
+                           <xmpG:magenta>45.999998</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Rose bonbon</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>25.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Bisque</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>6.999999</xmpG:cyan>
+                           <xmpG:magenta>24.000001</xmpG:magenta>
+                           <xmpG:yellow>37.000000</xmpG:yellow>
+                           <xmpG:black>1.999998</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>CafŽ au lait</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>25.000000</xmpG:cyan>
+                           <xmpG:magenta>41.999996</xmpG:magenta>
+                           <xmpG:yellow>48.000002</xmpG:yellow>
+                           <xmpG:black>11.000001</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Malt</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>32.999998</xmpG:cyan>
+                           <xmpG:magenta>44.000000</xmpG:magenta>
+                           <xmpG:yellow>53.999996</xmpG:yellow>
+                           <xmpG:black>19.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Moka</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>42.999995</xmpG:cyan>
+                           <xmpG:magenta>51.999998</xmpG:magenta>
+                           <xmpG:yellow>80.000001</xmpG:yellow>
+                           <xmpG:black>38.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Pigeon</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>30.000001</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>CuirassŽ</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>69.999999</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Noir global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>100.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Rouge global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>100.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Orange global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Jaune global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Citron vert global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>32.999998</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>72.999996</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Vert global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>80.000001</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Bleu global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>45.999998</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Nuit global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>100.000000</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Petite pervenche global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>42.999998</xmpG:cyan>
+                           <xmpG:magenta>28.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Prune global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>50.000000</xmpG:cyan>
+                           <xmpG:magenta>90.000004</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Rose gobal</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>25.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>Malt global</xmpG:swatchName>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:tint>100.000000</xmpG:tint>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:cyan>32.549998</xmpG:cyan>
+                           <xmpG:magenta>44.309998</xmpG:magenta>
+                           <xmpG:yellow>53.729999</xmpG:yellow>
+                           <xmpG:black>19.610000</xmpG:black>
+                        </rdf:li>
+                     </rdf:Seq>
+                  </xmpG:Colorants>
+               </rdf:li>
+            </rdf:Seq>
+         </xmpTPg:SwatchGroups>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:illustrator="http://ns.adobe.com/illustrator/1.0/">
+         <illustrator:Type>Document</illustrator:Type>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
+         <pdf:Producer>Adobe PDF library 9.00</pdf:Producer>
+      </rdf:Description>
+   </rdf:RDF>
+</x:xmpmeta>
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                           
+<?xpacket end="w"?>
+endstream
endobj
3 0 obj
<</Count 1/Kids[8 0 R]/Type/Pages>>
endobj
8 0 obj
<</ArtBox[211.684 483.535 446.224 558.769]/BleedBox[0.0 0.0 595.275 841.89]/Contents 9 0 R/LastModified(D:20090709143709+02'00')/MediaBox[0.0 0.0 595.275 841.89]/Parent 3 0 R/PieceInfo<</Illustrator 10 0 R>>/Resources<</ExtGState<</GS0 11 0 R>>/ProcSet[/PDF/ImageC]/Properties<</MC0 5 0 R/MC1 6 0 R>>/XObject<</Im0 12 0 R>>>>/Thumb 13 0 R/TrimBox[0.0 0.0 595.275 841.89]/Type/Page>>
endobj
9 0 obj
<</Filter/FlateDecode/Length 1641>>stream
+H���ˊ%E���������
�
.|��:`�2
+���Y�n9�:�Y�?��z��y}����o><�˗%��R+k)ݕ���\��X���4�w��5��z�kIՍ�>�w
/,�J\KL���	�4��"��Ka�y
�c5oW����X(�UT��Rok�����ӵIN����‹-��$��b������nz�o�pW�F����O�n�9�+�^���Iy����]-�D"{�<��]�y� /��V��\������4��������;�y��G����Ҫ���������@K
]5���{��4z!�����W�~�c�������:`#
n����fʛް�v���4�R
+��q�7�﫽��l?�eװ����[�<�ŷuk.��n�T�t��ei!�s?%ızj;%�+5��}!R*��E�����O������f$θ*�,���H���M{����TЃ��M�P+sԻh �]&�Dؼݐ�:m�8Q�-����h1ԯ}��>�%\"9Jy&g�w=��Ə�������!Z�1^�	�*l_,9�������pնd��
%��n���r�K��'d54�O�T��vK#�H�rVE�B��2Tp�f���R�lV��\��_ �MnI':K���g
�7T�pi �����ɬ���� Ú�.�B�rP����
+�ҹ �r
TJӡ��ȝa� \(�
+U���פ��~
K�_O���8Ϫ�۩����<
 ]��
�@d�Vl�ǿ
�=]���pa�[��Dy�]��ŝ�,� �!�C�+�8��Q�x,5����ƺ�ݬ�`�@���i�M����	��LI��OI����]ϓ�X��K���@�yj6�� ق���#kk�=���r{��1O �To��غ��2�]�^2��
+�I9�� ���D�d["�#ٖM�H>�<�ǨW�KvШ�g*Þ��C�vz;R�A~Eݳ;!��-ݝJLzK��FAW�i�T
oldM�
z
��d�̆�uFG�����
�C��)
+8}�P%tX��m5^���P�D��@i3�<��f�RO�:�%���Wk~
��yo�����5��/��#ti�;2�N�`�&j�%�C0X�u#A���oÕh��$������Oh� ���b[o\�F�3W�P�M7
!�P��
�I�x7^�Ԯ\��
N�2-�n�}Yp���"���)���N�i�)�=�]�g�Az�Z�������*F��� �m���hb�y���6p<�C�t�/t`�/3��n��W���O�q{���h
M���U����wxo�
`������T[E���O�N��5q4~��(C��*��N�I��7��+�������rGd3%9����.N�74z�Y
'���ü
�B��
�V�����F� }����0�#v�i��[
ǽ�,�*w�ا�B`t
&FR�7l΅R`ɫ�_ߵb������f\����щU�`D��so�=�l�������V/
��^���vr��X��ъ<��wY:!%M	��j�
��!'�E% �=��(ۛ���Ζ� �e9?��کvc3��r�&�b�W!� ��x5��Pe
�t�?�9~��F�������h���:< ����+�X�z8g
���%��V����-�~�S�i~����kK�� |��s
+endstream
endobj
13 0 obj
<</BitsPerComponent 8/ColorSpace 14 0 R/Filter[/ASCII85Decode/FlateDecode]/Height 105/Length 175/Width 74>>stream
+8;Z][Yn;UB%#&+!P>7D+nM%,a0S(^sBV!6(iekpu`9%#=1,O=OYWDgb!:ZK<=;A3r
+F'B6`a#'i:MMeu;][(Ma%gl0+ at p(t4Eca)%o3^$h0tWBWY10+m;'41sbah?h7.d*@
+0CtKdV3fX-[hSR8X]i%d\TXs*'fc6ozpu4F:Yj3rZ~>
+endstream
endobj
14 0 obj
[/Indexed/DeviceRGB 255 15 0 R]
endobj
15 0 obj
<</Filter[/ASCII85Decode/FlateDecode]/Length 428>>stream
+8;X]O>EqN@%''O_@%e@?J;%+8(9e>X=MR6S?i^YgA3=].HDXF.R$lIL@"pJ+EP(%0
+b]6ajmNZn*!='OQZeQ^Y*,=]?C.B+\Ulg9dhD*"iC[;*=3`oP1[!S^)?1)IZ4dup`
+E1r!/,*0[*9.aFIR2&b-C#s<Xl5FH@[<=!#6V)uDBXnIr.F>oRZ7Dl%MLY\.?d>Mn
+6%Q2oYfNRF$$+ON<+]RUJmC0I<jlL.oXisZ;SYU[/7#<&37rclQKqeJe#,UF7Rgb1
+VNWFKf>nDZ4OTs0S!saG>GGKUlQ*Q?45:CI&4J'_2j<etJICj7e7nPMb=O6S7UOH<
+PO7r\I.Hu&e0d&E<.')fERr/l+*W,)q^D*ai5<uuLX.7g/>$XKrcYp0n+Xl_nU*O(
+l[$6Nn+Z_Nq0]s7hs]`XX1nZ8&94a\~>
+endstream
endobj
12 0 obj
<</BitsPerComponent 8/ColorSpace/DeviceCMYK/DecodeParms<</BitsPerComponent 4/Colors 4/Columns 156>>/Filter/FlateDecode/Height 154/Intent/RelativeColorimetric/Length 19097/Name/X/Subtype/Image/Type/XObject/Width 156>>stream
+H��T��
ǟ��_��}���KM�t�Hb����  �������Q$m���J�j��if��l?Z�jٴ��IWg��l�m����G�܎��>���y��\ĭ��]��9�s
�?
�~_���0"�s����9 `
�}��O2���F�(`�EK%,E�`)f+*ص����,	
O0s�0�j�Dņ�O�L�A�'C�hc��l\��6DK����E���/fc�u��L`����s�81���5l���M4�٤�F�he�V;K5g)�
�?/2}`��~�5�2аd#^L4F�I��"v20�m�rYCm��mi���
��Z�a.!�2��Y����bS��,�Z��M�^ʆ�$�:2������X�p#N�q�
�L�;�f-AL�Y�d�
�h��Ҷ
��x�
+4�Ɂ,;��u�\��]�
+�
�к�ɍ�@~���Y,fP�s/�L�K�����{e
uM{(�6=�9
:t
=t� 5繬9>���-�4k�m����[2Vh�̋�&>]�ί�w�n�Y��X���p,��/��,�J��?BL������c��G���%���Y��i�!�UkU�ՠi����
�C�̖C�u��u��"k�$��5^�n޾�m��n>S�{�M��Ņ�c���
�M�g�i��4kb���4�j�=8Ke�.g��Yh/hf���4�k����j;�u���'�,�7oy����\msx�%��r�>[>�s �]��pl��{�`���HӴ��kAβ���;�DQ=� ��z��
}s2��
+W�r�5vV��?o �n��6M���Vb�D~ãm[y��M�m��v�m����Y{x���E��
+����0j�`�J�f�Y:iZ��i�^��F�<�2p�
-r|�9z��-s�"�V_�n�D
˗\-
elq�
d�.>x�!�%��巈�
+k�������G���
����A�
"݌�e-ޏz�d4�4���&pF=���K�/���ٙ,ȗ����͕���-/_�1�O��P�
b
}t����T�����*�
>_>ʫ�>^-����/��72����p�7=DӼ] Q���Ή}�Z1��f���.c�r��7j�l��,m!�*%���D=�����Y���i�4k�����KQې�r?��Z=�k��9f�pΗ�8����鞎w��t�"�lj�$�l���E�1��B蔨]�V���<�Ѭ< ��3��	ם��R_�5����k�~��mӼ�#��|��.��?����;l�_����
�i!�ikZ���7G�
`-�:���D�L���l�\�
+!�~�Iz�lQ�&4
{��*�q�;\�!�Ze�'m�R�I��ɽ�n�l6�z�r��ZI��Y�
�}��P>I��(��b�
����/�h��i�{^��;�<�s�㝞.�"fR>/�YF�b�,;��r�.�Y�Ⱥ���=��v��#3
Ac��A^���K�s���zy�׫���}=
�����g�z�/���ʧH���j�O�z�xջ���<>��
[Eڶ�f�ѷ����
��9�{d�w���0J�3� k�тީ3Z��m6��
�ͬ@3��vвn�dE��1�Y�@gv���/��ų]����2_����:kUo����ż�6kS�1�e+�1�V�[�N��
֨~�}	X<B| ��Q��1�.��O���f6�q�n��Z|�['�y��w������a�>��r��1��3��i�މޙ,Jlffl�Y
=���l
q��q��JZ�>�g\:Tg�T��7�W�r�K���l�z��R���#�Nu
+����Z����cؿ��!_��c�Js�
lVlj�F�9��ϑ7�f�v֨�y4�k䥘��=��<1�T
%��+
�c�>��ib�õ��z��S��i��\v
�$��z'f4蛓�`>Ӝ�N�a&�<���z�:�"_�:	���:b>$~:է�-y�
�g�Z���ox
�ϟ��v���A�~o��	�L�Ƶ��hk�͞�}6���y)<�H=C����
�ߋF���^���
tF����Ym�
�Y|��Mq5
��XQ�9�:gft3���l����oZwQ���
&�B���a҇�:�
� -;��&�����t��Μ���e������������‘_�?z�
+�e�g�Qd�4���=��A������������8�o^�a�����]�CYM�z�
8�g����ii&���lz't�<�ͧ���6��L�&�w�$�3������b$�e��LyY��u���� ����
�}�r_�<�зQ��{�<����w8{���
+:W�HC�|����*�`���<�7<��wA
�v��Y���tN�DM��j�SNӚ���I���f��]�Q�ݨ���|����Hϴo��u錫S=9띯�罯s���;��P���o�'Br
z-�/�W�Vޏ�5�~�
���ߟf����c� F
���3����)�@N�g�?K!�U��99M��i��[�w:M
�3³i�oR�Z��g�YP�N���Y9��:u>�;�r�)ϣw�Z���k�GI�0��p����z�~�~C]�9�_
���Ӄ��Ωwq��DC�����2��=3�� �u at N�
+�n��Y��
+k'���({�&PF��w������xf�y��߱��/�}�eo�9�}����k'�{���
9jr�üv��#/%}{�7y�x�y���ʘ?r�I��pk�
dM���YfH'H�F�(��:� �
��\��ʛy��4�~д��P�ó�l�
+>C���󣐌F���>d����v��֩��{g6ȵ�i�y�Y�����]�CߍV�W���D��e��^���񆚽L
�ě:I�#��{nVH����x���DŒg:�����g��?Ǜ
�D�
�����Hn���ϖRN��s�
����$�L`���8�Ιa&3���s;Xe)���e��,�3� �"��}��m�M�Ucc5M���K,�5���J�ф�Vc�4�`��
+�����sν�ݹ��<�79y�޻�ν���9�֋s
5MwN�+3�et��̆,����:ͷ�
�_���*�I�d��7a
5��.��L}>5o���:���ۣxb����8ZuT����[�P�]�?�Y��n'��
�s����bu���ϩ{.p1�
�L�]
sZxJ��4��
���Զl}4��!�g]ޓΐ�Ǟ�U����v�Sh�V��I������M�T�v��>;����GY��;�G�[
�e��.fV��SV\�
X���9V�瓜Q'@�\$�D�FwO��'\?��׳閛��}嫦��	c��93�)�C/��R	�a�l�sw�z�d�
�OOH�\�[�נ9P�apɆ�K�Das�L흝��*ֆC/�V��쉐�f���B`m��PV�<B�s��k���
��F�	y[�m�in]��u�(53q����5F�֡�.��A@�t�E�E����81��mm���o�y��_Ϣ�^�z��5�3�蟝���0�A/`=l��d��A�+!�mbwQV{��j�CV�
�,�s��38�f>���u��gq9-�ca����
����U�4�:蝘Ϩǂ��!�ޤ�Z��
��=wʛ
�7���>�Y<-�ܐCd�&;��հ��^�Ǟ�؋������C�`�������/��˔��cd�<Kk����sP��xk��Q�%������[}
�O1"���i�aI�9�c�"��u�x�x����P��g�6����7sv�R�蝤iȚ=�A�c�f��V�U���
�	��+^�Z��k�WT'�Q��b�wf{���0��gv�����sI�>� ;�i����}�|_5o^���x-��-�zޮ�����
����2��� [...]
�e�K��j���c�3b����@3<��m+2��3^�_�kL��#������f
c8��f݋+�����Z��J`m+�p����;h�޷F��h�hP�>`��?���ӿl�1�Z�Q��:�>!����rπν���W��3��\��r��[���Z��c_
��Zݔ�IM�
t�nU��e�F
��2�І��汆s��
Qc�k
q��\s߷�uP���U�kG]3N��h�G��d�;O]��C֤����r�`on
x�歶Y}�
�ƹ��
-�nM��uV
�+��6^�f���5�4�'$kˀ���8y�fm�b-�C�X��&�A]�Ӷl�/���<�FS�$s�9��V�C�
+
�wx��
�,�
k�`���Z�0g�57��p
+���{�����[ckS��=u�d�tM���Lf�+s�]QzczZ��E�Y_I]6n��?)?z�m��s�_/P���QG5xCn7����5�����
]��_)��m�șd
{�]�d��5�
(Y���"���
�����E�W3t
Yì���g�.r]˜
c/_��ܤs��8��{0���:�|3ӡ�k�
C%��u��
�����ۦ���;�eu`?�`�K��I�
�VfO��ٳ@�k��pg#�6A<�X;�t
���=T�ZgIkn�c�&�<Fe�l��ӧ(���]C��s���g��v?�9�ܝ�n��+�A�\W�7�R
�[^����zފ�Ǹ���5N�G[�k��lt���Yo{&�o/�V k5l���Nj��T�S>�=�����J�hF^
zh��4f��7s��x�q��A���dM���^����E�;��'��K~�ѷ
-$o�Z]ϛ�~��nA�f����nV9�
+փz(��L6@���t�������&��
܃|��
+��Q���3���Z�0���E8�6�%q����~_�j��2���:��.k8���龀���v��������7i�+�+��&9M+.��Z/k2��=���糁%��P�����X�>��1�����/ k/���?@�ޑ
*.��T5�#̫��'��6&ׇyp���ua
Ey~��er'y�B{U�69Pߤ<U�~j�����E�s�W����7%�Lr��
k�6
X�G�V��tj���|�x
+X��G<ϗ�������m�.���Kk>s�
��²O�������yd6:��Y���=��V�{�A�Aͥ�SuG�e��@���%�^��5_�Ѣ�Tw�M�X�
֬i��5�
���!�k�H��W����>�g���<�
_��X�;_�
�>Ӭ�\i��Ӹ
����42[
Ө��Ώ�4I��9��\��w��I�dzjZy��p�o�
��|���`���U�0AΈ5{2d���� {1uёb3/�����u������W��k�@�?�t͜��l
��Qk��;q����$N�2_�Z�����f��1���7����v��
Z���R����Mp��;��TG��'�d��=X�@�v;��
ꢃJ��.
+���(�9� _(^�.��=�*ݓ�kg�|a�h6��_�zE1�^���$�����S�3D�/�E��5�zśc�tOEO�Π�
�m�mW�샱��K��d�%��Գq�̞ c��v���е�컪�S?�%�����J��w�`ڠ����0����f�$}
+��8�j��&�d��%�gfU���u���e���:�mS
3ܮ6��K�����k�`Hz	�k��	e6�3
e�D�l
+t�i��5��ࣵ|�x�����~	��|�8
����A�{t�cް���W�f$�J'�2��wc�
zd��kG]?��ָ�:�����x���e����Q߀��:���p� 3ԍ>n��R�jZi������=��A�`
�lb��&��)����~p��=�����yɚې�0�	Ӡ���l
�٬o6��iq
�I�u�Z�<
aN�m��j
�H�T~Ӽ��f]���O�P_u
+�)��^��^�5��~��CJW�a��F�
࣏@f�	�-��
܃Ff{���X����s���y�q��e��wa���q~
���׈��l8�]Կ�|�y�����p������u��XW��=ܩ��Si��W;Y��3�iS��k�Eu?�T�;�Z^>:��/�e
�u���]�q
D�4
1g ����9�đq0���90`��D at Q�D�*�T�4��F�P�F
+J�V���i"�R�ڰ���
�
�k
�;;;���>����c�3���>�>K��\��Cg���σ.q�Wċ�Kƚ��C�t�Y�m�9�,���&������j|y�X;�/�~�,}�������i��"��sN~�f^�^+�g6�
r�ʘD���f��y� s�����>!k闌5���~����|��7�_��k�X���D���������K�cs8�!o;������i]_�m������\��;����O�
g5<�#�k�2_�>����DsWR���� G?�}�f�
+�����</T�D�
�u�S�i���e���������~]g�-�y~��������!`�~P�˚>�qf���q9�
:2t�1�Aqt�QbV�
����G��e�5G+���n�
m�k���˝��d�!�]��d%ȇ̱�|&[ё�Y<ix�
+3���
���������0
�f�s\��X�l���8
終�"�K���U���>:�փ��B����v�Zv�VZ��ps�ٛ!���[G�{����Us���u�U�WŰ�m�k��(9S�ΰ��
2y�3�~7O�7d���X�ھ�:?�(�
]��ᬖ��/@�.�
]}s�rt'�J��L�D暗|}�5G+��^孇j]��Ԟ=/˦�5e��<�r��e����h����y�Hg8���Ր����������qh<��8n at x\h0��D��E��ё�FQt5��qt+�Q��d�y��@�u�v���J�?vu�5�
HZG<���Q�K������@��y��g�z�L~���6�
W���V�'���
Xk

�����:�Knj�&r�G¼����(s���U�Ӵ�L3�Y�I�[���d�u����Q�e����������t�/�^��T�(�stsQ��Ryf�Y����U�v�o�ێ�G�
�gv�x����7<*T�N�Xe�]t%��:��G'��d���̠��.�n���j�������
� n�D��(�G���g�.'�k��
��Ǔl~�1��O����=�e<�_�lUY�vgȶg8��p��c����x�)�9Zֻ�t�N�S�A!pV.�\��`3�S����p[
y�
��p������an����7�#|^�����m:�.Z+ٺ�ߡ�2��|��"�C�
3�g�q��e���f*�
3��
�3�l鈼��
w�,��`�odžټ���N
�3o�3z�Ff.��3���6:�%`�e`��q�2�֒�Q�m�,t�gද�m7afs;B���I���zC�>xT�$�T���w�w]Vx�f?k�����A�ߎ�5g��ds�D~�Y�mV�{���t�38FCE֊���������[�Its۳ԙ��U�ܶ��:·,G�#���21�9�ϛ(��s�}��EL�r,�
�n���
=��}���w�����������AGM;~��~
+}����;�!_ܓ�2:�C�?����C������ඝ����X�0��l}��Va��ܶ��GE������Ue�jf}&z�:�+{�A�E����?۩�A��d��=�Û;�ag�n7����Q��ڼaW �EOܡ�
�Z����
��!dl��k�lf�
����&9s�Lz��m���d����J�#$�M�>*>x������TY�>�{A�����[ī�=(;�{F�qț;��<��>ޚ KOogF&��}���F���ݠ(s%�{
c����c"���6�6���9���!K��J�:���۬���m���<��-��ڻ�:�Q�s�'e�8
>�蜠���o���R�7g�s;C-�p�vGEގB_@��ې��'����53-+�>Cΰ`
]��(v�qt�㶃d��&�C/�E�W�?�۾0ʭo
�I����R]���Cw
�Ù��{q#/U��y&Uv�A0;�2���vg�ݳ�3 o]
�e`?���T�]zft⡳p�2s�Ty�
*��6�@�٬�}t
�ms[-��y��&�����}p�'d��Wc��@��6�t�B�"�\$�-�wys�.
2v��
+���
�����9�{��������
���XFc��sE��}w��������b�k�r��h��s���L�`n;=�"d��E�C�	�}
������^�1$��y�C5�ދ,�x|����@�"���X�Z�sx���3T�@g�IK'訝��
�

�49��
��B�ܤ���,E�Ƙ��i�k�����m�Dsd�^2�
&�ғ�.����d��1�	�X�"�'XmY���}�ޯȕ"��:��
��t�L�:���,t>�N�p��ΰ
g8�3
�O����|q"��S�n�S�ԞCBO9��qX�
-57��
�����0����9������26X7!Gc^OP9Cg�8@�s*>�q��#��t����t�?e{Vzo�L��P
���[���)�S?o�)��[~d
t�W��r�xs�F��d��L3�Y{�[d�uz��!K?���T��6Rq'��I��"t�9F���}��Ev~p&���r����!�פ����jz�����Nu0���� 
�)�9zx���Bq��ŒD���o�:��uH
!c�v k�Upv�
�i�S�~�	
����<�6d�U�R�	Y1*��I%�����G�}��w�T���a{*
E�OƆNP݇�^��#��b`�c���
:j:�v<�9�Ĉ;&�
c�2�.�M<
I
+y���^����
֪���l��%�Ѓ�'<O�{Y�ʺNʳ���rz�w\�6">x
��u]�t9Uq���,Dz�][v��Z���6�vx�3
㭇͛�Q�3

�D��ƾ�㭠��*��'c�g6���Vb�m�۰'̤'�
��RjgiEַvO`Yo��<����l]SY+W���{��/D�T�������+b�w
��W�
�ߐ�
8���e
���GCG
���p~s��ri"g��c*�Fg��z��͆��k���ۦ�7�t��v��R�*��?{Y��-UG��G" � ���{�2.R�
^f��)�w_��aϔ�L��
���;jo�-�3#���%ୡ�V���p�H��t���`�dnc=�փۚ��sd>�9Yb��류���W>��!�e�S�>D��f��c��Tq�z
��չ�!�U���t�ᰣ� o�����ȅ� 
�xk�o1Oo�O/B?�<.����D���B�zd

+a/`��-���
+s��It����@f�v����2���¸�e����k�n��W�<ք���m6c0!1�T$!i	I!)�
�`l�1�@��̾� *Q)U#���JM�4��-�[�z��㻍���˛wg�}�{ףe�>x�#�KW���\��ͽw��/����d�z�
Ϫ3}W���[ѾE:���*>e}�~��,38x����F;Dy�~
+��o/f��6()�l-��,�!��),�nb�Fs�,��/]�O�W�U��<@o�'��`�F�6Y���_G#dkꞇ컶g9{C�:�%b�7�yY��7��9�y��Y���TWf�	3ܞ̆�}CA�F o����ʊ��~)����
�"��$�꣜��%ȣTۦ�4c+Ӷ\�L/-"���y��S���|
��!���R���ut�T��U�x���l�����f�4�b��BF-���
݈���t���sܓ�"�c�iMYۂ���VN0�� g^Z����
�/��k��
�^�•l-^�t���12>tYT���QQ��j+[C���=���
���
��33�G�mK����
�+G�o�
~
+�����c�S|�
Ů
�G�ܖ�?/-/ݏ��Clv[�/[��_@۾A�ɏV.
Hu\�ӫ_�8Q1��t{B䕪{���Nt���}^�`�[ge�Qw�
+���oHCb�`r�
a�7+/�M�t;;-���yr��'q|
��h��Ma�̤�Ks�X.-$uh	�^
+��ܷ
+�s�m^�C��:~��ν�Lkd����le���[�Ϫއ�
/^ ���T�Q�u
+��`�g��V6��7��S�ۋ&o�Ez.쿲�
7")�G���k���fi[	xi���P>�dv{��Ӛ��~ʫ�J�t�IWt���y
�*e=(�\��껎�{�eT+3l�x�ݯ!~/��������F-���S��X��u�p�6>�u��Ե-��������h�Qü��\@��9��|������-9sQ_�������2-u�����8u�A���Ϝ�v���&����\[��:?���2*��2­)o����
ؐP1,�t��66��x������^���y���]L׶4Ѷ\\^Z	�բ��	6��{0�=���|�ݚ{�Nmt4�
�:�cM�cDk��U��:�'��no�T��ZQ}����ь
+��
�F��ào�,?��v>��w��p_'k��ƙ�Q�2]��;��],'�a3��7��B|�������0�=���-���s~�y�Nݽ~_g}�����C�������Uƈ�Z�>�>����̨��[o�v�1y+�x�`��	�7з���C
�!��?��O�����Rm��{��
+ȥ�0�
g��L��`v�·�<�j�j���^Y��h��\e�����(�^{A�����jī��<dg���.�vR�2A��&o��������Ŝp���g��y�4�gsFu��f�V�ҹ���^��Y�m�Wз����dLy�*/�);��x�k-ٓno�eς�����5�S�u?}����n�6;{o������5��u��6���(����������̙mWm�^������$�n�0��5������u��sV�Ͳ*���[�|�vȴP��ek��Q�&�7E��GE���A�
l�m�6����m���>s~�P���:k~�������ml�R��if
-�r�^4���Uo0��:��.���
ZA>5�n��%�P���LT�T���|e
��<W��d<���
+��ݹG�q����_ӌ
+���k�7�oU#�
����S��v)74`��;ь:�j��k���
�
x���f�ch>�]E��}Ȧ�o�x
p�'�T�$�L�����E�+*vEL��Ui��V��.�
�>UψfT�m��f�[�@����o��(o�����Ny��ʼ:;8��֮U|\���&k�G�}L�f��[-����U|f��M�@V���
+���J�x����]Oљ��A�=Zr���E}���:\�������ڦo�I3y��3ض��鐆�#b��t�F�����v��R����,��=��\6��rB5�o
A
�	�
+��5r-��)���
+�z����^��z.�7U��?s������|H�W���i�J�EuR��b^�\��Ey���-ж�lpC{�7�Om��g��R}�6'��:�&t���I9��f�[�v��Rꥅ����Ͳ�ʔ���-~/��w]�\��b\G?d���L��:��ڧ��^E��f�������dga��-=ܚ�[��eE����Ay��x}np�4?�L����2�
屋�h�6�؞�̬PL~�����oV6
h��J�����GĆL�T�z26D�+�+�Z��!�x�?�Od�k���>-�j���n�7��j
�f�vuVh�m�����}�1v��1e�� Ӷ||$:����>��'�;)_���G-]�������霃�gd穣�*�e���^ѭ�L�E�j�[��=�Ʃo5��������p����ୂi�顕�G��o0���h	�����h����V6ի��y�8��]G
U^�^C�-K��L�|�:z����9�Sy��=o�Qק:�_����马H:�m&�dS���1%dB�7|1�*��J��<�x�a���h!>	����:Z��y��%��G�l�bLGOD{�+���j��<ut��
�zA��:ϕ՜׋��Қ�M���
&oN}�~j�v1'�����[��Q��n�O4V��w2M3�,�f�Fsi�q�e�"r��-�
+���@߾�fS�6�4AW���n���W�DU�Ζw�^���/{οU}�:�ۺΖ����y�~�x��q)'ԟ�vs~pԮ�7�'�5,Ћ�6Ǡ�Հ��8f7�.1ޖoo�ǾU�;ƛ[
T=�۷���usz�.�-e��l՞E}�ØN��Eի��Q��Z�O7v��4�ml$���ܴHϋ��ۜ������U��Eu̼�����kk�����΢�,��A��?o�oߣ�
ٔ�w�G��@���QMDL鬯{.2�x��tCş{O<�utK��:=����S:�U��x�I;=9�Ay��@����
�
+�?�l�̙�V�|4e���$��yз+�8�.���Ey��|t~s�]vn^?�������w�Z��Gt���s��� �k�j#[C��^}f�)�7G>���o�'E�ꀷ��{]�x�� 4�ޢ��c�gԲ|`�]���\ZH��춄\GK�]��
���
з���ף�3����WU�d^�Eu��������(zO^]E���CU�\l�� Z��O������q��Q޲{_�

��
���1��“(WT���ֵc�\ZHΘ��k��C?'��V���w��z� WU�q<��
+!	焐 DބD��3��P�B���XT(
+$�C��DA�1���:�8N�����v�S���9�����9��~�����{���~���}�����r������_��Q1��&���Z�*�X�a�e�P�o�,O�^�Q�~���#�x?���`������h�}��h��#�>���^�
�8_��A�G=m�N�^�º���	���ۃ �S[X�Lt�d�T��4G��ӰDׄi�6���������������)�
�����h��H�a��3c�U���KOE
�v�Q����1�:��~���e��s�7���w����|�)�)��N{Lx�t�4?t�ӭ
��������kUq�t��c�eU�Y�ۉb�:��M�v�9�
��=��c�Mf�
�[gX�0þ�e�ε����
,�~`�a���nUN��b��Y���K��{:�;S�t�_;�͘`���;�[�~��[^(y{�p�
N��Sކ����ْh��"]�7�V�
�t�[
6�㋏I
k�m����˔���y�����<������ػ��*oM� �-nT��0�խS��:fu{�i6>@�Vd�x[�6\
�֕��ӱ��#CI��#I�M/@o:)�������)�)��`u
����)�'��B�6�����7�s=޸��r�d
��b�2����u����$�:VL�d�\�
��"�l��Z�Q}���mhGy�5��-����k�3�d
����ho
+��o�ݡ�O'O�~U��1���4��stTQ/�u�i�
+��3�o�<o��M�����HY��h
�A��N����֯�k�?$�&L�Ć�x{4ZoC�p������
I{�7��
D��'��
���K�Nqݚ��]
�
�16��#�ӶˬW�mNy�C
�LXӭ�dd9���	*-��cҟ72t��̈́WY���ǘ��ǟci�ok(o)oot
+���
I�߇d@�p���:;����z�G?�������LR
+}'�pUa]
N�/��pX�i]e^��};��5�ӿ��,ǰ���S�/X
d��{�\�N�0�����]b~�����?���
��u��W��uֶ��۔����W80�mz��
+�F�m��E󹗂�ݙA��xھB��e�
+�L8B�A_�3�ms�/�?��x��W�7پ��_֣b���P�J?T
��[��9��c�H4��u�� �c:�eF�~ĭ���9/�p����}�h�6��K�/����
+2���5˾Ey�Ŏ���M�g��)�ѹ���<�����o
���_ء����`9��6���4~2���Q�m���u<bzl�7��s֠v[��כ���Py��H����h��G
+��9�'������ s�/p�g �`<c�a#v�� h�n
�P}
)� �
,�2�����}�*
��ֱ��H����η��!kR�,����Z��{�-��-ۍ�n
�
�u5��ӱ$Y�h_zf�Ӂ�m��~7���o� %��n�Ǽ߾4}gp~Ɵ�n=g�oCǟ[��_�z
����wT۾������Ku�eʚlT9���_�F��y
+�t���Yח��{�j���p֠n[N�j7�K�wv�}i_��0ն�#I����NГ^/w�@?
+�qm�=���Ӟg
-��F�߽��l�`ߣ�~�����
B���
���S�콸/&{-2����H"��� ���W��$'u{.�����ڶ����s�����i�	�m�G��gK�
�>ZA��Y���~�s����c#�Xb�����=�
�Gc}�>��>`k4�}�%̻u��1����O��N�u:��a�]������}>
+u�J�'����
��i����7�4�
|��2�?��8o�8�pVz��
IK|��Z�ЮŒ���S����D;L9��\�
��_&�M4O5W�{t����اkK9k�n��u�O���r�C�I3�#�F
+��5�
��4`��ֳE�:)uӒ�zτ����e�w���1����%���Dţ̻0��i]"^��F��v��Db*�����=��%c֔QU|�
�Y{��Sw]�H�-��������3�4=WͻLk6���������������/�g�7�sWz�ٱk0^�t�,�8\���ȣ��|Ir���7�Q��X,D�U���3ѼP�	�X��m�Ϣ��u��XݔN��x8u�qd(iqv��{�h፩�0�/>n�$�M��+�������XE����E��sv��g
{0�z

+̉
,�=q�b�1���ɾ���f:���`5���t|��F�Ʀ�^�X{����C���棴�����H��S�"�o�>
+G�8o�S�*)[k�7��2Zom�H}�M�y�i��*9����p�=�9l/0�
V�t����.�:�U|�|Q�>6/�%�-1���E�<���֎��)��軃H��Qn�
#]?)w�D��>F~�V�$ߧ<�X
`l}.<X�H�B�{��xw%g��
p�
��Z��Xש�L�i&����cń)
+�=�ƫ�-сi���&����5�7� c�0�j6�>��r����P?o����L>��&�����w
%�^7jB6�b��u`X\Oh h
�;`�k��_1�W�X�U���W]����Ԇ:
Vi#�>S�u�1%����P}�"g
����m1����A1iu�4�X�=����
��9oP��>A���&���

��.�F|l�
b_ϋ�Ǹ�sZ�eZ��;�:Y_��:16��WiI�17��������)���eld9�q��S?�\�8k˩N k�
�_�e�rC��ЃI��Ai��j�3@�e��^�
&������GA�?vt
���
I���{$
�wt
�n�N�9l},�
h-�YQ�#Z'�S�ع,6&z�cO�%����j��N��r����A!f���X�L�
�fOOǢ
�u������]�*H�Ȗ8������k�S�����hc�޷�8�	ר���$���΍{le�(�i�Z�e��ː��*=P鈎!�od>�q��
�#�^W�j��
��Vm��Z
�j���@[��r�C�I��H��^]�
*�h�� ���Y�&��όv;��M���&���
8€k{{����Oĸ��5^C��xOA�n��5zX��=�?t{���ċU����&1Ƙ���a��dm�⿑iZV�?W�T�j[i,AO 懇�槞t�Az}�[�����+��6K�5�Y\p5���$�D�K��@?���
dzG}<t�{l�~"�����X�#0�t~'j�)�&��q)�S
K�w�QV���5QӼ:m�?�6�o�=!�'����0�sf��_������
�0��
+�$��@Rʝ$��p�i��
J�K�3��ijÀb ��TPkG�p��� 
+�A,�[g���?p���~���;ge��>;
�̚sݗ��g���
>��۴"3%�2��j,��8:>�p�����y߄l	�A�}�=�Q�3��s��xfz
+����?Ⱦ!2������`�� wa�L�qI�W!��rْ{&e:��X�!�Ya伳��4��r=����we
�U�Y��\���k�q�Wf�Eyg������E[�ܫ��ꂶ
���<X������`�{��L��N�^���%�1�͚�\�JB�.�\ToV�8����$�v�8])��-�ou�2	�a�N���
���{��i�
�$�Q�k{�&SzfAj�f� [�~T��
+���$��W����d�
���k^�3�
��
���]g���)��lg�
�]]q&�ݺn��",�E�M��<8���
�iIm���B��/�e4�7�wv�g���3��5P��3��i�'M;1�+;��WѴ<S
���F�\~�Xs��+�������̐�ż�s��A��ռ(������+��:����]��^�I�2��Z�o�����q�ӡ��˘�9
g%y={=ζI��e��S2y1�q|Vz�iѴ/DӮ���Y
cL#��j���#vu�hFf }����/���.7L�������ھB�
}s�2��g�v���!���yA����ַ�7s���B�,�Z���x�a��u�7��!�Y��3�
�'����F���y��|V�U^�� �������k%�
4�X2�W
��J?��ls���U��N��?b5��g�
�-�i�n���%�J-���ی����P�_���]Ժ%�%
+�Qn��d�|毮g�i�2���O�
+��
�Z��f^�
g�� �����ia}g
k�W�	���oV�5�xr�W�ɳ�Ps81���k|�\��'��גީ�t�k�
i{Za�h� _��Օ�uo]�=����|7ο�k
���չB�	��_*c���5�N�K=�O�o��>@z7��Uْ
g�^g�F_\�����̌0�Ӵ
+�Is�L�p'Yӣ�뀶;������a�槆���O榺�\aO5�൰��h
{��R#�k�K�أ�$�����(쭷�[g٣�Zg��
��y+�3Q��0-�Ҹ _A
[k�X�+}
�h���d�2�2����#��z�M�	gA��o~����
�-�ѯmk��G�<�楊�Eg�F~�05�9�Y��{�;
�
{�{��<�3��C�<��0�U���7��f=|��ǯw�\j��56����-i��r
v
g0�cAO���8&����r|u����H�+��j�v�̛�o�:l����0&u�~d��ٞ�m<���9��²�0�\�x��0��j��/h��T�'�
{�ۡ��*ȟ��\�G��O��u���
{P��z�
>�>�#��g�x.�'�ݑ�O�W�O���
���0=��`�È>$�c�E�Ӱ����?r#S��O��Y�xn�#���@�/��������%��g�[�)��Ԛ�i9
r�i›<i�����W؁֭�z�����'�X�
����k�q0�@��;����
}��\�)y��3��N�G���
�Q����`�c~�Ć��^��XW��Iԟ
��Mw��֜���ߕ!�(���T�g�����Y<�W<��;�K2-_h>��:Pj���}&�a�Lz j޴<S}uUvv���~��������M�uT�
�����%�^\�~�=�@������l�7^��=5/5��a�^M�wP�.����s��I���{�=?���3�Sć]�J���M
Ա�j#��Jo�䢍��O�҆�{�ռ���c��c�Kr}���q��y����?D�v
+[<;s`>�+��3_�_�xdZ��ƨ��=M��� Q��2橍��*�VM�::�ֽ8�
O�~[ٴ"3�
�;^��<3�����k滒�r�'�������އ
�/��j k�:Ⱥ�9:�	}`
ъf<Z&��~�e��:��*��	̚����s�:x��(�?Կy�g ����o�no��eؒ91��g�d����h}{�g�K���_��Lu�,���̦��w�)_]�]д��gQ��k��{\^������
ٙ�˫23���M�C���V�
�
��*F�����_����V� ����_��#���P�r������PfG��w����z.�k������'�Ϟhƕ<'�L�b�#���̕>
��5���,3Ʈ��քe���u��UԽU{�[y0�?L�/f~�bv���w��/��LG�+����[�=az'��ו��kҥ��&��pY����ƛ�ɧ3F#a��)Zi��0������r���\�k�o�at���6X?���<�3���-r>���fQj [...]
+q�X�v��6�n���Ø;5���;T�� ��֩��a=
+�]R�l�''9?�]�Ǻ���1�~1�֮��#�`}��֔�.‡Ջ
�WK}3i�����yV��>[߯��d���$�N��)L����>'wM܃{�VݫL�_� �`n
+endstream
endobj
5 0 obj
<</Intent 16 0 R/Name(CAMP)/Type/OCG/Usage 17 0 R>>
endobj
6 0 obj
<</Intent 18 0 R/Name(GICS)/Type/OCG/Usage 19 0 R>>
endobj
18 0 obj
[/View/Design]
endobj
19 0 obj
<</CreatorInfo<</Creator(Adobe Illustrator 14.0)/Subtype/Artwork>>>>
endobj
16 0 obj
[/View/Design]
endobj
17 0 obj
<</CreatorInfo<</Creator(Adobe Illustrator 14.0)/Subtype/Artwork>>>>
endobj
11 0 obj
<</AIS false/BM/Normal/CA 1.0/OP false/OPM 1/SA true/SMask/None/Type/ExtGState/ca 1.0/op false>>
endobj
10 0 obj
<</LastModified(D:20090709143709+02'00')/Private 20 0 R>>
endobj
20 0 obj
<</AIMetaData 21 0 R/AIPrivateData1 22 0 R/AIPrivateData2 23 0 R/AIPrivateData3 24 0 R/AIPrivateData4 25 0 R/AIPrivateData5 26 0 R/AIPrivateData6 27 0 R/AIPrivateData7 28 0 R/ContainerVersion 11/CreatorVersion 14/NumBlock 7/RoundtripStreamType 1/RoundtripVersion 14>>
endobj
21 0 obj
<</Length 1410>>stream
+%!PS-Adobe-3.0 
+%%Creator: Adobe Illustrator(R) 14.0
+%%AI8_CreatorVersion: 14.0.0
+%%For: (Laurent) ()
+%%Title: (logo_camp_gics.ai)
+%%CreationDate: 7/9/2009 2:37 PM
+%%Canvassize: 16383
+%%BoundingBox: 211 483 447 559
+%%HiResBoundingBox: 211.959 483.9697 446.2236 558.5903
+%%DocumentProcessColors: Cyan Magenta Yellow Black
+%AI5_FileFormat 10.0
+%AI12_BuildNumber: 367
+%AI3_ColorUsage: Color
+%AI7_ImageSettings: 0
+%%CMYKProcessColor: 0.46 0 0 0 (Bleu global)
+%%+ 0.33 0 0.73 0 (Citron vert global)
+%%+ 0 0 1 0 (Jaune global)
+%%+ 0.3255 0.4431 0.5373 0.1961 (Malt global)
+%%+ 0 0 0 1 (Noir global)
+%%+ 1 0.5 0 0 (Nuit global)
+%%+ 0 0.5 1 0 (Orange global)
+%%+ 0.43 0.28 0 0 (Petite pervenche global)
+%%+ 0.5 0.9 0 0 (Prune global)
+%%+ 0 0.25 0 0 (Rose gobal)
+%%+ 0 1 1 0 (Rouge global)
+%%+ 0.8 0 1 0 (Vert global)
+%%+ 1 1 1 1 ([RepŽrage])
+%AI3_Cropmarks: 0 0 595.2754 841.8896
+%AI3_TemplateBox: 298.5 420.3896 298.5 420.3896
+%AI3_TileBox: 0.142578 -0.045898 595.1328 841.9346
+%AI3_DocumentPreview: None
+%AI5_ArtSize: 14400 14400
+%AI5_RulerUnits: 1
+%AI9_ColorModel: 2
+%AI5_ArtFlags: 0 0 0 1 0 0 1 0 0
+%AI5_TargetResolution: 800
+%AI5_NumLayers: 2
+%AI9_OpenToView: -69 687.8896 2 1627 895 18 0 0 44 116 0 0 0 1 1 0 1 1 0
+%AI5_OpenViewLayers: 77
+%%PageOrigin:0 0
+%AI7_GridSettings: 72 8 72 8 1 0 0.8 0.8 0.8 0.9 0.9 0.9
+%AI9_Flatten: 1
+%AI12_CMSettings: 00.MS
+%%EndComments
+
+endstream
endobj
22 0 obj
<</Length 7329>>stream
+%%BoundingBox: 211 483 447 559
+%%HiResBoundingBox: 211.959 483.9697 446.2236 558.5903
+%AI7_Thumbnail: 128 44 8
+%%BeginData: 7175 Hex Bytes
+%0000330000660000990000CC0033000033330033660033990033CC0033FF
+%0066000066330066660066990066CC0066FF009900009933009966009999
+%0099CC0099FF00CC0000CC3300CC6600CC9900CCCC00CCFF00FF3300FF66
+%00FF9900FFCC3300003300333300663300993300CC3300FF333300333333
+%3333663333993333CC3333FF3366003366333366663366993366CC3366FF
+%3399003399333399663399993399CC3399FF33CC0033CC3333CC6633CC99
+%33CCCC33CCFF33FF0033FF3333FF6633FF9933FFCC33FFFF660000660033
+%6600666600996600CC6600FF6633006633336633666633996633CC6633FF
+%6666006666336666666666996666CC6666FF669900669933669966669999
+%6699CC6699FF66CC0066CC3366CC6666CC9966CCCC66CCFF66FF0066FF33
+%66FF6666FF9966FFCC66FFFF9900009900339900669900999900CC9900FF
+%9933009933339933669933999933CC9933FF996600996633996666996699
+%9966CC9966FF9999009999339999669999999999CC9999FF99CC0099CC33
+%99CC6699CC9999CCCC99CCFF99FF0099FF3399FF6699FF9999FFCC99FFFF
+%CC0000CC0033CC0066CC0099CC00CCCC00FFCC3300CC3333CC3366CC3399
+%CC33CCCC33FFCC6600CC6633CC6666CC6699CC66CCCC66FFCC9900CC9933
+%CC9966CC9999CC99CCCC99FFCCCC00CCCC33CCCC66CCCC99CCCCCCCCCCFF
+%CCFF00CCFF33CCFF66CCFF99CCFFCCCCFFFFFF0033FF0066FF0099FF00CC
+%FF3300FF3333FF3366FF3399FF33CCFF33FFFF6600FF6633FF6666FF6699
+%FF66CCFF66FFFF9900FF9933FF9966FF9999FF99CCFF99FFFFCC00FFCC33
+%FFCC66FFCC99FFCCCCFFCCFFFFFF33FFFF66FFFF99FFFFCC110000001100
+%000011111111220000002200000022222222440000004400000044444444
+%550000005500000055555555770000007700000077777777880000008800
+%000088888888AA000000AA000000AAAAAAAABB000000BB000000BBBBBBBB
+%DD000000DD000000DDDDDDDDEE000000EE000000EEEEEEEE0000000000FF
+%00FF0000FFFFFF0000FF00FFFFFF00FFFFFF
+%524C45FD13FFA8CFA7CFA8FD78FFA8AEA7A8A7A883A782AEAEFD72FFCFFF
+%A8AEA7AEA7A783A7A7A782A7A7FD70FFA8A8A7AEA7A782A782827C838283
+%7C8282CFFD6DFFAECFA8CFA7A782A6818281FD0482A7828282FD6CFFA8AE
+%A8A782A681817B817B817B817B827B8282827BAEFD69FFA8AEA7AE83827B
+%8281817B8281827B82818281A682827BCFFD67FFA8AEA7A77C827B815781
+%7B8157817B8157817B817B827B8257AEFD65FFA8CFA8A782A681827B8281
+%82818281828182818281828182818281CFFD63FFA8A8A7A782827B817B82
+%7B8157817B817B817B817B817B817B827B817BFD62FFAECFA8A782828181
+%57A7FFCFA7A68181578281817B8281827B8281827B8282FD13FFA8A8FD05
+%7DA8FD0CFFA8A8A8FD27FFA8FFFFFFA8FD0BFFA8A7A7828257815782AEFD
+%04FFCFA7A7828281828282578157817B81578183FD10FF7E5227F827F827
+%F827F82752A8FD08FFA827F852FD0BFF7D27277DFD0DFF275227FD05FFFD
+%0427F827F827275252A8FD07FFA7AEA7A681828182AEFD0DFFA782818281
+%8281827B82AEFD0DFFA85220272727527D7D7DFD042752FD08FF7D272720
+%A8FD0AFF7D272727FD0CFF7D272727A8FD04FF2727272027525220272727
+%207EFD05FFA7A883A67B815781A7FD0FFF82817B817B817B815783FD0CFF
+%7D27F827F8527EFD05FF7D27F87DFD08FF2727F82752FD0AFF53F827F87D
+%FD0BFF52F827F8A8FD04FF2727F82752FFFFA82727F827F8A8FFFFFFA8AE
+%A7A78182818182FD10FFCF81817B8281827B8257CFFD0AFFA827F8272752
+%A8FD07FF7D27A8FD07FF7D27F8272727A8FD09FF5227F82728FD0AFFA827
+%27F8277DFD04FF27F827277DFFFFFFA8F8FD0427FFFFA8A783A77C815781
+%81FFFFFFA8CFFD0DFFA7578157817B8157577CFD09FFA852F827F827A8FD
+%09FF7DFD08FF52F827F827F87DFD08FFA827F827F8277DFD09FF2E27F827
+%F87DFD04FF2727F82752FD04FF27F827F827FFFFCFA7AE8282818281FD04
+%FF8281FD0EFFA67B82818281825782FD09FFA82727202752FD13FF272720
+%27272752FD09FF272720272752FD08FFA827272720277DFD04FF27202727
+%7DFD04FF5227272720FFFFA7A782827B8157AEFFFFFFA67B817BFD0DFFAE
+%8157817B81578157A7FD08FF2727F827F8A8FD12FF52272752F827F827A8
+%FD07FFA827F827F827F8A8FD07FF52F827F827F87DFD04FF2727F82752FD
+%04FF52F827F827FFA8ADA7A7828281A7FFFFFFA77BADA78182FD0DFFAE82
+%7B82818157587CFD07FFA827F8272752FD13FF52F87DA827F827277DFD07
+%FFA8F8272727F82752FD07FFFD062752FD04FF272727F87DFD04FF2727F8
+%2727FFAE82A782815782AEFFFFCF57A77CFFA881A7FD0DFFA88157817B81
+%577CCFFD06FF7DF827F82752FD12FFA8F8277DFF2727F82727FD07FF7D27
+%5252F827F827A8FD05FF5227527DF827F852A8FFFFFF2027F82752FFFFFF
+%7D27F827F87DFFA7ADA7A78182AEFFFFFF81A7A882CFFFA782CFFD0DFFA7
+%8281827B8257CFFD06FF7D272027277DFD12FF522727FFFF7D20272727A8
+%FD06FF7D20A8A8272027277DFD04FFA82727FF7DFD0427FD04FF27272720
+%7DFFFFA85227272027A8FFA782A7828182FFFFFF8281FFA657CFFFFF8282
+%FD0EFFA7817B81575783FD06FF7DF827F8277DFD11FFA827F87DFFFFA827
+%F827F852FD06FF52277DFF2727F827F8A8FFFFFF53F852FF7DF827F827A8
+%FFFFFF2727F827277D5227F827F8277DFFFFA7A7828282FFFFFFAE81A8FF
+%8181A8FFFFFF7BADFD0EFFA78281825783FD06FF52272727F87DFD11FF7D
+%F827A8FFFFFF2827F82727FD06FF5227A8FF7D2727F82752FFFFFF27277D
+%FF7D27F82727A8FFFFFF27F8272727F8FD04277DA8FFFFA7A7828257CFFF
+%FFFF8282FF82817BAEFFFFFFAE57CFFD0EFF8381575757FD06FF52F827F8
+%2752FD11FF272752FD04FF7DF827F8277DFD05FFF827A8FFA827F827F827
+%A8FF522727FFFFA8F827F8277DFFFFFF2727F827277D7DA8A8FD05FFCF83
+%A782AEFFFFFFAD81FFFF828182A8FD04FFAD82FD0FFFA782577CFD06FF59
+%272727207DFD10FFA82720FD06522720272752FD04FFA82727FFFFFF7D27
+%2027277DA82727A8FFFFA8272027277DFFFFFF272027277DFD09FFA7A782
+%A7FFFFFFCF57AEFFA757817BAEFD05FF82A7FD0FFF7B572DFD06FF84F827
+%F82727FD10FF52F827F827F827F827F827F827F8A8FFFFFFA8F827FD04FF
+%2727F8272752F852FD04FF2727F82752FFFFFF2727F82752FD09FFA882A7
+%A7FFA7AD81A6FFFF82817B82A8FD05FFA882CFFD09FFCFCFA7A67B825757
+%A8FD05FFAF27F8272727A8FD0FFFF82752A87DFD04A87D2727F8277DFFFF
+%FF7D2727FD04FF7D2727F82727277DFD04FF522727F87DFFFFFF272727F8
+%7DFD09FF82837C827B815781A8FFA7817B8157AEFD06FF8282FD06FFA8AD
+%82815781578157572DA8FD06FF5227F827F87DFD0EFF7D27F8A8FD06FFA8
+%27F827F827A8FFFF7DF852FD04FFA827F827F82727FD05FF2727F82727FF
+%FFFF2027F82752FD09FFA782A78182818282FFFFAD81828182A7FD07FF81
+%ADCFCFA7A7818281A68282818281825757A7FD07FFFD042720FD0EFF5220
+%52FD08FF5227202727A8FFFF522752FD05FF52272027277DFD05FF522727
+%2052FFFFFF272727207DFD09FF82837C827B8157A7FFCF57817B8157AEFD
+%07FFCF5781578181A7A7FFFFAE7B817B8157572DA8FD07FFA8F827F82727
+%FD09FF527DFFA8F8277DFD08FFA8F827F82752FFFF52F87DFD05FFA8F827
+%F827A8FD05FF5227F827F8FFFFFF2727F82752FD09FFA782A681828181A8
+%FF82817B828181A7FD08FFAEA7AEA8FFFFFFA7A681817B828182575783FD
+%08FF84F8FD0427A8FD05FFA82727A8FF522727AFFD08FFA8272727F827A8
+%FF272752FD06FF52272752FD06FF7DF8272727A8FFFF27F827277DFD09FF
+%7C827C8157817B827B817B81578157AEFD0CFFA7A77B8157817B81578157
+%572DA8FD09FFA82727F827F82752535227F82720FFA827F852FD0AFF2727
+%F827F87DA827F87DFD06FF7D27F8A8FD06FF5227F827F87DFFFFF827F827
+%52FD09FFAD8182818281827B82818281828182A7FFCFFD08FFAE82828182
+%81828182818281582D2DA8FD0BFF7D52FD04272027272752AFFFA827527D
+%FD0AFFA827522E5252A827277DFD07FF527DFD07FF7D275252277DFFFF52
+%2752277DFD09FF83817B8157817B8157817B817B817B817B827B8281A682
+%A78282578157817B817B817B8157812D2D2DFD0FFF7EA87D7D7DA8A9FD19
+%FFA8FD28FF57827B827B8281827B8281827B8281817B828181578281817B
+%8281817B8281827B828182512D2DA8FD58FFA85157577B57817B8157817B
+%8157817B8157817B8157817B8157817B8157817B81577B2D2D047DFD5AFF
+%A8575857827B828182818281828182818281828182818281828182818281
+%82577C2D2D0B7DFD5CFFA82D57517B578157817B817B817B817B817B817B
+%817B817B817B81578157572D2D057DFD5EFFCF582D2D58577C57827B827B
+%82818281828182818281827B82575851572D2D2DA8FD61FF7C2D052D2D57
+%2DFD04577B577B5781577B577B57572D512D2D042D52FD64FFAE83512D0B
+%2D2D572D585157515851572D58FD042D0B2D2D7DA8FD68FF7D7C2D2D0B2D
+%052D052D052D052D042D052D2D587DFD6EFFA8A87D7D527C5258517C587D
+%7CA8A8FDE3FFFF
+%%EndData
+
+endstream
endobj
23 0 obj
<</Length 65536>>stream
+%AI12_CompressedDatax���%�u&�?�|��(�0�m7#�bUS�\@R�&�F!�,e3�ꬬҨb�H�z�9�w��/�#��Ƞ�*
d�������Y��������~v�����Y8��^���O�>ݽ������x����}���O8����ՙ�����E�ʮ���O߽�����N����?}���Ow>���O�
+'���;9���7�z����_}���w�����Yy����rQ�O�?�ijg�硜�旼���^����%߻
j��ˏ����o.?�???�Ν��b,g)5|�_�����E�-5\x�r+ru>�>d����6���|�^^�7�>�����>~���gW�����/_#߼>��ݻw������7�{.~���}��N����3������_]~���׿���?�	]B.<��S��;y�<����_��S����Y�Y~�$������e��y�g��^�����w���;R���oC�w�������O?��p����:9
������;x�O	?�\s�
v�Zvg?���w;���~���o?�����������}�%_�ן^���-"~�W��7w��~�;����w�����x�f�~:
�do�ۏ�ɷ�/���o?~��S�������?������O2}����$����ן����#�t�K�g5��Z[��~���w��u�6Y�g������Yj�X&$�T���d�� [...]
ر����w�'��W�<JF���L����Q��#�=���?
+w��go>�p��㷋�3�?|}�����1�ͻ�^:��ٯ�� ߼b�O��
��ן�I��݇��OՏ�'��c
��y��߽���x�����#���ݧ������������?�O�
쫙�>�=1?2.����/��W�߽{�ͧ�����7{���~��=�
��ސ�{���j���
�B��퇯����r�
���w���[�ƕ��+�禯�s.9��~�0�t���������•���?{��"~�Q�@>����x��_��m������toí�u��������������M��7�&ߤ�xn�����o�o�����/�/��u�.��:]��p-���]OW�W7W�WWW�WW�^��|���U��W�j�������������l���\��t/å�t����������������^��|�.�E���bj��]��v�.Zk�Q�S�-4�\��m�����^�
Q)j-5�TEk���թܖ�r]��e�(��RJ.���/�L�6���|�/�En��sN9�}vyJ��& [...]
+��"4�J�!�B�w
.L����k�/��o���O>��w~r���]�+w�.\s��]r�'v��&��I�c��|1	Y&�$�6��_���r�\�����
���|�<���yby�C��LO����y����*g?�����l���
8.
8.�!O��
W
�
�'O<�������=�
����8½G�!O��Gz���
µ�垣>p����9V��ea
MXȥ��ka)�~��͈i&,��i‚.�]
K�
��'/�*
+��¸�0�� s,��Z��m���yauQX^�W�^+��x#ß�Eza�QXf�Y��^3��z#$����
^�����a�MX��kaͷ���� ,;	�.�›��Ka����oeU���Ga�bz�h"
�
E,\˒�m��
+/"#���"B���
)W"Zn���$�Ƌȉ"z���*��B�ҕ�����I����wѕD�eMDڥ��kY�W��;/b/���"���
�W"
o�n�'�^g�E�V���"^�e���L"r���("8�(��o��!7\ӎ�0r�δ���U�ca�O?�b
�ώ�C�����"{ȶb�[�|��������y��<$��'>rũ�=�>�,;<���Ĉ���Y���'����k��z��K��=���/���l��/���ڳ�^���k��z��K����j�sM���K���[7�m���IZ�h_��eO��İ�G/{�V&��=z�S���/��˞����u�^��V6��Ci��F�F�.��>w1�ċ������C���u��q��1�2y�}���qϟl���9v���c���/_�b�by�
*����
������N���
{'
��C����
���bv>�홐�#��'�}s?�u1ѿ�		ﺘ�gB».&��3!�]�ᙐ𮋉��LHx���{:�BY [...]
+�:Ƒ{�ۖ�Yy��M{�k��
�e��CH��/s�
Br/_|������}��t��Jc��ΊΗΣΰ�<�׊�"��������j�	
+0x��bp��	���}o7�
/�j�Qg���4B���������&C�<q�6f sig/��"
P�<�f�����q��@��a������#E8/��䤰�'Y��ro�<����q\�
���<Q6��q�{�C��o`,���<H�
�=�b������Ѡ��T���ȹ�gv.�c��!O||>����V��
��t=��q\��b
m
����(���Hv�q�q�3�O&'O�� �cV��q5��q\�����W�B�#�#�c���n����?rNy�D$��":�V�3fv�̮���
� �`fDxƞg�ۏc���o�(|��P��En�C�I4�/rc
jLb~��Pc��ܘ���+G�1
.#w�]�qB�UV�6�=��Hh���Kf�/-��ZA�5Ŷ�"��W�ާ��,)g0�,��ڲ�f�\�g�	^;F��'�Wo�ޝ}}w�����O]������k�n
ҭQ�|��|XY{LA[��vղ��Ǖ��խ�L�MD�X
��lq��^�x�8
e`´�-C�����
L��`a���sF0c�d�1�3$��#�1C2s�����1�VBf��kG�^��a<��At�P��8�������vͪXW�L]C��*r<�j7�{]���YQ��̚���P<翮��*kWbg�vVu�
�&�
]M�U�Y��
+��tw9�tF�
�����L�
G�2�

�h��6�Ç<�+v���䉏.�
��\�:��d�M��U���p����T+�t!�4���0�mͨ�0��v��+��#W���˻���twv������wt�
��oL
��y.�~<�����������="��xG������
a"$W�$�
�w
=��%b��kMe-t>f���	tCz�뉰Ǎ�#�!�q=٣N�
��5����=���2^��(�wm\�S���~bPl�&�c}���~eLv�C��v��{��v
O�oڸe�ϕ����
�=�����{�06�<���>�ɢ��}=�a���8ؖ���XD�-����f^ֹY�g��u�ƹ
����̈�	g�x
�Eg.u�cv0?�!�״�L9jW�\mXoXqXsXu\yX{X}�+k0q
b%�FY��^���V��qwU_��Ҏ
;�8��(���ۑ:΋�
;����B��6��.��g�[���_�v^J
+˟:��0�h��|�5{��9L���t�%����g�|^�ˋ�������b:��_޷���gA���[ZBT;_�]q<��
S;�4��}�_<ڇ�)���y�[�`�	~���ϟ����������ξ������<���e��=��}fd¼���>
��/ �=�W�C�^T��l��acQغ���
lg
�h��b��f�����o̔wf�G�&d3����^�	�F���>�L�h&t1����|eZǍ����]yY�[�4q���haGM���qiDž
͎jŸpt���+����zt���ݲ��e(��C��ՐC
��%�<��X�]����q��<Q��zu����s�c�V�L�,���7�M[�}���
WuԾtu���
�/a]�sr���u�b���F�F3��/k[��#
2.�7�t������߱6��[�����l������
f+�6��
��4�5��t{�V@�v���ՂP
�R[��sE�憞����NM�U�V�ZW�YX�&T,�`PѠ¡q�_�\�/ܒ_�g��[���?9noO�u�
bo)�h�<U쥖;�
v���~<!S�|�U�<<ϼ�s��k�X�����h��o�^$��<:��9���:����L��_�b9R4C8C<��J�������7
�P��Qx{�5�B<�P��EF�|A�~I��~m�6aB�u���F�λv�om5�%��\�jh��w߻��]��j0�r���e�r^��2v��侇u=߳�e���^�d]��Ǻ��N�վ��+�7�vx|��Q̘ޅG�#���
+ڝ�x9��y���r���
��A�V�y����������Z��b

��A��r,ׁ�+4dk��GN;s�z��<oⅬ��MB,�۞1	1�;>o��w|�$D��nv���M�$�
[���H7�lj�ؕf�#H%�l�)�����,
��.3��
+
5!��z�����J�s
+�?��^@�_bO`���!�����!\��i�ʹ0��~��
�Kv���Av���Ư>~��ݻwwg�����
���<v��a�[c �Pr06F�HE��xa�
�@��J
SGV\�`k�k�zQ��mql��Ep�ڿ���/|������y_
���1/��p���|��@��`?L0�����/L��j�P@�!����='_-�s��
x��
RE��
k��b5�]qp?�{��CW��]� �ww��^+�O�K.�Ά���^��?0������8����
�h� ��m��Ґ�j"0S���<��	:�Eq_���
�m��i�^�
gmq��#���⥋)��b���Lg��7&8�,����,�
M�j����;!w�b���mܓm��gp|�Ɵ'gc'������st

+�ܖjy(�������fn��:�!�Q�~��R�S�y��kc
�3F�_��yި��fyr���܀��m�B[K��c}k�o��)Xbu�~
�3�o�������շ�k�XϬR�6�h˱ֻe��F^����KE�ZY��I�3�{��A��Bd�<S��N��\N���C���k\<��z�o��?�[SQ=1��N|6G�r��/�
����� �^Wͤ;�
ۑ��N�"{B���Z7l�u��m��m��*<Z��
�)�wOP�N8��6�������9�]
+I�����%����'��g-��*���X���s��
�����n�~�ox�]���{
��Ỏ�e��l^���[
{�e��
+o]�\�Zז�
���q�����8vj��|ف@F����f�Ƅ�ង��7�R��-@�y4K��}��-$�����U
[��cW�jg)��j�AV�!�\y"��w>�~���7v
+P���%�0� ��XI�
���^.=�/`��A�#���U�eZ�߀z�?0_�M�Œu�X��C�K��0 s��d
�an�0���s0f�>�:���
g����|��
���!l�y��y��r��y����
�Ľ���
��
���Zʼn���T��S��
��u\"�N�&P=�2uob�H\{/�s��e,@�b��g��:빞
o��5��mč�Vy8ed��
=zpcJ����G&P���p�fx��]��Ҏ�q��jGAj�5%�'���G�
��9����ߘA���7�!�YB��Ҏ�q���:��`f&5�Ù}v��Y���{!�

�fNc����7;���v�'��mi��"){�RVeS�㠀�^)���*{�U�
{MF�����
�{���մ߫�(�/�^	��b.;ݚ�
=hք��(a�-
N7���9�ق���Տ��ZGZ��\
jH���cj���JRY���i)��ʒO�V�U
N+o݋ͥ��rC
V
%�8,�-�+˯�Y}���a^�}M�kv�Ik�3��i��kc��yvg�W�1�������NDܓ������2+~
���:*~v��r���
�XJj�G�
��������%۶�	K^z�4r�f���N�l
Q��(x��VmK��n�L�$�|���?,�PU�> ��Kz$��2y�t.4
�`�W�z��c
+٧t�]=���]n�~
K��]��Ű|����}v��x�%_9	��P'�>[�
��zPn�A�}.�C�u(���2p�b�f�m�bK96K�Y�uif�L6��i[X��qݐ벍�m�7?�����ň��4Yw=R
z�Ü�PL�0:h�d�`Rp����/��
��&-,��
+B�E�œ�Б,M�R��#B
��#���L�+s/�m	_M?Ҿ�H�R0�'���6��<nž��ˢ��2��Zi˺hKG���[����]B\[6�,t������h�<�� ���~��=e@��?��w��;��
���q������?��w���;~
�,�0���
+N�s��� ��G�_~1L��a��J�S�w�}&x]�ٿ{��'��_�x>x}������J�
v�Z���"�.��^���|��X���ݣ��9��X�c�R8ʎ/-�Qٲ%;s�)�Z,�[ѳ�J}���
+��*E�+Q�M%�m-�m5��E=�e�[81����"�����O|Z�܃���vOx�A��)��{�҂<|Y��J
�*�U^���,���
.,��C��U�/�=C� ��'{�7a~�)��i���/�
�M�E�ϣ��x�gt�A%D�u�\M��Nt����������9{�~X6�b@0�O_��YX�X��@��N
��
-��l��t���W�VQ�,8v
+m�3	�-�|��cn�Pb|��c�|�n7}:֙�G��*�����C�ɗ�e�
|���'�vxr���xj����G���)(D�)Lox�
e�
���Cl�gJ�ſV������~�[�
�U�lʕ�*������ںv��f��^���B_Wk;�!K����m��<��������l
���G��M�K?l�֗�

+�̿�|8O���%M<r�1
��
��k����}�
�UZNKO;&��	�jʎ����Z?[j��ӕi�N~�+��%?�+93+4�I�X�'�p,�\]d�;u&���\�r]fou>k��a�n���XZ
s
+'���ʀ4:�q�጗/6pF�2z}��BS
 F0.���/�\��V����q3ء��?K�$�xM�>d7�j::�j���@	���5�[[������17��
�!�EF�ꆍT:�/Mi_4�m��E��6�c's@y�A����1�mG��C����c��������A�ay�#����0�z���s��C�A����:�Q��f�
+9'C.�Rh��:%r���9�߲^ǜ�{T\n���^i�`I4�Fb��?�3��&E`�E��@l��EeY�
���I�Y&֬;
��ʫ�D�e�˲w�:q�(�)	�Pa`��Y��g��+����k�q+F�3�P�(��{(A2����K�3��AO���|
YO<P�ͨ���xQ%��}��N~�Z������P_ �
�Ӌ]�
��}���{��`�����^�J����D=&�^�h��`
��	��^�����	�l�ze>=���̿R��U1�d����<.�:[y�gN��2�sk~�3!���Džu�R�L�IV�
��@�2o*z��gpZ���­�,��r
צ�\Zن
��,m���b-�{�2��[��8wh9��rAXu��2:�
8`m��h��a1P�x���<,�����:.�RE���:.�]Ǝ/�DImӅ�jY��ß��;��G�x�Y��V�"�Xœ�ǧU��Σ��e��o��(����
��t�s�2-��'�d�~�,��v��ǃwZY��^��F~ٵ��n����N�3�TW�La�Lx�P8�Yg���<T�n�R?��{h,"��_
t��EV�s�Ȳu빬ɺ�w=p�&�q�+/Wג��^�~}v��C��{A�G�=q�����wg_ߝ}������ן�g�睳�q���|�����t'�
�[7�R~h}��<�b8�W��
�h�MDǢ��
�?YknU�b]c]>c]Zc]|c��`
�)�q���J�0h�Oכr$��_��X��y��w��p�Nu����U�\��z�F̍��r��sr-�5�K���/)��ݪ)†6Kz,F��iD�eC���[m��0��0��[f�ea�3�{V�7�-�����'J�1�6��/
ٳ� [...]
+z�JjK���n����R�����M1�uKL���)�����m
[
r�
^O/���sP�{������
�R�g���9���r��
~.e�W
~���:N�A�n��a�u$��|���C�
X�
��O_��\p�-?ߤ��_��
+j���Y��'��[�%�W�Ԏ��Zh�y�9���O��
��������1�Es���G P9�կ>~�ͧ�>�����~��F�߼|�o�]��~����O~~�ӫן>�ۿ~w����o���w�3=8���ep5��8!��'_}��Bh���������C���Y<���?�����8��~�g���=��>n��>9�ǩ����k#�����ܟ���~��鷽���:���.��W|�e���
����ZFi�e!�-�I��A��}���7�Z޼:��-����|��o�ꤏ�����s���$� ���O��_�<q�
Y�dQ��s�
�(u�?�b�����_e�Qr�k��_�<q�
��}r�`���c`�������yR0=p���j���U�&�>��K�lDM�����,�<$�@��s���j����Y�4���
'�bR�
+L��9�X%�'�?
e;��k6�>���,hb��������7��{��՞U���'�xV:����s��W{O<f�y�*[5� �����IY�SH�~�y�-��7��{⑛1��I��5+�������y��rၓ��W{�<�?�b�j2�X�U����rYǺ{���j��Wy��gY��j
'�reN:��'�b�l�9����ITa^�؂�S��s�i^�/�'��W��;��I������d}��b���?�/�~ޑ�Q��Ù��Zm-�)Yޜȱ�'y�ݓv���
�1��'�Μp0���
��0�ɱ��=�o���#94$��Zm�����1a�c��'����y�d�Ƅ�i�&�ɰ�S�j��ݓ�rUn���
���Cc*��~N�w\�=Ε�Sv竝�
Il�7xR³�/τ�x4
�r�O��^��
���8��:�f�H?'
ۋ�4�:Υ��v���'
���8ǥ�e
+�E줬t�
�ν'����y,Cj:(Y��4��~R�<,�;���~���g
)��`�][��~R{\�?���S��W{ϛ_��^��y���Xsf���5����7߿fP������X����	
�"�#÷�Dm~��\h�K��g������g���[O�V�<2iO���w��L)��1�\[�
�J(�:
\4�"�}W*�}�D�vپA4|v�KK �Л���eyQ
����s�/�Mb��"�N�QAؕ�������e��d������''=����,�%���`��L�
^�%lk;�7�VB&-�ۄ	��
ܩ�r�ׂ��Ȅ:���@�<�:����2dF��I���$���I��T���h��"��l7�Xk�?���1�+㍊(��巶���'cC(Q3�W�BSa+��@�,
�wE*]�Q�ܪU�i�V�8�7�����>Qԋ&v��*�t�� ZM����pBa�����
&��瓋Y�O��ub��Gb��&y�0QFk��<�o�m���JJqP�Qհ�8��4� [...]
+N�L����
���,�	�|+$��r��ئ��$ų����a���H�?C�����M^�cP��J!�L�p�J\S:���J~:��0?���JV#�j��;�&eD���B=�Qߨ�@9��pH�:a֔�ȲV�r!aR�O�S�����
���.0�qwb�	<��ۉş�R�
Ģ1�qFeV��
�܉�rp�$�W���
E�t�FL��%��eN^�qe|\/BEQ�A��R�+�5�"V��(_dx�w�,Mٮ�]Ѫ�^�V�l"/ �O�˔=�J��@�h�"��:�I�Hi����?d��:�B����7./�[s}UA�5�!ƳۆtV$�T�&�W��p �J'��Cl]�K�Q��0Y�]��g� ����0�r�Ӫ�5�)
�Ey��*9Y�B*8Ul�T�� Z��I�B�㤬1��<�׼
+��\
�
+m�i���΄����!L��{
+�p��j�p����YH!kN���
��v�+J�R"['m�Lg˟l�������U�@�ɩ��uh�R��t��TOFj)q�
��]���"S
�L��v�x��Sڋ4�OqK'����tj��t"�
�8�L=X��pW�ROTЂE�"u�N�*�Qֺ�
�sDo��
+����i�	�rj~|Vj�
�Bċ B�|V��V.1�b��ӟ�ND�p.Y
�o$L��[
Y8�`Q�O֩�X��Ӱ�\v����W�����z�b
,���|�7+Sv�V�\�e*�U�AG�\X���s�UjS�/j�l�ϑ���V��Yp�j� �-Y���
)�1jiZ�!B���8R}5�'l76c_Y�������TO��pHѭ8AvbUg�۹�~
+�
+u"((�Y@,.�3raEQ ��N,_r�/j�C5/?���e�i춻��k�����n�Yۖ]a���J�#[9p<��'���2�����%�C��Y�����?]�9��Z�n�.�e�
��ꪨʳ����Z�n3��H���a�,VM6�'�6�:�*�.��f���O�	�ny�j
�mRd��j`(5��rƾ�xE,M�󪃖^�fK�-S�i�m�"6�8I09��g��BJ��X��O�
�*���4n�b���
����7�}��j��t0���U�@w�LM�N�nAn���b롮���Q�<��?U��
+|U[?��/
9��L��������-�����S�"ekU?�Q���H�j�U�|@�Z�Ym�;�Y���J�����y3��Q�,:`�B��g;7e�*)���M�9.���B������(0@
��
+
&ObP�ˈ�^:5�?85�;U�Xd���i�9
+���#��
�5-��Dȁ؏�A� 
Ƚ��[�Z.ubS��qd�Wz�'��@�0�N��
�>��_��e�g ʈ��6���!+���L+|
��e]$��BZ�&���05* �+�.'�i"jFu�����A�=
�8ATL�~rBKD B�,
(��tB��N���mQ��l�N(RD�E(��rPjN�`��p����l
+�FӼ�[,Ap	AlP��D��95L��:�̗���p���aP#0�I�'
��
x��I
N��;7Ope+5hM�E�E5�)/MM_���݉A�O�L�����"�"�) $
	U����

jhYvo����2���vT'���) �@��N�� �L��
+���A���'�A�<u!����"�D@��q�H��!�%B��Mj�
+��F�������&2�|�`��d,�B&�y�
�	,3�\I�
ױ&{ƒ�#7R����E$xyKp��t�����I�T� H	J��l�0�V77:��g�1
z8��@�����
8���D�D��)#,
��(-q�Y3p�SC��rv0�Ls��`TLu�m��}�IRj�k�ς�b7�ю�@8aZ�L��OF�L� �Z�>�VD*t="�zF%
Gș�5
+��`*��3J����v:"��$��]� �$!�v0�l���� �X1H�3԰)�� ��n� vVo
+��_�HJ��@��Z����ATT(5
��Phb��I�K�	c��84��^�C'	u]*D��$>��&�%�z9;�	����[�GJ�\�1
�$�>�
�9��ʓ&Q/iҺ��D,��TEQ�ʼn
���V
��J�j
7��.Q���
+�Y�P��䶢.����7M���)M��:ޤ�[k�.�
�~�${8`��j?7ʤ�@ |#��V_IJT��>f�cB��62�IU�^�I,5�� ����I
%8)���	G���M="n���L��>�	���k�bQzXW�T#u�a�)��M�w҈�ʍS[W$�\������4�.���;>�� rG��[!%��@�BA-�� ���j�D�e���n�tQ��u�q��
+>�+�\
!WA'��FR��� K_(B��΀@�U� E�p�B�Tu����c��M�jg��$
��D1�Ѥ
T�H*���8�������n���a�`go�

�
F�m�",��s4ټ Iɉ$Qq[
+PS�xgۦP��y"
�[�!���A?�¡�X�-�Wxd���`�B��LF�B��$�M�(���
�jEUܭ}FQ��5s:E�����	ŏn�IaK
�]^@�"��
F}�WƮ,��zP�79�Xݐ-mRu_o�C5Eh
�6���^�[rS �R���jDN-R
Lȓ��*�vT+�h��ZZf}�A��d���wR$%+�TO!e|�Ts !+�5�C*�YZ�| U��!B���u2p7�I93ć�\��"$@�~O����3Lm [�z�vD' !4@��=��P�jH��_�8�pY��:8*�����F�o�(���"�2��"ht�j
?�6{١���*-�c����
Qy���J��Y\��W5�Ao�Aċ��6�@+����&g�qъ�8���j�c�����3� �*�9�ƍΆ���
&Z	
+�;�.ȿh�`뼺��R��h\�t�@��2_'��.좉��(�
�| ��`��^P���K|�Z��:���q�e�#av �
��5y�-/�A��u�ǩn������+pe9�lM���<

�i��6�Gn�
��2���E�����'��|�R1�A��2��h�(���=�(3��2$�2Y�W��C�+[��f�.@�@��v0}`6�3<�f��a�AX���ZQѪ2Sxj������i�y�f�*p
+���	-rb9�mW�0B����7���1c�����u@3�����B|��5��^�	z�jU��G[�OM�rH�
���n⠪ש�)
�Q�zWS[�Š�U�V& 
j��B�4�:�X"��M�|65̮"�A���2��� ��9��4�z��*��V��*�%X
+��ek
+����
�"�;]�s97�G�H&(9m�E��>74+�Π|A�T,�i ���`�.Nyp'*4u5xg����@�ͪ��E)��/F�9Vq���q ��"
�1���
Q��B'�W�e�Q$s�� |م��(
`'�T��pS7o37����Xb�; �rb
��(#VC[�
Q�
���5&4�����ľ'd� X��s�H�9��B�Śg�a쉶+� ��"�kl�R��
}%��%�
`Q���n��2�H77O
## 5��
�\���a��B"��af,^_�Ѹ��d'B�:Z�3��s�{�kK��7J���֘��
ef���ZC'���}b4ƄOq�~�	}y�����ݡV�W?QS��a�+G�r��`�	���ԉE���!��\�
+=9���+VӐ����Py�(l�L9v�:3[�S(P!a)
?��L�$�m
�{2�(`n�+
�x53C�x�
+���y��@�d
+�
��äQ}n�Y��zXL�)�BL�|&����z�
&,V3r�$���'M]#�}J��0]����f�f
+*M���H�CP�kQ���e��ȯ�����
�q5%J
�
+�!e��+>!t8j�}3�(��
Qevْ���yP��OQ��c
+��u$��N�(�ɜ:3I]#dr�����)؀�r� �B�Ą�Ams����FQa���sCr���8�y�G�q�!�`��b�
;�
����0��J�q� ͦ�1ˌ��<<�S��G�.Z�P9,K�{Q�s��*!��]����.�A�{S�x��1�Yf͌e�禂�"����N�do�Y� 
f��?B6G8�mEc���@ㅎ�7�r3-�$�瞅�j���B
�P8�-&
�n�2�8R
M�����}�T�:_���ĸw�-q1�D�d
����A��o �����U�
+&�Z'��Al:3�$I����XE]����ޕY�~GE��ؒ��r	�y�u	�{:vR���?�s�
e�B@�^;j�T
�Wl�>�`���ݵ��BB.�x�1Ehæ@`R�ʷ�T1cRT>x(���G n�ä�K��4��Qi{��|*���0bL�!�ɩ�'6H�L�������p�	
�J
3G���� 9�"�l
f��ǚ�M��K�<^#�+B��e� 8|b&T:���ȭ�>�kcL���[�-�+�}���I��$¬m'E\�~oMU�}Ws�0�N�bG�ީ-
�H�M�	�����0�t�1XԌ&i���'(�:��c�ú����'&�����&%]	o�qR+�L�
+��Ʈ���_�tm������`9
��*�#�~�dEU���Q�bHzՇmC��ق�Z��}�%M�8��jn
��������s�Ʀ7���5��+��SÉ�L�fKX��B�
�a��^Ej�2��p;�
+���j�ߩ�
V�jB��U�c�T��
�)ݴ� L��\����~�5Q���� ��X�sѴT����Q(Xpr~�O3�5D?�����y���UU
�B�S3��i���јBY禪�Q�ƹA�&�%�;�*+zۜ���,�Ge *��`t�Y���F��"$
�'�:��I�e�_rj��ؕ���E|O�m�72�A56<���J�
|�L��U�J����
]w51��Aș�>����S#k$i���K�Jl�ӹ�ay�#�r
�+��R? 
�5W(]_`Jŗa*v0�1>�@U!#Ѝ��vRK]O�w��?�I����j��0��gI}���j�guzq[����NJu	H`���{����+��1���+��^�|?�t���p1
R���"�YzY��R/��
��gUz0b��ޥ'�4X\���
̤��~�̙�!kq���_��
�����q�q��@U�!�[Z�g���@�A:)rĭ7�@�
#*�#�i1s�g?�W��=��;oS�}��=���u���3J�p��?�c�
+�`b���y���\�l=W-zj=t|��H���Lp#�ؔ�3gŬ ��1��8����r
�'zM�M�Ѿ,��}z����?����@�Y8��E�nT��|O�.A��ISG\��^*M�$o�����,ݡdi��	vm�n ���S:͗`�D^hRw;����ɱw� ɝ̙��'��wQ�eC�y�U��NS�=�QX�X�4Gݷ�|�>v��)
,�I�c���'��^
F܇��F�
+sz��j
L�
��G��h)kBq�&�{M��6
�m]�A™��N�iL?b�c�
+X��
+�z��g�T]�te`2�b�4zG��� V��I�`��w>���
�P����5��|�ڪg����םy�z==�Ւ�8zX�qg�c�D��-G]��P�F�lư�#�*��m�SZ� cY�M�j�MX�LE�2��u�R_��=1��W�m�th����@ը�A�D�Ng�=�w�k]����X���[�Y
L���21 $`�#s��pK
:}rCC�|���2 ��LՔ1n�%��7(��
+h����\ҘڡK�t8�
=
+&e����;[����.ަ|J�9�H��G�6���0(��ʮ�����N���
+�)1j����,�'wUI����bE��q8hU�
���C>~���X�
Y
?��Šv�@����F�P���xQ?W���#{k
V�?�s8m��
+1�huư��z�S� �P��[�Z����A-t�T���G�����#pG�.
Ȋ��� �)&�g���z3�޳�Q��l�7[�`5�G@%l'�Pt�|�CaX>"x��_P��O��̰�o�y�
�����R�Sl��)-�԰݌?)�4Ư)5�����&w�iQ� �A�(�t1ӷz�zU,�pU#~Xx��MU�V��ʰlE�[�)P�WԂ��am��

+��vϼ` :���O��
f��aE�G �#�s���a���q��2O������y��+c
�i�H���t��$�=:��n4c�U?�r��X�s�ĻB��`
+�
D`sq�#N�W�U�i�
+<X,�%��.׳��c�!�cd�,���$�}\�
�
L}�8�1r
NAXc��Vtg�/Y��N������~�O̚�̹�gD��sԛ�"���4�4���BL,6��Z�
 �
�D^��Zu�W]� ���+.��k��X�.�in#l�`DPO0��ߠ� ��)��}���y �
N���F��8AQ]���
���c�� ������hN��;
=vҠ�����B�Uef$�F�������0�N����W��
#�ŰݠCF�C%VoyR�
Bcn�����a.PR�Q���b
�+#e����" ����9�IE�`�Dp���]lG�|�1BF{!4qRb-_��X5W5+�M��Q���
��5EP�0u��	�y1 at Fߦ`q�0��'KY
#��Y����{�=�s�4���MO������y �a��
8

+�!����?�Ě0�,h

6D����$�	�
t	��`�A"i�c�=ȑrv�G�O�xg�q�Hׁ"0C�S*�&&���@{E�T
��σUI
+�"h"���
+ǗUX���[s��UM��"$�=%
�+"1ن�}
��
�Y!<�!���q�����v�
����[a�
�8��ʕ�GY4
�UWY)�KSW�������*��801��� ph��Xf
�r�
G���7�h������y�T��c�(�1F���*�n�����X�H���i|�fex,�\����?	
�8i(|��,"#rj
+�F��%���B�
$�n�8!�d��tk��+�l^� �Qʭt�
���,WЊa�ȁ	�D�`<h����gb�,�1J$1m���F�%��QF vc���Dm�d@@ʤ,e�8���ъ1��3P;���%dg�}6��dp3��<*���t\y�ajIJȃW=% ��od^_L�Pc��k��$c7�����S�$��@�WlҴZ5��,ۍ�F�S�a=̠���fP?���W=%� @�g��� �]���l�O�>�
3:�:�h+d��:F��
N�AՑb)c�H�Az����5.o
��jA	���Z��)NyTӂ�����t��){�U
e�&T<�t��b3��K�qW:�Fۢ�"Rs�h�>��$�� 
�Á7[C*����/z�������
d� UgUG�a�o��6�CH��QZES��`7VX�.��FA�
ۤ��3��($�\�O��<�O�"Q�-�d$�F��An�
n�X���sV<�
+9o�sK+3(�:�ҫ;˥K�s��\�'-2����Z�(�G+��#�ij��,���y
�7�w� ��Z��FX�b��&�^��x�4�����0��&�3" J�wѴ��
�Cტ4��\[�Qg�<Q+�*�Y�3���
��U�ɢ����R`�G8���2�K��}`E2��M�i�x&��]�N��I�o��� �е�
�`�b��kž�����(p�k�y9S�C 5Ћ�j2tV�j|�rs���D��V�ք
���rb��R�k?b�Q��DH��7U�[-��B�b^>΄�@8��V���2j�=݁G���e�֠�L�̕:h-�
��d�FYc׀�Ҟ
�
�Np�{�n͚,ubçʠ%1�>���?�2����7���G�M#�5D�תT`�_xc|���UQZ�Da�lf����V����"@�M�Bۃ�Z��>}��M�,L�Im�����t0tRW��5��-���(\�!ر�}�ז�
�Q+ʃ��dfH׳��e�D�܉�(���X��"� L&�j�c?b���W^�%��\~'��È��p��l&��Z@$}���I�'
8҈wյ��~R��N�:K�����`��Hi�{���	q�N,�E�i�f��R�/"��ćkM͌F
�
Ԭ��m
x�Ua�)���h1����P��RM�%�
3Q�-rP�ba2X��� ��
�f���U��Ęi��S�Ē�UţR�~�Ni+/�I�h�j�R&$�"�
��"��\��M	R�6�PO��4,�wI�P�b댢c(���I����XE\��P��T1C�a������ә�0�sdۖ��7�m
T����B��Wmq[�g��m"a���h�fE��ۡX���Lk�܍�y6��#�{�@T�v��C�1k5ĉb7+�T5�ߨͶq؆��j�#wm
+$6KKэ6���H���2�N
��#���?t-��9�s���:�A��
���[ 
r�*`�6�|em'��O��):��N�˭ɤ� �1
�Zl�vB@�ea���Ê�a��Մ��N��ܠ�S_u���/�iό	�!F+@T��ި�!��6@`S�2H͹�ߕuw���Z�I��$= $X(;�����}z��4F��2�O
l���>.&�f��N��@#�^�
��u���h�.<
���S�"F�f&�p���Y��4���������ʴɄ�Ի}�p��E��qs�����=�j}��\P��ce4�
V�&� � vP׉�*>�
�=�Oniv|�I�"��h�f{B�nI��j�9�\4��0����&X��(]w�<=,���p4o4Ao�,��)��iܶP�cx1t��9Q���378|�9���Z��r��Ȯ̪�0Dc��`��A��3�k���k�?'%D�!϶�;!�%���xiHJ���ǟ�‡
�@b�e���P��~�7R-
+��i�W͝f���2Uk�5��By'�:Bu�&��!?#t�� �
tm
p5w�9
��������z���������I��@0ƼN��op���vB0M�h.�0?
q]�M�>�
�$0�5:��֍֬�#��S��n�ځ��=�&�E�[��@�OdD+�m>?��V�wv��>I�Ϭ��E�M����F�Y�m���j��v�bP;����M[��P�V�k&�`'�� :
��c�Ҫ�z��zn�q������ ��0�1du�h��֢�Zũ���C�d�^D��_��
���N�:�j�z
+jE�V��+RoIl�łg��Ɓ3�
��&��.+rKbD"&��Z�t�hK�„���3b�LCb*t9
>�y+LO���)�mנE�n�8h��J�3�CK6��5�}��$mEk�����e�1���0 (Ԍ�
+��Lro�U��+g��
+�<锥��]U|�u:���
��,ك5#�si3gqkH�.�whf/���
mC룂��1���D��uԾ!��9����^�;�k� �f�ju9����dY-YY.21ip<Y�饬kk���UtJ���'�M��4v�ᶘ7�L�BM��&C]���3�}�OSFa��Uk�N=��
W��.o�-�b��rޖ�U�P����`Y�=Ak4*���z��~��u#�|o8�
+��u�Dz��V/NWYS��*�
�,	����=�,
+���t]oS���h�ah{��Ά�ݡ�
IK�RA�
���7&e+��zwЊ�2
��	�U7��4��҆O�ć(��Ԭ5c��V��=|�3�j�0UY��7�h}�^ ��#��̩�Z�f�mRrխ�֎����Qz�̘{�ت<0��XRԑl����e�'����d=�nVD�b|�a ��,Zc(�L8�Zs4�t\�pS��l�+���D��
+:�i���je�:ݘ�Q�b�h�27-��bY(�U{��{;K
��\�Z���� K��Y�Lw���9��L_�7��2H�plR�*�̚��f�6�4P

���o��JֵL	�@$���X�bH3ḢAM,
tOÔ��)*�MSP±��.Y,��m�Es���FZ�X�9 '��E��
�&��/5$1B�(j�������?���M�r�C�b�#�h�`��w_��P�7 ,�jU;Řx2�F5��V��k<�~��P�w�
+
+C<
~�3X�
m=��b4lVm���A�hva���e���Iư(�e�;�Y=��z�N�W�
�EK_{K]F@*��
�3@�
{Ќ��Y�!g=t��Gq��CH1�
+��ᅨt�Nm�>�ōľ'm�8���A��6�7�,����IѬ�-clKSSC ���d���(%�]��x:
+ԣ�6z*��j��;����oшyi�Ynm�(PYv�t��:�I��П��kA�ۑ��۲�g�?�:BźO��z� �͢a�,���-��k��묅
]G����CUe�Ћ�
E��
F;��l�hʂF] �jP�'ŴJR�!�3�ea���j���+�?��h�SzH�~��^��4M�T�;Ty��u^z}=�U�n��[Ed��;c�J,Z��Ç�	��G�UT
��TF+=�Qee��Q��4�"#,Y�~t�Z�+�ӌ��QT)D�G���
�W�>H�Z^�Fh��V��������Z���l���h��%|�ض7�
+4|�1�	j�F�`�hm�z
+�I��r
+NÉ�i7hS�0����������w^��ɲ�AQl;��РMG៩n�̚��!

�
���$:�������d��-��
�z���I�������E�6jR�z6�Q�}6���� H�"���^ :��͏z�8�V;� %V��'n�}
+��n3
v��;�ԣ�p Y`̭)��I��UZ�*k�O���+!�(�B[;��y�5�\,��b�`1�6zk`2�U����
'�P�=S�%��%WY�~�K��2kJ�TY��-Ʒ�>�
�����K�;8�[��-��U�g��Y�,��F�D�� 
&�cY����,Q�>3�K���c0U��Em�`�(6��YEc���P?,8-�_G�F4��'@9C�"X
뜾
�)�bВ6��~�ĀL��T�Zi2�}��<@�%*Yq�f]��i��p3� �b�Gv
+�#�iH�Jf ˠv??z5BoY�A����%˩��b~G���t\�i�HGL
�r�[��@U?#�h��-ެ��
�8���z�
�-[db� 0+�*�
��:�$
5����V�3�"�Q3�4\��PgQ~���(`��p���
�a����CZ�w��T+=A�sl�Jc�`���֔�J� \\`�(��~���

��Ī�Ik��{�3�pB�T�%��ڝX�}O�Bz�yA5
*MN}�@%F�B���A!S�T5mن9j��ԇ
�U�"F�,^{�O�f�' e蓇�[4�B�Ĭ�yQ\,nVK�}
�Ƽ�U��Z,h�\�`ڻ�E�V�
��~�e?F���
�'?F�JE��H�Ó|lƨw��<�W�ژ��
�b������1
!��E����אtb1W�q�d�s�����b�#��|�0a$F��1;�e-O1sd
Xg�~r!�&��6�Z�T�Y+'`f@�`f�o�5��mP��o13Lc�w���
I��T[*� �ek#�ƅ��Z�P���dh}�k `�nL��,M��
P�<ũ�mF�
��Ƹ�G�G?A����7%����MU��t �;i`�1!	SP��ĩH��'�)H�Q���F�(�r�d#:���������$�V�NH����J� ��͝Ҥ4bn�c�q�Hli�1�βIݮRqID,�I
6D�)8;G���@c�P t���T��;
+�ه���.rT�݁� 1N��iA�c�4�ӳ�R�.{48� 
�\$Omt��i�9$,��b��ӆ�f@�(d�p������FC�u�4i͘SOU}��x

��Ŷ]�"�z�q��ˆ�ٌ��U�e�
�y��d8[c�J��Jd� 1u�3��� 
�Xؕ���CR;	6U���d#��M��NS
�
+}�ٙ+��1n�3nG:��NǢ�>�pf� �,�Z�G��lo�s
GC1�>����o$z�	���X���aa[l~��v �*�A?��;&�jˣY]�4>�8�`�
��G�������Īd��hb��2i�T
�-j=Ūq�o�4�ޢi���M��D'塭���M6�Q�
��.�T8x���[�,vRE+N
���
�z+( 5	��{��h��*�3����9�Ѩe=�;���79F
Ƣ0\j�2��j�+F
�sLI��d!�h6<u%,���$�
�8[:� ¡�9�(���NB�1�-?@WY,v�S��SVf
c��=�t�\4�,&:�@Afܟ�P��
��cѨ�lE�;	�(�5�VLrt>��,O����;aWH/3��+>���ٖ' rh��[e*h)���/r;z����.&
{
�5:�R,WjV�6p[�"4�ˈ֌��
+�	P=Et�
79����TK
�
ml���M�:
N�\HE%+����
��!�AX�@� ��V���x|.WB�_�=
��a7Bl�~�s@�Ib�&>�T�`���&�㡦Ѵ=�a8�m�\�ZH�Xz�8Ǹ�ifj��}Y��;�X� �������E�8S
Z�bb����6]���Ɇ]o	pR�*����+Փ�^"��Q�V�l' �1�9%n&
M�l�a�n�v�fr����|#�7f� `Z�㵨N�<�O��W"s��C�:]M��*� �FUQ,Kj�A��d�*X3��'�v�1t.0����U5,��5h���(��뵟�uw��GfQe���
��s��âzv��]�b�
+�d�ea)ª�nF�M�H
�V%��Y0i�
2��j�H�5��ز��N ��aE�y��~�@2�ʇ�6Q}!�
J������M���-gĭG݈�v.ftd���le��=櫌MUet�
=�����
+E/���Ŋ� ��-�~`}�� #�%Y{�l!g[*� �%�g	5-
z�a��7<b}C�����v��4`��[�b-��RKZ�v�� �����b�BXj�V䣻�7�MN����~V“�V�)�RF�w(���E!�-���0M��h�l'[f {U�/y��i�f�n}�ȴ:����3(��I �
+1�XE|h����0�=o|܃(O|R+�/�v����u2�I�j�Bz�X�f��4�3���d��
+'�}la�8�^�
H��3�'���d�
+����z�Z�D�`��@	
+��V�/A���{���b,".�����xT�k�<�f�3��fU���h��~���lL3�Ȏ"5��mVu�د��s<&�T֡�Hꕥ٠U2*X�u�_4R͛+�M�b��U��l�,�)rKm�5��I�l�
N�V [�1l��]�.‘��
oV�V�f�1�O"��;[�2KC*.�
#��"��ږ�
�z��:7��

+
"8:��A�V���"{	�W0
+�lu2�=�f�ZiNqP��+��N�~��,�j�����nL�#:	�U+l�'2��E�Q���L��O2�R
�P��(����2:[��4�'�`y�ֽ��	�b�fP�F!881&�Gmhu�)�ER���-�
�KW�VYT,[�qI�c1#T	��nL��]�U�V�A�eQv�Mw�V�Y�Gh��bW3��>w:s���Z]>3*�
+
g���`�
�#�����ь%�h.��ձ($�C8�}L��ږ�YkK
����ܚ�V9��*#%`���&�dV|ʚ�D���[�k<�W�g�)�<��?�J�4h*QӺmp�X�B��ꟕ�I+u��
����ɧ�μ����[$��7F�����Z� U6k@��;��]��C�C�PxX`�0�q�@�
�V�U_���҃/AQ ���g*����u2�k�*Fժ�CJ0���ܔk�;E�b`�K0�eT��0��
����	#�#�����^���K��
+�XZŖ\�"��3�;�
b���	h5�G
-�ݝ�@"{}�RTZ�~
zY��H �ߠ�F�=Gܨܯ�
+�T�[ZVu�;!.~e '��
Vx�lqʶV���c�q�ԍ��].�P�ю
�z̺��f��+�w�l��V'��2u��
�Ah	#:k^h<bv��c�
9se�m� ��	��Q�.YE��H��d��x-�A}���p#�J�� U��,K��8l����>+���u?Ɉf�.�jg���a����C!�ߺY�,{�pI��Q�
+bs�:��Ȯ���j}���
`����^EW�TY
~�;UA%ؒ���i��s�$hy��vSĚ�wŋA��whˠo�?w"S��ڸRtR�A�N���]�"���j퍛7�h�Y��:BE�>ʎ�iflO�B�����G�T��
�A��������z��߫/�M b@��D�WMq��

�_�hH��U���h�S��F��;��:�ImJ7�Uka��@I9�QE�UJct�x��4_Q�x�w��ZT�Ә&C�&���t3 ��ڐ�|�u�!d�09�j*nʪw+�-W�Ӹ_,s%�J�p�
6�
+�^-x��.����
)���Nd֥�'5�1�U�b�H�f�`)����hxH
�A[[R� �6K��VŪS��^4�U7[{�V�3�R5WFB8G�u:��M?���J��S�_c��5k�z8�Cw#�	E#��5��V������g%XP�h\d�
���` 50˱����1
+�a�ՠ��:�m�T�^�jޛ���Xټ��G�$`�q��2��d�Dt-0 ��E�"�,�]���+v*�kPG���D �����@}�q
L�
���U0�ϝ�ԇ�5U+�ǠU�a��[�e�d"
�����	�fke�"�	�.n%����i��p\�Оm��0B�$v0��ی R�Ֆ-c����,��3�	�v�%A5�R:Փf���V at D5�(�
"��J�:>v
+S��m.���E ����v͏%��6�AEv�
+�"�	�/n��l�=Ě��N1k�>�Z6lҺ�`���WF<�g�b{`MRGN�0ͯN�~�e>W�H�m$�[�A(τ
����Lym��?+��*"㢬�-�@x�AObT��a��.cmO��;T
+/�t<�{�:y��i˨p0W�_�;�5����W���
> � �Z�L�}��-
+X������>J6��t�Pm�F�����ڞ�ȴ�����n\d�ꑦ�����@ɰ�'�4���f�p��A��R'@ȣMD��LG=kƤ��xX�A.BZ����M�P9�!��r֤�I��zV&�:�X,[� ������>C\4��:�Wz��C���\�
+?Zj���f��ʸh�a�<
	f�1�nDut�b،����e��Ӭ��6uk���]`�b9�l��*ߴ�%&�d
h
%-`�Ph���f�� �h��٠Q��
+�
`m��R

�,�E������&{p���W�
��|�VR��"j�
D�?P,

(ث��&��/e� ��H*6�׀�ѫA���T��T4�BU�߄��
�4��'�?��Fu�iI#'R
E|@*V�`�_τ_7j�;���Y��pV�-M��.*���W�55;�T��[�u�kRU��
�ʩs��wB8}���j;�cU�QZy#�9���zKG���6h���E�Q�;-03��%�벵3���}��Ŵ�f]�@%Tn��w�%��k"A1ϋ���h�
@"�=$���
�	�(���9U�G}w�a��zhE
Y
:Yc�h�����L�j�U%�����lT���(�JB����qr����L�z�����
��ДC�J��Z$�'�+,{,��:��B��Tb�C?j�%��-�7�b��Z��,�Z��KVnPՒ��W,񬝩g")M����z��Is7+E
�D�2"�J
��Üm亁s'�	��	�$��N�Xà���~����7��8�����Ot ���<����Қ�@9�v�dl0$h.KZ�4���'������lhH�XQ��&����yΓ��f�s����j�' ����1-�h����������5�O5���tŋf
�3hw&T�e��E�2��[v�g]���{�isàŴ��N��`��ܕU���Df��'��j�

��p��F6[�
r��/*Q��)��`��팦u���XJ,ެ�$�h�Z���&�AS�fr�3]P=�
���#��"�5�, ~n3��֚�u���@*��݌�x��}���Db�����9m���R�d�
+�����
͹��a����6׵vy�
+�]bY�-p'��NZy�5���i��kb�UK ���e�:o
+1��o�[e5�@;6,������bQITn�O`�UuB0lGT�Z�c3�
a7ނ;X�

j�E�)j���1g3�Xh+�BfG~���F��y2[b�����&@mǢ�0VG�`�'@o�'�2jG�K��O���MK���dߋ�7`K� u�S�DCL_�Kg��BR���e�K6����ظjD�
+��Zt��ej����Rg�����]����Y�M��Tְ�
r���n�2,WT��	ܩPr�M��>�@د~��B�>i�:��Χy�(���wk�L(ee�_VS�FɊ\�)�875����z�CN!��*�V#>����5
q�E�ZXx<��^J[��k޼�ۗ����Pq?�k-��U�-�E��L+��/��@�D-�:���
+h�iU5�h�

+g��<b���u�>
+ܢ�s��j��Ć9lV[�I��j;�����`x�2���]AU6������]�w&���Ծ�:%���H�v�D*�������Y[�Ġ�8��֦g9�0*TI��h�~��$�
�
+]
�v��a�0$�
_�	�OH�V�Z��W5A�B�3T��)�D	��)E	�uf�9>�9	��cc
FGТp�p	���K1q"`&�t�bl
z���y�
�W�hEL���E�M��)+z�7An▮�����#��(�
������j`�
+#P�&������	��r��p�C��ާ���`���EH\QD��
:1N��{�t�
��PԸy�������n9tЂ��R�| j
-tt��Q���r��Q��|`�?ez�)�q��Xy5=��VmsF�>4Sr�σ5��A!0�ޖ����7��{+��]M'��m���z��V:��u���I0-#[�'ꓚ����"9������פ�SPü6#$��"�A���wr�6"4�	�&O���N����+"��瑈̬5+ ����V���L���IGÆN`�IM��:t,�ڬ�8U%ST4˱G�_V��[��Q��
��:&��҂��Ѹ�r1���;��`���-w�����
+�ͣ聅`�L`���'��Sa��eWA!�
�>*iky�=<e>c7CP"�l;)��|(�3i��cw_��l�ؗ�Fs�$z�[e�xZ8PgU�`"��Y�o��1ȓ���
	�vOފ^W�gBP����9a:X
4Y ��oD������4l�0Y�H6u9i���<ixp�i��]�mځPCɃ�ѳ��
1�{�R5-�
+5��ӋQ<m.���z��ͤ,'�Ӥ
��z4|
k%���X��
���_�:���8���rؠ	{� ϜOj�0�R���el�Y5܏jr��}>���ƍ���X��m5�\1�H=�C�Kl|�4�O��HYSK1�=,#�y�jiL���(��,c�
�"�@�Y,���i�J��0���jJ
+f��]��;��\�gi؀�? rZT�Ng�s=`�<0h�\���a�E:�!��C����-��Zu�@
J˻�= k��b��`sC���7� ��
���?ko�kٲ]��
��)	�Ê:�=9���l�Y2/
�xHQ6-&E���ӷ���%ޣ����o�L���uv�֌jc�qP�;�N^�x&
~�F�M�%��*���C��<�E9��@��a�IX�`\B�a�����f�‘)>�P%�
��o0�`�,&�P�R<Q@�k&���G�F��t���)ϿPv0�M](��X��p�#����"��!f�PMHX���`.�S���5��õ/v�t�
�\R�&�z�]6��f���V�!���* 3�B�6L���

gda���+��j.{-�Q
��|	Ǟ
,��(��b�i�1�?�p�J��d��y�o�Bl�փȏӼɲx�w�z�'zR\)�� �Ϫ��Q�v�b5��YM��
y����0@ܮ5vf���dI���Y�
+Wo_��
Ap�-�;VJ�<�4�����D�BnX�z�����EP}�+w�)=26�OmQ
���y�.Vͭ/���h�_�	�2�␼��O��k�KM
߼�-V�"�<��$�h5��툆��)���"�T��D
}q �F����
b&�*E9�=�|SӲ)~��s��%�;�K�[��hM����#�bS�gDM��0=L��HQ��T
�A��&�OTES��P�aQC%�[���xX~���B�?�{�c�~��A�gz�#���RDM�Ų>�r(�|���v�9��f��If�<ΤؙC	I,�-

�#�����R+��<ƙ�#�簃���ϯ
3�I����u�
PF*^•(ǹZu���
;m����
+�B0xD�|?�����ݼ�
��ް��;ƙ!sD�9��fa7�_�O�iy��yG���OTkȩ����}�$QA`S&��A	$�P5�
X�cƦ�
c��
�FEv��Z�A�i*/b�-�i�;&N��ʕi-��`�dn��c��c�P;�;���]V��{w�Nf��k��\e2�u�t��˚Iǰ>�E���j6
�6��@}	h�?l���GS�j
j��3���W1��ݏw
�M�d���r�^�&�]͚�r(�F-<ͪ)7%
�Jϋ-�(W6��;�Y3��8�P1�na�k;]j���w��*%�"��6�6W��
3�ھ�{�U�`�"^�X����/6�+��p�VJrrE�p��dݤN����"ûM��c�$ЗH���9�ëFw�
+���-��u_
+���������!�3�0� TkY���
+��
bo"郳�𱡸�
�A2J���T���;v�p:;�8��ӷG8�H�
�O�1�1؄ꠊ� 6K9��'^c�m�b_4C8���h�⏐�1�R�9��L�a�����N����'r�� ��2��<���� ���gj��p�D�/6
�ȑ�˜a�I��Ɠx���p���]�T��Uӥ���e\�Y ��V����,��g9�N�
Cd��c
�C��g�]݀�;^cέ�Z�M�F��$bS�W���xG����%a2�̖XH�s���=���(�C\�����
b^R����S�T͏����l�ׁ��q6��N �O[C$��
_��kS
v�(�XV�Hu1�`$��1T�>
�[B
�]�L�,��{���؃�� �^�'��	�6b"��kgY��!�0L��}�������EX
�&w!��Zn`^Y��$�O
�6\����1k˳�_�Y&��TQ�"�;��~�[���%#4��5c��IBxM,����; �̢�V��|�_+������Q֨�����D;6~RR�G.ڬ��.
4.��X|�"
�$�(�2�@A�P�f�6 C��L��}�5�Y�@��B��,Ę�:u�=�\�r��N+�(�aś��_"��̎���O�d)�I�fEPk ��������뱛�
'�k:��vHh���a���^//��Z+,
���*ޔ�]����!@
3d7�JT݌� ��#���IY3���(K�C��V��ЙG���Â7��|S-W�����C�Z>Bj�S0ѥ�
���*�ěp�	�*e�i����^f_WT�U�����$�sl�X<we;����ɫի�^�FG���s�,QY%�
��Kt��[_�F��
��W����������Y������ax:�ˌ{�
��
����m��
Eo*��-9�W���B@��1��k\iS�i��5aJ荹Pg�=(�LD�P��AJ1$q�To֟*X��?EBq�P���
��A�3^E��^%�r�	��Jv�j~�f���D�.	B�I��L�w������b)l8��0}��o��J�%Y�
�;*+	[�YC2"��w�SY�ƜͿ��vf����0D��!7�w�1n�w�sȳG���Q���JD�f�eB��yt�����f���. 4��)>HY>+:���XBH1
�����_n�7�R��K�����^�d�ɽwhq
�E��X׆ ������\

+�E�J�6
6�����x�n�ws�6��XI�|�?��1��z��4��ZMD>��0�OT@/�2�ܴ0}VY�x��g"
+$^T���m{��M�b�hC��?l#���L
�oQ"�,�����x��i���|:��G#K��, n��j�Y
�2LBP{5�)����px���z�4,r�J���i(�x�'r�5��
���$n���b-6
M�ޑ-^��D���*i����D9,ϩ���cwn�+�tw�G�h��.<����Zh}{H&A��2�-�9n�U�&��VB7D�
���h
2<��*ʾ߆��,bV8 �
��Q���_�a$�f��C���x�
t���&~O
�Us�Yjaܓ���_�"V�o�
��K
+?���1���6��̦��b ���!��
��b)�ê�cB�z�3�P���:&�I3A��4k:Nn��m��
(n_% +�4��)�J��UX$��C
#�������O��0�P��C�C~�/*�'e�'������*wK	�
+�:+c}��6�t �v-�J�2�t��:Fj0�)Q,c��qU
��r��R����b^�C�f鷍�s�%�o�c�2��N��2��1���~��TKcv1�a\������?��Ɛ  t�%ae͎a�W�lO9օrf�jRK�
M�ڬs�
+󒘧��6a\� 	~_���a%I�Ţ��
g��
y�j�[�OV
+\h�I�̊��d�?���G�q��E�K�PP�\U�6�&%��E"���
�C!-$C'�'/v��$5�f C�qƈ�/�+����#�Q�.$��rI�oh"��R/-���]����Ro;)bi��l�*xG�
h3���ˤ���B��ʁ1
�u�c=�5+Kz7�:�ƼD��qi��������עؽ�TD6P�7d�w59�W��D&�����K
�4W��@�f���N	�c���v���$@1�C]�(
��Ōgr�t�"Ɋh��~-N^)�Šh�dw�\8[�:�@-�U|Ҕ�H^X
t��yո������_m
���DaV�����C1�YcYq����M��������������L�O�C-���e9���F{��E�!oi� 
�c��5wU��X�]�� }ƎӤ��o�^��Ӄ{8��JU^���R��)+�A���э�/�J�������X�:Ȣv{��aW����t�E2
��J��&&2H���oƽe���Cb�"1��=U��U��;�-"�(�ZQ�۝.��O~�PD�� �)_N"���S�J?$���Ղ*6?�Z9+�͘
+?B3D��

��j�ﶢ�F[/��
���
+����a�X�͐��wh��r�	l�a�Tg�t���t���{5���j
�`��ȉQ��
q�Ei��!E<G
x�ӷ������}&�
ɛN�Qu!��-
�VHqԸ0|�-�
~��A
�ܯ���J.R9�q OKg�wDe�Z��&�Yѡ�����+���k.ȸ@p���f=�xX�F	�������;|vv!�.��j5�Ã�Eq^*bm
ʯi�)ޑ�ܰ�}c`���T�
�"�S�����8���Dl=��!�Q�^�]�9��%�F�^��
���)��h�ۓތ�L9,��P/
?�^Y�S��X�(�d
-'ĉ���ES	
+08��\5�J
(�.)�ѭ)����qI�F�' \�Hl��!࠮�Wg�Y�5
�E�]W��|ԫ�~OMq7�T����� $����sץ��2��d���sծ0C�P�m�/cj����r\8"�^��+��о��"��-���H�HtS�Q`$lg(
�x<��Fߓ��
+N���-Ą&�P$b�BDE at E �إ�n@����
&'K�b���I�<��E��~��Q�i!�
���LQ�@�Q1u^w 
+�kK��@u��,�Ʉo��
���Yo6�
Q<7݃��\&R_�)��L
��z �żI*@Y��:ʰ�Ƃf/�����iC7�<*�q�i�w�iH� )��P�d�;�����À�S�V!]�{���(�e!�6����C�3�Qo�H
+��VEO�vѧ�
82G�v*��^">�4�l���v�Ǻl1�a�lrdmS���Ki
e?N�,�,�a`'��H!��|؛�~G�l݊�ַ�
�^y���Ν`�������,��-Dž+���3
1q3�~&�|���|����,N�2�O���\Y���
ǭP��6��5M8�]L��'���vE�Z(�"P
1�@�?�

��K1C,D-����~SR�%�� ��^ �ɤ�<�J�
2���3Ws�r�^��Kd�Q��Zͩ�x��r���B�{5������e.�a9�zX�x]]�a'����q�ɽb�^�+6�*ZY:���F)��,HL<3��b�>Nb� ���Y�Z��E�D��i`(�54=O{3��H��`K8֭
��`j�C)p�J%m����z�����0_��F����	���$*:"�n�|d�{�AC��r�e��wJ-�X�P�ʊ��P-vJ�"y[�>��N�#A7�>B�")��*d�ڒT|��:e�8��s,a& ��y_b��G�
�]�AQ�y�)
Z
����DVCQ�h��,�B�����a\zp[mIpl�L��Y"W�%�:%v�Hϴ��L!�`&n0K�!�`����a&�I!Q��Y��ْ���ĔGzʐ�M�VZc���w�q�W�j�]zq\�E�ٞOxA �!�qn
}�dݞ���W��^�5C̐ĸ������
)��
�����&�xZ�_E�=$ [...]
��Т<J�����B�倫��:�l*�DRF)����P,�6yb�3�S�*�	��C��Kћ��Od熰�D覷�2��N
�4���Ġ���E��\\w����e��V��2��%ߩZ�]���R��r�5���b0�3`���9o���&��g^'�
+��@r�0���	MtR)�ӄ&g��mLN��Z�B䄶���SfW�o�u�Қ�Ħ�Zj�/�Os�!@���Ƀ��������	Ő��1��|g�$�wm�	���W�_T�ׇ|#�*��z�
�
+�0�w�z-
��
��3g��6T�v���>�gY P��R	pL�M�=�+Ώ<ѕ�<�(��Ty4 ��:AO:�lS8B���t*M.�$U�uw��+B_�eam`�+�_^��c�
�����|8����Gf��7
)�A��׌PR����%
sS
G�
+��<�{���<RR�)�=0�b`Uɸ	#�����t����쳸2��T�B�л���Jy����C`@څ�!?Tm�7��[��<U��ͼ
K�ƨB17�������fdO��K���%6�.4{���W�l`&Ĺ�Ӝu�`7E��Z�r��؇o�U�0�mt��#,��	�YCS��C*�G�{���LG���)w�Ӫ����
+�

���Qb9
��B�xl胹
�fۡ,'�
q�М�� �J�C�Ί�G�#=8��hg+�Y?΂��9&�\T�A!'�p8�
]�K��Otm�Q;���2��պ�kz����~R��ʐ8�=,7�R�� Ҕ@
`f]�
\14D�6w9 ��D���)ʰ���qb>�5�
�P��
�Mb@�6�.� 
�����D�
�a
��X�5�m��_'�b����	R�Ί�Y�?
DS
W��7v����(�4t�,~�y�jf��yo#�T(i�;#M.�
+W�pѰ�㤄Dž�
�� �(&M�Bq��)��������b������g����x	
V�i��D�s�Zȓ�R!"
C6�Ѵ���wTW�FD��J����_�&"0����k- 󕹀8 ]A

+?���b�U����mT��|��1��)�x+C���Ų+�<uJ���O�c at +���X�ى��3}��c���C#�u(��- 
X,{W� �(�n%�l�i�t�Fsf�y�*�9s�� x�z�-�{G���b\إ�i�ra�
 - ������l8��ү܋���0���uo���d/���b`X��U�FL|S�\0�{�k�1.�q�� NTgx6=�#��a၍uW�)U;���X
Sư0h�U�&o[��
ր̪
�҄�d_\v��X򗽦��_)��b�.A��
&�i5��u�\V���mX��[F@"*bzS�â�E�� �t"�p\��~ph�<EVӌ�Y�i
����b P�O��G���(�<4y���欩���4̃8
+>ǐ��5��P,wJ
��n^��o*��#����T���*���~�#
����ERN����o��ݜ6�5,P sh�	�V����J)Y
d2b|�S FF�d�),��2
+\���Em���T�Z$�C�|�l�@�!(3��y�-�͢Q��y�Y�� 8�E��>�_'�?9m1�(ƅ̏X�}��it�3Ҷ8-�]�� 	�CX���S���V�Ӷ�
��S�
��É���Ȧp�f�N�Ɍ�II�Ӥ4cx�y�Q9� ���R
N�-X۞��c`�����}N;c
+L�졇����K�
+BeS�HHژa&[��m at 12JZ,�`T�9
CE�_�&���|��e$��r��gk��%�
���<M|����q8� ��iD.'.y�ن�
Љ�<$�}6�T͊��4�B50���8�����
�U�
?�
+� ���8��m�)�j!
����3nP��R�uů.
If;��
cS���`x�)���!�6s�VP����`�� ��'���>�{���s�����V �K����V�������H�b(F�gYi��e�!V������
��l�G�	=�ݰ�f�r��!��e(p��'8�X
�"���W}&~�0<M�)����5ZK�%�҃ќ��u�XCZ;i�٥��_`�l��պ?Q����~D	�}
߷
�%�kRpP��5��h������N(�U��O{s]z1.k��D����.O���"���#�W`��
��%��í>�m*��C^	�K�
4ϒ_b�aB竸�
��4�8R�Z��
+N�
�%0yfz
���R}�N����=(l
 $��`D�
᳇b@��1$]I
~Դ�|�zV�|��36��xp���+��6�W0{��y�ŹE��O�ck�-}�
Kڬ�w��r�9�gK��QƦ��=
�:����絟��7I�$�ͺ9ƽ%�~Os�V�NT�pţ�Ғ\��_��;����n�%��O
�G���,Ό�Q��i8�A"��->�܄�:�b�e�F$#�
M�K�<?&��h3��,Q�0!�
+�s
y�E݇��&L���V!&���_���GS� "��	�O
��C]��׀r�M`��
�(�0l
�y��
�',f�9���� 1�֔�	{��
�c�b2eP�&و��N=#q�g�`n!q����}j���� ��X"�*j���<�=N)@ڃ����
�`�rm��DR�
�'��h'��K�A�0^��>y*`��� ��30ЦC�њ�L�C�
q��N�TR��
���
�� �B�����5����Є�}�7WO����u�8\��i؂ph�a#�3����M��^�v�
����b�9�ҠD0�8�F'�ئ`��y�62����W[�4�S�6�ݭF#15@�Q,�r�G��|��I�:�O�� CF�D����AH�
���x�hw9�
+�ڈ�[:�@
\�����AUE
cI�ꀝ�ts �l5���=*}��],C͚�����$�N
�'ʖ�Q��'!���P�j����z
*·^6��X������2�6;/SUc2�a�Ձ?n{����D%A�
d��p���q}�����
x8�<�'j�0�ҸW�Kb
!���f%Bߋ�F`qA�0|ڛDtm���
+�uO�XY@׆�!��tWá��A��խ�ۜ�y<�OdK� @m�,� �����ܤ�=$r����g�1���yH��
J�$v�]��n[��(��L8�õ�c3ۅ1��l
b
yD����>�ݟ�'r�V~ECű}

h�\�7��ګUK�d
��'�%P�#��0�s�(�F���cw4�.��1Q�΃���;Ƣ�k[$�'U�)
�L5�x����t�e�zU�0NMD�]�ˎ~�&!Sn��*d�Z���=��q�:�~;�٠k6O��1\V�f	�v�a���A�&z)�1��
����f� T}<�O$��P���s-/葘�!c�Wo���c
�UM_�I���k`)H�~
ёw�X#8.um��A!G.��N�i	>�-�8 `�;���"��x��Hz
��zU�7o��ӂ��1vwך���2�`O��a;T��
+�\��l�,҇%�sjͥ$�a�����	S���K�%Vҵ,�q�e��׉f�8ݟ�0U
+-���?,�y��4=6�����M���M{�6��8���R�0����\��pc�٪�5.�{#r=�JZ��yt(�eY�KxY�OK@�nݤ;x(��˺�V�(9�+n�+̫�0�O$��"l8a��|�����n"�� 3��1����FT-{?�V�fAļ	��(�t���$��������P��_5��[������k�����	�-�q�f5�%;Yi'ۗ��u�#Tc,���~(�DF
�n
Y���Ho(�խ��>8��[�p(���κ:�[0���M��׈�xx8���t~r�Ec7��
�'/���*H\��|Lel<
+��P+Ӂ�b
'F�ʏ�
�fy�Y���p22��������p�9p0!�����O���nព6��E�U!TۙV�4Q�62/E���:��$j��B~_�Vr�
�[�v=����z�k�I	�*12�v~�O�4Eɤ�o-:{���8��K64P��y%B8��ӬX
{h�bsc�
�
+FM� �
���`��{��)
Ne9X�|-
h/��#tX
���&D(H
+W�
Ek�� ����լ��c?0wX�wk#��S��np� 嚲�$��
G�(�3��{�yf\d}�X��(�]�^Ҿz<�O�y\`�yj�B^�%q��� �/g�v����p�K2$�#����C��p>(@=����wT�:�^�6�2�`����0}����q~4�S��R���p�|�M'C
+�
��Ē�*�N�&KŢ΀�祍�8�����/
+Ab
*��C���A0~��m�)��SLJ�V�^�!x��~"�Sլ�ſ��A�W��%1塉5 �%���J
�زQ�Y��)pYAms!�h����%ʀ��S�c�oN;�Pt�
+� ��L��P�{E3��~4�S��(����Us� �!�����&l�V K�tI��T�0x��
.�"�V��tC-���`�L@�kg����#���]]����Df�
+������
��W���`�/J.�����Ꮁ$����BB�
:����C���k���(�
zs�a	��)�A�(]"J]�r �������DV�(��|
+���J��OA+��$�R|����|Z2W4=)("��!�����E�� h��4'6WL�Co
�)��N;d��`n�s[��7>��'R:E
��d�߼�b�Nκ�G�ܘ�� ߑ����;9����]�SV3�ea$m	"��Bm3I�
)d�Y(�0*�e��	�� j<@�<
��S:��I2w�
!b����L(F����U*Q.
+ص��E-������P�C �$_#���N���v(:�m����M��Zp�������$�M����\F�A�\�VԬ$
+��
�A��L�
d�UK	]����xXL
/��
s3T�6W4B��Yη���H�d��K۱�@)9�d��b!����mk~�D�2����{��Tr2��gg��\\="�
S4u��R2|�
+�8���0 ������L����kCH�`�@՚h�<UDW�0|;vn_�xCY�j:� z(+����YEp� ��,Ȧ�9��/��&�UU�nu�����<?�d�.�Nu����ҼN8P�EM�o�{�s�Ŕ@)��X�beb�7��Y�f�͋
15{�]{�
!͟��:�d��!V���P>�
��7L)�b�Y~��j�[�#|��
Z��(�bv7��8�;|��!�
8�:E�,R�$6:&� �X�@����O��?�r�?�����A~��T��&Ѫ�TTĕ�|NGљ�dܢ�
�iz�T�#>�-m�|�YL'�
U<�}�5��y��(Y��/GL'M3�9
�tS ���Jd�8��L�_TާD?)E�����N�
�$�3���*��x�
�_s:if�f�9��ŒS�yVZW3�

њS�X��� GODN#�N�Z��:L̊������g�}�sNڌ�ض����YW����֝�S�4_=Τ���K�g3+
��#�t7L�X�Ȋ
�
��VS�9w�Y�j(��*9�ͷM*H�X��;����삘L�We�Lr�(�ey�ST��x�(��o at I��PNwу]>/r�RDWn��*5�-Q��"�f)��N��%/d���o`)��)ǔ
-��f��M�&U��*y�4�i¼)oə�����_�W��	.�R(�=0ݰQ�>��K�Ճ󫺯�ˌ
I��,��O�n���,�g#`7l��P�k<+��� el&hvAM�7��
� �peQI��x�K�1�6b1���|��[�5�;��)Ys� �ɟUo��m�W��L��*&[j���U����H��U�K:�=�}&t��i�ٹHXuHf�e��$�!?��6z6��"=l#���G5�"�.��� k� n�t��LE
�L<T�Kj�g��
�=�G���&.s���g`�K��@�c""���Ĕ���._$X��/�]O���s�y�4S|�fTR�?e�O�/����jc�?��f�Ji�~gN���$�4=��s$
+��yA(��Rp��3�w���0}2-k��B @Ў�&8x0#q %D'3�� _Ȕ<
d���a>��eȺJ��L+߼�<�
*K����<#I�p�as����e��g����'i�
g8����ԕ
�]���[CM�k�GZ�R}:�$a�]Ҷ��� x�l��ോ
+h@@�3��Z\����.�cK����-�aQ&$�
{�_F�ř13R@��(j
��4=�H:� >�
\U ����<����i���_�&�U����$�����Fv|����(%M����U�û�#
+��	>V�c��s
<��v��=�3��ƅ/�ӷ�E�
+p��
�t����P�⬛��0S�R�!
���U�ᦋ
*X�Γ�P�';�t؞����v2�˙Ӛ3F����t[ښ�B�C+W�l}
�_έ�Ep(Z�|̘d͜�-z��1
䘀�:���ռ]a�%�� l�<!(S�2Nnк�k�OF�(��
��
�]
���;\(V���4
���UVy>�9o��Rμ
�Ch�z
�~��{`r�����=���!UE�K%g&w�aI�&*�q\2���!
+;�a8B
�8�HG7 ���–L��F?�y.Ȩ�;�5$D.�W����B��P�,��k$����RO����t�Qѣ-��}&D��6Eu\
+{d��e�yi�Zꦋ�
�fH�����ALk��ҳ�1y��tf6J����	��]�^���%�>�aA�o��}���ҞR\��c���ӧ
N�0 ]b���-��^X�gaIB���I�� N��<
��)�#�!
kQ�
]L�rލ�q��=�y��pt�"8
��&(6m�~M(��LjB��0
���V���Z��z��R	b4�l��8�
+��n���ś"u~�
�a&��Ipy�w��I`$r�
�Q��55���<
�s�P
�qFK��@tO��Tɪ�pz/9~R���)��%�c�"�yІ�0)����dF��:�	��܅_O��,�by�Y>!�6��ͼ+���3ّ��J$J��-u������M�[O�;j�Z��IW�?�Bsu����$�eiS�
'�x��T�75A��^2�Y��S>���w�P�h
A�ŋ�:f6�	߷\)�N-�Ç��N,৹�
��2����q�"�G����(��
��2� ��{.���Ŵ�ʪ'Nw���4/w3ć�kD���,���uD"wr�J�$ �O%��gB
+S����3��Y3
Sz\��5���
E��a�_�v
��i�\/�Gq3E	�h.�
S�,��V�@� �q�Q�%�F9ir���4�
+.��ZxF����R���F�p�-ͨߦ"O2����(b�]
}��B��J�G|��d�[
6��d0"#r3{��x��7�sJ7�ʩ	
�>�x��#�C�<�~�LE�c�k�ՐH�2�58S1Pl��o��ɗ9΢|Ǯ��-�J
���x��2��	Z�J!
>�R�KC��uuQh�,�b�n�c�sD!!Jcm�	���a�"��9����N�c�����><��YY
:�a_*�H@ӥ��9�����DO���O1�/�܏9�L5�n��2Bf�=��yכ3qvX��T��*N1z��!�
�θDn�����/�'�TL��tj�����ւSQ�:��8� (��8�`4 2������zb���+
C������E�Ṵ�-�x�d^̞����R2ιIWs�06��i+��i�"���A%"�{W]�:� �UU���
+�
��"a؋렉!:�3O�ً
�\��i)�
���
F,[R-NC��E�E
+�D�=�+��a�>��`��{�a���<Dw�R2y�����h"���
�D-�8�vȩ@:��!Pou�2�kM��HJ�B�\�A�7|����,
+�S�x5�N�D �	�?�u;�|��F˩2H�)�ĈL�
ݬ��a&G`d`:S��n.m�eG$������\Tþ��^U�Gd�	�#�E
��u$7�
Қ�5�Ld^�S��L��b�E�EI����N����v<��.!�s]�;�Ńdɴ����}]�5՚���έ�1+N�1
��o�_,!�t۰�j���DsxꡨF�=���9+|
��ITqMa'%Lش@x���@�46b�OII�C}�'�t�_SY<VZR�
|d����u�}��w
��n��]
���� aA��U�`W��d]VMhH"<x��Dd��)!,�tq�"{b0:����
��5�͂�`銰��D;�p�7�!S���BR#.�>4��uV�~m�m��I��,�Ȑ#�mY�4�>G�E,���a�/B�΄_�m{�!
�[Dk #4��1U�U��.�v�
� T>�:��M6mW�ox�v	8�����N��j-	
�T<��>X۰31�L�����6f�
	}��0R�����|�ػY�z�7j1䧓��1%AUp߁�C
c)9�
V�����b��1�9[po����ۧA$}�S�+'�<�ZBo}P�ZS�[F�9);�H;���f�
�����Ӧ{ ��E�*�*K��.d�n��F�ɡE�����#�
��r�At��r�X�l챶核���e�7��oFhJ?r\>$�'���\Zi�*���/]���,�eSU+YTeeSI�+F
����8�>�2]��z�5 7���f)W����d'�PJpڠ9�
~l
��"	۠��
8��f߶+W�0���7����_R�����U��@<�
+ʌ���*�Υ�@��O�$��v�� ��4м<:��X�Dу�����]i�
+/�;ݪ���썗JhR�Mq~���Tx�@c�_�6�.ɹ�(x������g)�f�&�|�ե���9�i�f:�[�
��4	
_��JSi	��8��|y��&W�M6���m��&=k�ya��7sه���<S?�I!��3 M��J;N
>�6/Ҫ@��]�I�|7�X��Y&�yp>%���Q�=xȓ�&�Bɜ�뉟�߂�5�
+9��<D&�*��^�1��gV�� ��>:��$
>.��hC�oX���ي� �&
+���'d�x�P��M
+yˇ�CN�R�H����j�6J��۳_qa��yM,��	��%-w�
g��V��J0��c*�
���Si3�ɃC�N�YP�eT
����.��reY�l`|� xl��Y;5�C4R�g�;��De� + at i���Jի���N�~�t�z��1�^��sm+a�۹{�n��b[)�7
*/㢗Z��m�
UJ�r��4m.�Re�J:�z���y�DQ�W|޺6��)�5��S�Y���sܚ�K(�ar�Ǝ��tW�
�y�� 
=}
�_�)C�Z?OR�&#�P����mp�=%/W0��

���\/��}Fy�62.Pn�/ē�J��@���4=��s�룏��{��b&%���1y�P�RO�\|E
�����uO�j�@E��%
��s��šqi?������(i����՚�'�i>T���p��gn301B��l����
[Ӣ>�ﻺX��
�k�]��a�{��wf�V���g�I��Y]:�<W��_�8�?�6���#X 2����X
+�6Ì-=ͨ�MJ���tj[�1�,>��@��hv�w�@����(.�J˲������jQ7.�ǭMs�����Ȗ͢[� �
�N�
*B�b�����^���,|/}����E'�)�Έj$�;��z
ᢠ
�#Toi��V
*S�hrX.w�M���7C�y����!��"�
���I�g��=\|R���Z
q�r;O$9#{� צ��齙�=s�Y���dtJ�t��Mi�^dϹ�dž�p�>!k�,��g�ן��wv#* C���|z�UE���?���#���ϯ�� �~>{mD H�?DqDS��;�4����r�Xo�\]�*�f��z�u�K�,u(I�|)	#;��LS�Y��
+��v��̖��K_7~��czKL�H_
�
�!"�����=j(��
��b����$�%�J��9��-N#
�5pk$�nA�
�L�3/�めØ�l�I�dUd�ӭ�A
���C�������2Y��
��x+�/���M�SÃ����8�|M����G��!���ܘ��ɭ�ϟ��

@�!x\s;�˘��w�V��rbo��
vW�+�&�\/�w�ŧUy������t|�y�E��C�M�O��j�X�:�7�X�m:��(//���tK��(����g#�S��-��t��\|y����4��i��՘�SPg(SLQ�'�9��GL�1 )5U{�{F�/Ϭ��5���I%=a�~�|�{E�Ù����]^�
"a�����f篫�gO��<n��z�0|�di��B����k�}�S�885X�6;t��wv	J�^W:�*��+ �fS�/���׻��g��h���2�v��
+
��7�/R܂d
B0�K7I(
Nq��'���'9��p�~�G��ӟ�/~��_������������������o������?��}����՟��/���7��uX
��NI�������?�������x�������?�O������
��ݟ����k������*�����];\Ë��k���"n�?���ݻ����H�#���o�f�K0��Y~�?�� �:	k�MC���#���3��ݝ|q���;E{>��ǹ�
+)Hu'B}ԒO
�!����q�?HK��,>6�j�OB[O6V,�A����~Ʉ$n?����e]e�Ġ?tFJTl�������KC��ƅ5�=�Y� �)�'�j�;�r$�}��
Y�A�"�m3
2����|iæ~�rl�$�V$�n�O���F�F����޴��
�0�e�̪� ����#@*�_ �ɦ�
��P�!��Oy45p��#y�f^�&\k"�^_��2�ge�%���
;�'3��*$&( ��0)D�Pq
�D
АIj�G�|:��N]-ٙI�W%F�7;�.+O�i�Њ�&h�ɼn	�*|ؙt(�������%�#�A�
_��&�}�,�
�K�	����R�`��C�$EAsr� I0EXEH	`��]��ئ੩�n���}�b���Kbg�&����,�7_�_P�mZ�*��:�|Yg����V���'����j,��q�E�Z�̙1
���*�\iF�ڮ�(JvW5.�o
���zީ}AYq�<2���Bt�ş&��i� �	X�b˩ju�� �
4�I���Bj�ʼnH9���X�u�
FƲ@f�p�Q Q��z4 V:)2�`V�{�L�e��ᇅ�n
������Es��C�d턻 ��Ŗ�d���y� �o�֏"�<�N��~��@<R�I�=j�%�A�хW(R
�x8"a[�4"�@ѴJ�[�P�E
�+�&�I
�p
��RPn/��$�8�b.��g�9+������ X�i��<�	��g���B���U*��)j�I�4/
W@|L�M캂m6]��*Xm^�ia
+2�u���bN��;n��X��۽�/�}���
�\5J5�+%���\�2nG\r3�4u�rR�^���>L�f������,
�
?�o��r@��m-Xʼ&����=���c�.�ᐻ\��{=ZI�$Dž
 �o5kn�E5��Vٱ���[�P��/�ޯ#�n
+|WC�6-�y�Ŋ$�la$
�~���es�
����W�C�ng"~
��nlK5��J:� �1�(ˈ��w~��ʨUns�K���2D	�y�
�,dx���u���ѭ��(>}�Wƌ��_��Z�}_
G���2�G�-o
a
B��PJNF�׉
�Q�#�B�<U�%y�e?�!>�/�k'#;|�o�q?�
a�3��bƅgUt�3x,�-�ߐ���|"��>&��k� �Y\�̹ Z��*S�
n��Ge��"܈_
�Di;Mz�
����Żu_\�\7��c�^38��*�
NqP �Uz�3I||��Lk&�$�
ps2�w��C��"'0$�7z%�����djmr�����%�zd�<�5�KC{j��#���Q�%cM�jJp�Γ
~'���άޠ�=1��_�N�k�EЏu}��F.7w����]Ä]C�MG�����2�G��5s��X~��Q��ڦ�1>c
;"�I�G
G<
Zڇt��N��tmH:��>ks ���\v�������Ǿ��S�
�̭�����"�w��N]*��η�|!
+Z�K-��.os��<��O��mI����w�Euǁ������� �d:(&qb

O
	������؏.��9�m�R�<^�����1� TG
�_"D����1�=t�|q�AMZ��������6����M�D�(҈�[�CR+��g���V�.�Bc&"��e��'�ue��΅��F4�u��K��n�֮�;�л
+�M
��ZQ�q�
hi�]������G
7w}Ԑ�rZhC�
+�ę*S���z�G����湤K>�9�M0�y��嗿ڱ���K�
S�Bg��X�D	M�j��o�5v����'G2`?
a@}��6�7��
�R�o����F���}
R��=ƞ���>G�ƹ��'
��|�u���������&q����H�̘��(���}�
J�ܖ�Y�c="�m
�:my]���[|l�cq�1n?��f�؁�W� �ت��+n{�e�o�n���c�
Y��vz��]��6\lϘf{ϊ-<.�}M�x��|=.��U�c�vq����s��N�g7s��w�H����Pq���xp�\��e��C{^���8�o�k���c-��ۃ�Cq���<n;\��;�� �����`�&
.�,�ӕR�:K�7�*.>_�ru�n;Cxu��t<ܿ�27������4ݼ���V�?���c����@����O�u�\�ηg��͝5��
��
�_��\<`�y��X���n����.e�����`�Ə�.MYRN�32�BГt@���
�N�%O���s���-^�
�M:!�f~�������쑢y
y_�a6"��M��K4�yW�bw���6�Ia�EA���!m�!0�޸ [...]
+c�3<�_U�
Er�5�\�eN��+����R97�
���ȅ�"i>@���l-s���	���
���kE��&��1�"33��LR��G3�y�������
��y���;����q'f|dyH�1>=��k��VRTݹ?��ҧ�^��o'yc�Dc~�^��h��,�
̍��
(�M�	�a�7����_J���6di��%NU�Y�Ra�D�&��
2�.pή�'���(���~��Գ��g@ĕ��8�4w+t��ž�Ϋ7

�T�~
�/>�ɲ��!q>qt-��.����m�_|.��_�20�oj�Do�/��W{G잎�h`H� �Z��jg����*t�G
+��*1/��z�֌ۻϋ��ДJ�q��fː>eM
���$v����2�`	
+l�$�Gg@��n����o�,`���C�
vd��Zdʆ����7[,P��j�ԮF
��y��eKwT���i�
P$��{���c.Ɠ��8��������!S�`
+��*��&��b
n�b�D\-S�Ё�u��I���!"� �(�Q
�.
+ߠʒ�~ �6|Aښb�*!�2$�RD��x�|����q����yP���^���*�a�
HTfr̟)9�l8�nZ�=�(v�n	-��h����ܪ��@��S��k퐪��~2Ti���X6>�X�
���ܠ�,����P�97
1v�
�
2�D�H1s2�ܴ,Y>�sq�C;[�e0
+�266)�5l^h�"�0yZm���D5

�
���O��L1pڵ>�
A`��C�~�Q��ʌp�}�
�4vW�8�v��d�<�l�U�"p��<J>�v���@"
��k)� �lI-Ԩ}�Md���@�](fW��X�
�R� ���p�9C�AJHb�0�PVy>�*a/����X��>]L��
����$7[l��:Ĺ�%��b�����J(�ר�33
f��G,�b�ð�[1�H�UeO���э�թ̣1
�>	�N�.(�(�����c������qV�Q6'�m��zl�~��1ʫ�_���g:��l^�:
;>Ն�RE��ݯ*Y2�T
�ܥ�&,�I��/P��"�ۧ�"��p
'V��
x�f��%,NW�|Z����0��Gg1HN%���Wm�ڢ�8��|v�w�[̆�
�H�I);A�􎳡u
b�W����cۊA�8t���U7�"�h��I͞o�g����W��|�s����ƥ�n�����[��t���L��:�p=�5ժ�-6�����L
��zX��AT�dB���l���ĝ����
�/M�6�c�u [...]
+��1l� @���L�[�H(�h�1
�0�f�A�S�0�B
��/���3����a�k�
m�;c��A����!E�29*�`�Mz�[�E�6�3�[8�P��O
+�v.61�T�?ߟ
������pn3��w�Fі6��,�^�
��n�9I��jv��пᤥ�U`�C�f���ph�&ek������=���j'lj�@�g%��6����G�)
+D�
P���{<�%f�*�R
bS�!�yK$�A&;�I!��!�EbN��c�J3ȳ"�&�2�2����
�p	0 at E*:�s��\��#ʎI!g�l|EOΈ��x��oe�~�.��D�Y�a��@�@��&溜dz{h�b���F�ـ
	��d�j�t�T(lE��g�޾%6i5wRfcy at GoIk;�� o��h�q�Z�R�7�.�@س�&]*��v����a/!��8 �5�p1
�M�;2��

�W���W�?�x���GP ��{`{`��{�3�k]m�R�KV��<���G�.8���אK�Q.q]V��Nm�jzv̕&yZ�g)����f�s����3�1v_�4
+��
���T�x
J�FE*\z���aj���\�ֻ <ˁ�p7�U�f��*�
P
X.�9�&S�1�X.�,U��w�
�냞ӣ�f�L��=����9��uk
Y�'7� ���`3=(���,�-;1�B_t��(���K eQ�'� i��6�rw
7�‚�� [...]
�0�M�!��
+LlK�*�N*n���y袀�+i����@y�,��ü�q�R�=@���W0�e�����O��g����������������������������no.3GVJ���bQ������?�
w��o�K�3�Hq���E�����[��(�
+�Ba0�Û/�����������[� q8��ڧ�c�e�����?�1$Z
��h%�nQ at oԩ�U�7~�����������ŝպ��/���o�r}#�
������
ϟ�'�l�7�2š����������/o���S~N�!m9v�^j�|g���Ð��������^��ϔ�#�HWq9XDA{�9��C�2�鳪.�dҵH����f�u>�	A
+Bi!���?r؜�����:�Gr���)����
�>S]E}f�Y�h+�:Z1�0�K��C�������O��d.��@�� .�
Xn���ˮ&�}�M$<�1�9Aq��
+�?��
?��7Ǐ�1���ncT#��qR���3�+��������ָ
D-.<'$%"�N>r|
�rv,��G�ߛ��B��2�����ۘ��b
+�M����:�,����l|o��?
���d�
+Ӈ�JLG��a
�?e˂�1Їơ
����{��h*,0-���g�`c�m
L�)��q�sD?M�\4�����5K%�e��-
%��
K��0������
����9>��:���
`9L�Fc˪��q���H��5����/w��T�����{�IM�y���F��E��c$q����o���
r~������;>����{p<��E>p��<΃�}v�v]�yT��>s�+�Y
��Wǻ�/�w�7|�AK�#���"��>�x�>�I�c�۩��?֏?+���,���TL\.�ˏ�_�o�����o�6N=>u|C\��>�S�zr������4���E�ARr3&� Âx��o������;nS�qJ+�AV� �ø��>�W�!X�?Q�
��Շ�濡}_�o�)�
>$0n����_}o��C]��x|�^��Y�b����w�
�Y�׆T<��~�?����}�����y_�~���~�K��]8���Gv_�|>���˗>������p{�}�j���?��I{�{�h4w�+usS��H��M%[y��%��b�W�5�b�l�Ij
��:���@]���� D\eE��J��DZ
}BoA���/@�+��#� �[w�;!
��Nx��������gۅ���d��/��n��=0��HA 7���HI6J�a�
����w4����)�<\SL
 `}�����)�d������q��%?{�ӎ�
�1�"���34A��^�Dq�a�������+d��+��-�a-��^� XS5
+|9ЦC�Ž�q$�hB^"O���Zj�w�
+ ���$�)NXo�G���	�$� 6
+5�7��;��
)Jz��i�
&�g۷��AZ��#�7�����,��l��s|��0�Z�i*��e�Tdۼ�a��>w
[�J�j���*u-�%23�a	Ϋs6[�;
�xL�)
���Ư��~���.�N�F�`ۋ9$y���B���5�7�b������ͻ��?����ۿ��O���7Kz����0*
�{I���T4��
�����q�B�O����3��z��̟
+q� �� ��_����|���',�ǿ�˿��_1K�I U�"�hق
��[(Q����'&����z1�=z;
?��
_����~�C#�Q�#��_�2��EJxc3��&��E72�n��g8�4�_��ąW�|hy(�
�V{��'�vJ��=�T�]�
�.�%U�2�W��4�.
u�^�C�'3����`~��E"�]
9CV2a��
��T;z�
�w�u�T"���kZ�IRI_�%��]�W���E
�zK��K��=���D]�%ƒ��;�绰��Hw���j����
�
��r��l#��_��1H��A,+e�@�N�t��s0.��������9�D�
>�!�Y�M�nVn�$�/�I8�(ǧ+:���ԱnKg�<���U�7��f֮3ȖP�JP��8��3�!�ܹ�_�UQ�-ze�v!��ŜY�
+�MWp�����F���K�L&������h�HP���CxX)�Q����A�a	}�zB
_����8�R�t<�9l�6� +��
ȄE
�i�@s�3�!e�5�̓j���!�K�$f뎂7��[�T�[|3�9������z��yJ沒ҧ���5�e	�
\r�|
��$�J�9S��
�u3(�u���]�zr�#5k~o�R���D�_��[���4
+�i���z��JxG��7�1�
+�:	
8Xd(K���T��L�׎`x��Mm��E�
���WqsP�x�
I�_�%u�EN�!� �z9���P��ZU
+#
�E���|l� ];
�K
���G֩;V�� NN�n�3�7�	���u���

�%aL�P�D^C�k������Vg"�>*^m�a��ˀ�[(x_�#��ةR5,�w.���Q��e6�
���C+�j%P|ml�{M`��(���goO1V�(�Iy�.�|�+��%<��\_X�jZ}�t
���_�䄓�$Q���N��[ W��Zk�C�i�ĆL�3�=�I�s�瑴���R�9���Xf�+�6���,F_$�
h�
�8�Mϩ��x�1��wK��
����1�@5-~�!N|����v�pi�!Z%?e
{�
K�O	�

/Ή����n��F2�6�D5�Ln=/w�qۗ
+�xl���;�}��i���wI�T�������,�[~͘Ts� �
�i�8�
��>�TJK�>��R	,��XS%
���m+� @�Ƣ��Vׯ�s�=G���s�G%i�� �n;�<�Ns^Gu$"] �52e.��x�� ��J�U�0 at e���Ep�A�!K2>�.�>ŧ؇Vk�Q�����E��1=ɀ$���XOA��8�*�/�^U��r�4�x
8�ӣ
V���
׵ᵦ=
+4Ш"����
R��P�+,U�DJcqo�	 �6���A?�����9{*ͽ�
��̙�
N�'���8� �W��X����n��X"��\�<��Z��f�X`*AM�@v�=d���}�+�%HHg#ɥ�ؑm�.�	�
�<
��_�脻	��P
`:��䊊*
�� ���x
$��H���S�%*��Ho�H���
�ѭ�
-
S��(
9�jO�LFOx
��m
z[ƒB������*:K���r�
���ثcrn:~cc-��;@���(�B�"��QW=�V��E�1K�����]�5��*�3/T��X��B�m�u�+e��C��ie��VV~�-Nte��KzX
����,��rX��iˣ�ݨKI
������8,W�tnr[�u;ϚZ���%{P�l�|-e<�A8�`�����uu���/+4�#�D� k��6�Cq;��M�l�m�.����,s���-԰;a�di��� �k;T��xܠ:K���:��8�Dܱ�Χ��iM��Z���խ�y41�"���M��k��J��a�G0��
CsFw<���?�l �P�_l�hU��Ϟ�N蒤�*(�^�fTIA3�����tbI�ET�߮�H�ݐ
�[�ӥ�b/�������Ll�ʤz��xenՀ;/��h*���u��@����i{��g�c�23D
縅��Ru��C�*f|QB�e_�j��cF�4Hcլc�5�.ķ8�)t��d�"
�����3�D���B7�o���p���=!�P@&�p��Z��1�
����$���
�5I�0腱�Q��>A��] �/RK92L��
��	8ΣE]pA����%�T_�3�vp�ego�D��4�
��I}�\��6�QB?q�Q�b��(�҇]�Vf�J�c�ͮ
���Č=�L��F�3�:6?<����\�bMO=��Л������[	�R�b0:
�PLJ��S-��}$.���HI��<B�
��Q�do�"ą5b�V.b���S�S
p
�l̠'EL�l��=辯��9�ġ�-�lϛR$s�6h�Y��� ���Mi�ߦ��qX�	ble1_�~{�,P.Lm�� a�s�LQ��gJS_[L�'��<�H43�,�ۣ�
�Ui��"�J���a�����E���2�f:a�M�uhr��V�8����`�^�8%CT�tI%
W{�2	ʛ$۪U�ڬ͒��)�#L�J�&�
�S�r���j�D3�����
+�}�묦���L�RA����H�%�*�q|y�%.�1J_�̺H��8�đ��0
+�K��������
+~��[]�t��d��h�
��~��p*WK����Y9��X�1
���#����B
�b�5!v�#��ⱇ�8��K$C�XQ��Mc�{فK�-�(\D4��3�5}���
9J��ڐ��z15{�J0#�O���
�?a�1��.�)��kB
h��B��F�j����+x�#r��$�I�!���*5	�X�t�I�u�.�R{�a睸GDf&�6�me�I��0r�&�m��x����8����Y=<H*���_@��m`7���{��K�۰E�ͬP�}��۪H�ΫI�$7
���,e�k{�夭i(��蘻�n�ăS��:(���=@]c*S���I7iK���M��*4���d�8��u+�B��<��c���a_|� ���5k�2]
��A�
��8�jh�����Q>)���;Į0+J2�Ԁ��Njg��R8�芺e��
a

ʜ;�BM�e
+���
�ӧ��

�<nY�cXoဲv��$ϖ�}(
9V
+��K�ɏ�g��u����$��N�e�ٱ

C���X2�á���B�q��U{�mY3�t���݈%�W�CF:,�<�C�K�R��zVLOY� � A��1_
�[��C��	
+�9(�%�V%�u��=�����
�o�r`��F�I��!
��k(G--�8g9S���(��b$��_�}EP�RL�1�+��#S���e
T�-M`��T���u�sP\q ���Q�S�F#Ie�nu�L�3I
�Q1)�WU���K��g���M�U4
�(��3mAGy
WR�K����
)���
)QTSG9�@z0��L�·�3�U�ZV��wjdI�D�/�	�P�*8/��
�L����%b+T�A�A"�&e�v��\�kdj�GАcojl��@n�!�


	�FQ��i����%
�Z�L��I�F=���=�-�*3
g
.
���ÉD�#�\����S$������7\R�cl�rQR�C��bSfw��W�9�D�9���!��ɰ�"�-���,3�'.n�l,)S��ʲ�50հ�l�N���b%y@���Ȕ� ���b1��º�/,�m��������Ʀq�¢]��6��d���	t��&xvú
��n�D�"����KY��ݑ�ɂ�\ [...]
+�THt���������pw���d���Y���E���vS
v��	ú2�9��L�IA7�LA׉=�J
�|�
� B�P(�	3	Z����IC���%�O��sQ3ܷ��(t����yչ�^�] �l
d&�`�
�To��)��/�}6!de�����0��q"
������y�IfB�Á�H�
����=R3�-�9�qz�WA�D>���ng^I���_*��t~'�X#�wR�-�w_�$�Q�r�&)�phFn+I�[-^]�������5��N��@��-���C�$�rv��Łt}W�B4�)Es2�i(-�NF9~ �[��2 ��A����ײ�<�";��x��S3
�Y�(�nf֗�
+~�s��j��E��
k�8+&�#X��rO��p�MYp;��"�����{#�0������;��B�O ����
Ȼ�����
��_R
�
R��
|���=��(s��P�
�ww�@ ���Bm���Gb!0x�b�"]
m
 �nP�Qx�Gq���D�_7/�	��X�<�	�G\BNŻ���)2������[O�z��2�L}�2����ڋ
s���5�c����+�'�€d<�u��su�=^Z[C��^Z��
\q{iq�]{a�F
��e*�^D���a�5�v�v.)$��9��Wf7o4
8�L�>�=N*s��9r�K�η)e�\�r�(�ul\����ig:�t��
��bc#�邵
�H��R���H��n.6#Q�A�i�"���ٕ{�쀄�H�`۠H���&2/U�o�*�Ơ	~����� Dv��Y��(x4$FXcM�����C���?R�Z���
���j��
I`�8�6XJt�>�l~��?��o������1h�����e|�?�f��͞q��_
WӅX���^��h��������#�T$B�fu�{s�������7wT����˗���bP߮��$�5/u��	��8|
���E԰�⇖�!�������eRx1�az�.ƌ+_7��^b��P�p�A�T� h��<AGY�+�O)�����v6�
*����k�h����%��4��:]?�mH�-����/�믾=��~�o��'5�	��q+
�U�r�U Rs�M���t�//
�S��ѷ
c����@"��s��L|��(_x��`
�� /X�X�:R˨]z�U��
�J�8f`��|_
"��/A�Nd���b���H��ì��Px�{�>f�׽B�/��
��b	��x_��X��^�%�=�3Ý��/�E�R}Rɷ�3}�i
+���ƬO/�)#D/���X�� ��Y	���8+����~����{�h���J|�\?��k��ƀ�f��4�KG�E�i<
a
Wa$#�^bb��S�:{(��(׆�J���s�����m2���w��N�>��\/�u�������:D��
I|	и�Z~c�=��}꾛��%�\��P��',iA�hjx�C��dz��
�X5�c��NzO�;
����w@�
����6E?/dA��P��	eћ3�|�o?7����n�6�.#;<ɖ
�M<&˻'*眪��/Z1�7����}
�o�o?�PFD�t
*ˏ��|
�O��8��[ެ�����olp�M�I���C��`#���&#MP
�뻡�^b�ŗ���汷��7=��7#t�����WK�8䊷��}}�Z`����g�m��c��o2�M�;Ulg��C����s�uu��+���i�`
Kbʼn�Bw� c<����Ed����w���|�E5-h*�y��;�����$z�
+�$�1,z$����b��8��E.�W(O��+���[���-���u���E���S9b�x����v
S�����
��
��� d�8nu��i��qB����9n�ꎛ��HB.D���t���x3c><ч�~��a��A�ՠp#��xlt����i��^@�s��d��ۚ�����=��D��E�8����ߚ��8<�飵
Ou��
_V�3�8�L(<�ӷ}��k������"�bR�B��!"2��*
���=@H�z������X�r�~��#�~�סk�JJz=��4�}��3ha��3Y�:>���ڞɑ��Ë�m��������&錁]�:e��mu��G
+f6ۅ�$
C�/�X�+ʏw+/�
�5+�
�d4�CJ��$���|��#nF����ܼ�.? 5�l	w,eiX���L�o�7�>
�nP��<�u���=o�7��=���f����_�?�-p�q��=�>F��av�U�Dɲֻ��o�৳���~�q�Y~���q�G�!�MvqH�{���꾡=����9�?,�w����Ylc�j�����v�t6u
��u-o\ �����~;�2ɀ�$V�
�8�>P:�����M�Z3ݛ�P��E�>*
���'Q�Y��$P�r��돞ڄ�qz�ᚕw�Y��fv��b8}yZ��1 �1�
�,��暡��O�z�o�
on7���I�}�{ֺ��f��❖osﴵ�u޻UWc���Cn���%Q>�܏9f�z�?����ys#����(�PE�pn��q��w�i�
�?�]��v�n��߮V<Ec�nx[|�����BL�]��s�r|]��5�=�kv}{d��3E�>�
+k�Ɔ�������~�P҇Z8a�Lj�s�?��V���I]a?�u�a���
N����X��G�5�U����c+}�owcGuX����}������
��QnQR����ԇ
��8~k�=w������t�>n�
�Ǎ5���O�0�}���.�M�ɼ���
���K񹊞���R|�o�ݷI�p����K��Y�(�v�}�����n2�ۚ
;׻ݍ�
�p�g�#R
���[l�u���A:�H������F@..�՘oJ�Ӊ׷�~_���؞�0�0x���
����RtA	��#$�(��:8%ٲ�)�e����|�7��V ���^&��Q�a-u�ɵV����F�m��
+>�d�
+N��ܱ��@��;F�dU��m�� ]}��1��6���Ȩ�1��Ƶ�Qt� ��#L.��x󣈬+
�����ROl�{�|���~��F��>_���ݜ�Z,�FLRhaK�4��p���I�o��g����}�����P�g����\�3��!:p�g\;����^p.���:���Lj�B��wW.鷦�}�>������;?��o�מ��pGJ�H>��33�Hk=�^o��m�>������`cs&�Q
DC���9��~7	��	�y��;�BӔ�ob�;+J�����L�-=z�˵����p��Ʉg��mF�y3ϛ}�D���g!�9o3|���
h��Ly
8�y(��q���]�;�����!�va|��F��X�~[1%R\$�a"E�Į�n�
+�	��a�v	�:��?�ޮז]�{����_J�U�7g�� Ao�F�u��6V'0�O�~j�A�$��\{�o?h�S�V�DRE�
�>)��
X��Y/NZs�W�Ok[�
�H��҇[VI��/���:��$
7+�wZ�֤��}�w�-�m�q�*e���&��,D�9ݼ1<��[F�ԛ����<�yy��hT���|Ŷ�F������7�}�c�\��o���	?��:+?�W��
(����@����
fn尺Ig�4Z9�[���Nt�E�$l�OO7H7����\���4ʖ��n�n�c
�Ah���Ү��[����Y�3�q��!g�+�#XR�Ѫ�����yW��`Uc��
�=�=���E�jM���3�_pg\N��%j�^a
�$�\�'}
�v����f��{叛
�
��k'�{�gO���5��y��v���tx�/W
�u	{)�K;t���^Q4���r)�OO���{z͚B��\nk�Y�|���ݣ��tv��L��b)9��sQ�b���p���kf�/�CB�g�,	7�CfɊp���I���;U�Cgu0ͧ��t[�ו
4�S�
���aoY<�'���
���ӿ�Æ������z�N'e��ȳ�~������h�C�{K| �L�W�v�<lWȓ�����5鳵�2�if��f�5�0�ϗ����m�%	��Ο}+�y4�/W���Ϭ�ެ'A�雒~�]c�Q�cg+��ƭ�
sC3�s|@7>
�X���yB*�H��pg�DO��װ�5�a����	c3�|^C��x��rG�Z@� ;��Q�jϞ���>�;L��[�8�WT{ Af�ț���inC���������26a�)H�ߺ�
�
�5e~�c(q��La������M5��=�qyob�/ )g��yOA� �r�ջ��rZ.�`�q��0��ŋO�bC���V���PBE
+,}�4���£�G�1��ӊ/xO[O���*[�je����H���
�J�\������\�N���>��
+�˶d��'+��c�u�����Ο�)�L�؄3��m=}lⰫ��?X��&�������D��4B1n_eV�����K<��>4��>�J�d��N���{^�}ڟ
�>:�E�����9WgRT��������(:���?�)V�9�1 �p��ċ�|+�x���Y$�"���Y����j�lچ˽������u{~����c�xCΆ��_N���Iz�y�*7
�G?��2���+���]�%�<�����O��0~�e��'��?y%r�T�2��I�����>�$�mQ�+���
G����7�R�����������u���9���
d—���{-��q����(��:�é��
N����zj��[l����60�ݨln��3�zSd	G�i�1
}{ҿ�m�|*ȅHg��4�sJ;Wib�&�/�4�W�t�K��Z��$.�4�D�-(j��GO�6�yy�h�5���̬�ި�[����I�O
_��<����q-�1&x�C�>0&��QC��H���y�84Zr��р
+���m������L�O�e��n	%(�:�CB		��4/o������:m�^h�N�Z�zM)u�
+=�򚏞f�yb�̘���0������c���Mg�u�J�z��f=/�I����I�`‚UU�Nˌ�Le�Ԙ�D}���Jh�i�2��6�jP�`�˄���r�����<���N����L��|�Ĭ�bV�����+�G��Y�%luO#��3\�{?<�?��
�$�� ��}����r��p*��gK���:K�e�H�q�}��G��m��l
8�'�J틐n�[C������Ig罃
S��}���-��(���b���4E�[o�Y?��Z�gm��p����2��5jT=�5֔2�H;�f�74�����bg>T�Cy�8�&Z��^�8�|�3l���y�/��9���PMK:�~Ϛ�i�Q[<�ɬp�[�t+Z��G��=��ov��]��BDB����Jx(��n�
Ѓ�p�� zK��I�?��
�nTiV~p�<+��1���~���ߒ�
Cn��h�5���AM?���1&���J�ƪ���uX�0,��4Ϥkf\�m���Ǽ7��Z�S�e��L��]3-&Fޣ�s{���|���+��Z��+����f�BH
b�\�b�3�^$A�R��2k9u��T7�+6���΋q
�c\C�̘D�������M�_�c~n>v]gM=6�w����)����'�4m7�3��尖q�b��?O�D"?O<��O$Z:�
a�g�g
+:��L�s�����7ҹu����_�Y"�u�vH�/yy����fo�0�[�-N����eQ�A���V�����{w@��Cѽښ��YsnB�ل�KjL�|�����>��0}��
�|�c��Ya=Tڋ��U��'5f�h�
�Sv̓�K����}���;��&-�خnx9ڬYf7{��
����
�e���#�Ѭ��5�AO�8�QS˵҇8��	DE�
B�hK�8�.��
�^&cX��V
�Y���
�1\O��������|Ǯ�>>xXD����i���<Ґ޵���^W��sX�f�:
����c�:h,QR�̡�Py������ź�X���99�YT�1Ϣr�X�'��`x2��n�8Ao�܃�`o�r���Lۙ�k����)�� �a���Fi�b~�|į��0�Ӡ�>g�
�s_��
����S�}��s����M�{}����7NO����K�
+=
�G�/���ҹ��p�,.܏�^��l'@�Ȋ�t�7^��spv.�;	�,%KI2��'�3bE��%�,w�{
�cU
���͒��O��XS�={���N����|-N��8�����}j�Yi?��}.z��VM�6u����aE�{��r�cOs�#�ׯ��]��"����,��=)��ؒ��4�	5rE즤���t�'��`�CwM�m���l�ٸXg
�$L�(W��-{�����G�IaǦ��
^�*hVQ����:�ix��G�}}�w�gR��i�}
���� �.QJ�

O�q��e�x�4�H�	��������4 at 7V=M�Q��%ts�=d�'$�=�v`zb���X�l
�
l�{��k'�̣/ا����k��Z���l����=!˗�	Yk��
䝁�+��
�|�.���Q\fqZʜ�'ɸ^�2P�i���6hI%��,�d��Y&f�Y
+��?8�?������C����4K�����j��$�
�ы
+a�ߧ�K���囜�Ky
�v�䛪��W����^�D�_Y

קKvvs���	|n7z�;�g�)�p��~���f��4������vKk:i���ieG�|�-u�B1Oz{��y�{
+Y�/a4���g>���z-ۯ�����>������~�
��v�Ϛ�$z*�Y3O��5
f>���W�i����T uLktS��FS���\���:2{�`��{����3�
�W=SeE��\3@�c
�p���
+�l-�ZZ:$�
���e����"Oh{|x��� ��L&p��}�
H�5�W��%�=���+�ؖ ��>���4O�x�1y�Pޠ�_��:�2G�
q��>׉�s�����
F���r�W?��d������z��A�G���^ l�ٹ��
�A���}�9y���,,{�\

+`
�MJ�5*���+�	GC�Ec�M+��1)�Έ�m�{ω&Gp
�:���v�^��Ǘ���KmЦ�L�Ц[���&�����]�欓e����
���
�1�+�ޘ��Jcd�"(���{X�WJ��^5�!�,S��*�����ȗ�[��w�Gr�o��@K>�;�/�~�뿓�~g�q������ߞ^@��1���d_���Nb��ĞpQ���Cy|��
������l���)ۮ�,���E�Ш
z����nvK��%s!�/Ż�y��6Ҽ�
��ݖ������&�j:x��"]<e ^��n�7��ЋЋl�Y
$B��<$j���\��.d��h��j���ndl�2����Kn/Y��B8g�})�m��d���#��
|�Ǜ3+Xr�(���=�~r0-�z?�J�~�e��X"~�$+���^��8����U��XnY���ʮ��
Ӵ�4J�<>X
���Xn�����In _tkUh4�Y��&K�Լ���~�=^�lԅ��\
+6�G5�S?lV��u"u�Imx&l]��%��:��Y��M��������5O�ϼq����DxPj��
r��fVFK�5��Y�-����v-{'sْ�}0[T$�����
�d�lY���u�4�`��]�v1�r�FKYʆ�Jhr�'��l1�`X�l1�`0�����5]��C�o�v�i8Z�����\�bو����}
�}�.�Vw�����_0�ڟ�k�~�A–Վ��
�� �NL�,�Ű;�ش�	�kF����z�E?��/ș�9�`�aJ��7��?���|�&���1�x�xjW�:��
�>���##f6=��XԼ�mA��A���h�Ӯ��j��-\N{f?�†t��
�2�VP�?�
|�˽��߲����돫��*����
]���%T�ޭ��`<@-�@����4�z|"񇩹Q{>��bg*9?� A>o�����
��}�n�(��>*�
�yjB��gk�tn{0v���R��YB��|C��驼{ϊ ��
+
+���6��~z�\m���=�W�xk}̟�}n��_(�Y�j���X�{\���sfI6�CZ�?̅�4�v�lG/��Ŷ���s�Z42�-[42��C���p��i3,w�{��8F���y|�j�t?�f��.���[����yv��}Y��ݭۖ
	�)L?v��3a��殱v�y�k����&i9�fK�.�^��Ж4T�����Q~l�ce��+Ӭ
�QǢ1��7s�g�
�l�D��(A���
��4?�b��*~}�)��z�I�5g�5ݵ�n�5׶����&���aU����g���m6��ctN^~�1��d�+btW��ͦ^�չ:���<���
N{oښ����j7gh�Q&��[[��K��
��r�sM�����M���s�v�x�$7�����݆~[��f�5�Z����c��63�|=n4u�;
��Q�����C{�ʜ��w���گ�	����'Լ�O
�y).���MF
�
�5�vݬlfe� �@���++譅6���ϸa���V��"~]��zfE��ڼ?�8�y�=
��3���]:���[~�jκe���Y
g)]J�B/Mj�ڬ��}�բw�p�Y>i�b��!d�ɲ�c�,��m�ԧ@dNJ�e5�  *;�'uX����P�
Z��:n�dK�s�Y��R�\��G
�~&�G�}��~n�6�} ��]9ےt������ z��C��c����
T��A5q��5^���`j�k	Lk��P���uB�܋A;}m�|3�`$<��s�w
���QXfaZJ�����N�dy3�nb��X�ʏN�٩���ˉGK1�U�Q��Uf�os�M�c|��<���'�d�� �������8
�,�k��Г�z��~������S�prMN��4N";��R�꿥�dC
�
@z��3����p
Ξ�ŭ�0��R�a����-��!��w$ٓ�avA,�3O�1�Պ���]��m��h����4
a��ԲOM<+����0���
`��m�O�j3�̮l�[ᖧ*{�~�$�� �ʟ΃
�qV�K
�����	
A��d�F��N��Oώ	n�
�nV�km�T���]j�h�U<&�[��z��HL"�����%�g���}'�����-h0��Y���K����W�*�fG�a��
��m��a��
�d�ibG����ғv
��s
���~Oɿ�y�=�5
��7c�	�
�f
�}���
��[����>@�
޽
�T�nݨ��3�~�$����
b�
��c�=¼�Z�v͞�{
����h?{���k��{'��{A���3�ܙ0�3fs	����&��>����6�|t-f�
6�O�m���.k���~���+�����kނ�]m�K��pXc�F�sq ��H'��p�� y�d��w�՛�~נ��s�j��unU��ή�ٕ�d���Y2V�cͲ\�3S;Ԧ�W�=:��Üb�g��p��������'�x�y�>����yy.��k:ܖ
+vV��RH�g�X{�Ybm�F�����t��j���E����uԧ��}��o�=���q���$��N3
���[�o�ȳ
+
4�J����V:o���Ƿ+u��W��jǿ�E_P`|�����fF͌\��u��լӞ���j�Cl5v��`yZ�w�ڶx�=��K����<C��8�	,=��_�y�Ј'lf��<C3	ȱ�),�;,/�
��Ev�z��{��������5d���0�7+Z
�<��x^�H�
�[*���IS�;�[Ҽg�:�8GM��R��-�ɾ��+�W�&"����9���AV����i5%�R�w��
�V��cǨ
�VgW��
N�����Yu��ٗ��\�֣Ǡ �UF�~w:����@ǔ�u��
��AO�����K� ��@�G�@�Ò,����I
N�8=��"�
D�je8w<P�
��3���
T�v
�{^�
p����]_�ij��{�~�l�}J����!�������n���O�E�';�u�y��q+� 
C��tN��ٟJ}W�|�P�;��)�!#]�6���$���0۵�*�
+endstream
endobj
24 0 obj
<</Length 65536>>stream
+!��8�.�Rܞ"9��k�n�?m��zl�y�۫��
6�R+Xꌯ�Sg�.��1�sŒ�
�A�Yz��$�ι�aF�(.�8�����4��j,3�ZÞ���m��c�)>�)����=s�ע��?n��z�iG��'�7
�Rh&�
+0�G�
FdmV���D[���
+$�~pj���
+
/u���'��޲�f��k�YT�tt����?�4{�z���t>/�pA>|��9qz<���#o����q:/x�NJd�&�5�
�V�:+��yd�Gv����)��_�ޭ����
-��pb�J�B��}ؾg?�nE��N:.�=�Y�֬�f��"�{��B�n-)�f!~e+��oqDݴ��	�
s��f���bj���x�њ=�F�hKCݰ>��\4, at Gϖl†�KpغV�-�]F�
Q"�f�׽��Dk�`>�r�6��{'��W�;㮿ϵ��Z5{ޞZĜ�&���,�n��.��,m9X��Q���uN�2)��y�ʚx+O\xɫ�}cB��g�pAJ.a��@�7�I��]k4�I5h�ϲ��5�^~k5�i��u)k��1@����h^d$~
�=_��$����_Ɩ�5/�]rK�9�{��KξN^���:���'�Vַ�?L�
���
5�B�5S��=����T
��;n��=���wDZVh_x7o�f��F�
k5��9쬆�=��
[&�m�(���6k��޵
=<i�>�t$��8��$��ؿ=���9�X֘�6.��[��m�ljwr�ޔ�4i�%�fR>h=����g~�<AOʜ��X�L_؊L
��PJ
2}��7�[�L�bV$e3_A�+��"���Jt5��^k�{H�S����T��X�C�^iM
�wZ�ҥ&}o��Ƚ��
�Q](7�,�\�^�[�������;���#A<\�Գ�
5��.�Q=7X�ۗ
��轼��#|ԡ	n�:4a8]<��M����6ܹ4 ���Fݒj9q��3g~���wJd�R�|�吹���6�-��Y\����lk)X��$M˥=(��L�
+]�G�2k�v�
+3�~�
+||�c �:Y�5e˖qM����L�[����'	�g�/�����;L��7���2 at R�f�
�kj��AyY"�� ��'��'�k�A_��ćZy(�����>�����cKF�=������B�}�|L��|������{׳��,ٻ�
͒}y�ؗ7�{Ԍ��t��s�eX���R��\]��m�ߴ\׌��Py�-�unR�I�/M���d�F�V�z�8�ul�|,�J�4�C�-���,~�d�C$��d-�������Ȏە�X�I���gn�9�Yj���C�<�B=�üa���=�-����>�I��o�{7e7���Jq���C�Ͼ>��"��[�S�Nk-�r�Y��u=�σ���nn޸��R�7�<Ҙ�t�Rܳ�
��i��#�����_l�q�I����-p,�8��/'�̣�dy�ŞC�Ӡǿ���"�n�UΒ�k��9���P��a����|c{1֮�4�//�6w&��CS@�/QC~��7�qf����܇�XV���O>mt�@g<��:ktI��_��X�ޗ
��#���_�y'�;u��-)�v����f `/�+L�,[ƿA g}yx [...]
+c��c��R���xo�z����n���<��g
�l-��gk��V��	㻀 ?/3�re���A\fqZ�\m����QL7ϔ�����cr�?\�/=mcz��&6�a+��2uk;��Opж�マ��v-����2�B�G��
X�ޥN
�����휽���t��Y���oY1�l=+ƕ�
�L|py-

o��ݹ�zXr���������kI�������n��/g��<���[�Ӗ
2ź�f8�V��|�=N���])�Ak?7R
OuO.�׶-ۛm0��en����'���|�q0���txR�-gm�>�����[�`�;OcsB.w�Τ�����&��T��z}(����R�8��r��L<df%X�	��)8S��(�1��-pE�YO�z�%�^fw�1ڞ��fb�� �jFv'>-3
+�)�X�׼ 6�@���"�
@�_c�+hh�g,`�Oz �Ћ;��z��y��_Oo{��� �Ȓ�}�i�l^�s��pP/dq
T��q���#��}�`��N�{d����F%>�8
g�x���K�.X0��u�m��Q�W�����o��������_����-
+������
��{���
+�Y�E�I�@_��TU��
�g��^W��4C��ڽߍ
.�;�Me�n{G��[?O�����f�t*b�ws{�P��>H�)R���<��$W���Qdg���r�=>��:ɍ�-�Lob���y&������=Z9z�]�s���OQ3���N=������t�\L�T�vH�/�ס���Y
�-}��W�>m��2����L�3e ���h�ZE,~#~������]�,��o�
�g��u�M�W�3
r�>�۩�}���|v�e�]���e��U��6�[�ʷ�;e�Q�
+�d5�&��.9�\�6�
}�#*�;n�(k��!��;}a����j����as`��k�6�ro��l��@�
'�u��ӄC�k����w��8PF%�l8Ir���f�vӊ�-��?�Tyq����c�8���j��~�lyq��j��.��l��
 ��b�c:`���0|�����?]����Sf

3<^B;f8>Ȫ����+
4�f�#��K~�ܛ鯱�V��Ş擦m$;j�}��F��]�d�2�,
�e�;p�
��@�����`3�ǩ��O�{���3l
?x�c'Ͻq���ͶYN��>æ�����?mӬ�̖̿2o?Kk�.��5Š������.�a�n��
9Ի"�u�:�3�W��1�>�v�g���~��&yl����C>Y�W4�1mK�������[��I>~��j���Mwo�����a�=N�/����!��/��_���K{_�̧�m
��yMC
�4�� F�� �ܷD8(�Y�Z{�-���>辧a|�i�/���6~��&���5��/h�
+��W+���Ҋ���D�鍐�R�߈q�ȉ����B��G���s�����.��7�-�Ȑ����
���~�|���/�kz����
/��ܮ�:9A�̘���a��Vk�]:�_�[�����Eq�	�a������#
z��?����t�5�v]����������o��?����?��������������6��~������/��O��������6���33w
��v�Դ��o������5��~����o����}��
+��������a7~��~�����]��������
��6�;lw�����|���
���Q�W/��[	��xޥ8
+򤽊`���۵����?mO�]
oVɔ���'��Ar���-�Z.��#����O��ϳM1h6�$?�����w����שy?	,-����n��e�HX���H��3߹݃�
�O��
�J���;K��T�I����w�7~�[�M7�����w�'S?x�Hz�	T�@ݠq���
ѳ�V����Y���h,�	t��3�fO�w����g�WO���Q~g!��;��q`c�=3N_��CK�@�GT��~{�~�XL�U���;a�i�;z�֓=��E�o�=����y�)��.�>4p�}�^�2ȉ��o�j��ۃ�q'�&ߥ�
�ݓ�l���
��y�����'�5�=��ҷ��&��#?�L�'S?hz�
��=��9���~{#���Ԗ�	G������o��
���	�����F�����
�
�"ʖv��Jv�ŤA�
+ԝ��X=���
n����?y�I����i0�`���	��<�'Yz{��#y���G{���M>��������6w�]��G��y��.��s
5��
��:|����~�矗��d-
�u]ƪ�rϗ-7�ѣ��r�f=���ݽ��"msC��ނ�LP*�֧	J7�ٓ��Hḿɕm0��Ť'�4<MPj�n0�L
�Ɂ��M>�R
l򩟼��觔�ఢ�DeXQ2Nt�����稶��0�[���J�Ăp�i�D���%���e?W
�D������S�Hv��q��E�(�lN⎎��v׻
ҟ�eߝ�V���y�Ƥ�0ՠ�.Q�Q�� !�$��	YGg���'R
�
"#�&�$���#�:h��|�4�Q����0���<���&�c����g��7�뒆
E�>+�Ȥ����̰��ȅ7�k���/FP!���'�a���{�u�Y����y
�\��ንވ�R�l��$I���~V�
g0 :��gu�=������
�x	A�1W��2"��0tAX�툱�ߢe����/�:g/vsq/C �~�N%����c�t�V\�
c~w��>
 ���sȅ��R�f1��ĠJ
�!�Ġ�8�{f^�bpI9��ZX\�8���z�+��p/)�`
y8p��NvԳGb/aW����R��.~�G
�N��	I��˾�P�)�3r�@�� n�Z~A(���Q
ۊ
+�+���i��Y7%���
N�(
2a�]&��Q6��m_b���,┻j6!FJ�]ઙT�:�`�ϊ���f:2�[�E�ki��@U.P*��7
�L �

y�DA
+;DA����H,�
x��{è
<�Ě.1�s�<2P��/<ݜ ���*O��ٷ�f��.
�h*$�df�R���?J�8���A�U
���
+o�'j���V^�J��N�Նڵ�.A8P�H
��K��׻�A�[�̈́���a�T
��������iC���@a��BU�� E�!XB�'���(#�>�l���3� �8}�"��ڋA��^��
�n��H��^�ab�%8��C
+��a�
 ���
y;��Qq��x�&���s�ރ螅�_�-&5Gf�ѳ�0�֦�|XW�˄۳ΐsO�����\Ht�^�����l�Buq�-
~�e����.����ew
�,���br
o�
�I"�]�Ʈ�'f�ÿ)
�M3b��7<�tZ���
+.'�p��cב�	�do
�'2����yY.�2�wH�z��ݷ�����c׎�Jh�
�Ya���K��% �c
�"ɧxs	c\�f�~��
�0X�*��_�

�Bd�Jmr^�Ҵ�A�-�
.j�UTr�χN9`p��%����i������敄 �����K�ZsطS��^F�n���G��qw����
e���L�)��8�_�fW6]7!"����]P%��IV�
4	P��a�\D�ks�2b?ԣ��ɄP�����8u�<���NF&3���~8Gj
���`LS��E��9�=y��XY��_���`�����D~����4���Nyĵ�Q�ͱ�։N��>�UJ쇲q��ITQ
+
yD'*�"�

�����W3�ܗ"�F��o����U΍o>���	��E%���JUs�k��|\"���
b��� �e���x�=����֡U��A��Ri�'@Z�x��ͅ�
�)��$�G�ƙ�_8G��W����qa� ��K"b��M5L:��3N���T
+������C�y���8r��?�oX.8��i��{��{o��PQp:e�Ra�����n�爗
E,�L���<�6�(�h��:	Nw��^V<� Ks&��4  ��@B9��hϙ��k�M��)!
7]��B3������jV�v�u��T_
I
�@�d��?�B���;Y���)��N�
+u�qkJQ
�XS��r��� �����ٱM.5ѱ��q��M~�,O��rR�$�Y���
�&�ٸ��d3Ȱ�K&af�4�\0Ԛj	�j
,e�)�'io�]2�B>�C-��j�m�J ��š��͓C7Νl�f[$��aI�A�C�a��J��R�
d��a��F%ۿ�Et�B�P<YT[\Dc��_�9�|+��d�kC�����
�C �Z�L�ߚ<`,����P
����w�"SN��n.f	�pM��p{�n*h��EA�1�M��
ms&~)X����
/(�.WX5���IU�QU��؝ȋ*��A۬Kw��Z��/�Nx�����=��Ă�m��,��!����T��F�Rq�	>\�
d�Z)H$.A��:�1��
8O@
x���>��;����}
��9�?��ts���
+z��8B�|�����{0kRV��9�<���5G6�����p�C���M+T{2uׯP��r����hj$�On����!�J�0����9�_�;�
mE�k^kO݊����{0�mU;҉����#�kO�bOƞ��Z�"�g�W�?O�
��L�	�
������)%�Aa	�ɧj��;������!�/-�4Jv�j�=D�n�>W�}>%{��}�$��$���r^I����A�o�.O���dוd�+�>W�]���ǽ�}<%;��n�=�����[���d���{c\XI���~�t�]��=��-�e%��S�{��5�������f ��f���
����i���|v�ܷ�d7tt�^d�I8?�;w��R���
�s:���w�.���y/ň�ؓ������Ž��AP�(
`>� ׹���*FH�_?�'ͅ�C�d0"��
6I�u�o���'-~�ko?�+�IP���%3�!8��2��j���D��Yk{�^�%!\�@�}k��,�����[j��@��Nj��uE�;y�&���Nn
� ��{?�.ݰ/�Il�~���ye�7)D�ڽ�
M�oF�I�C\kj���(�h�+i�&���g�N�h3���9�k6��4��Լe�uB�n��Gi?M����a�F�n����䰵�ړ
=o"w<��٩��d�'2 F�A� [...]
+�K���r+cO��={�a) -��O8��!5��#׿��L�g	
G@�� L�c
dq ����� �"�p��|N�"n�A�dUL�G�@'�~%��r6�R/D��E�.��(�6e�a��m?X:�:5�u��8
+�ɱ��Äђ�A0�ȧ��x�Y��?+�2ԁ��A�A�*\6�-�j�}�=@�����C����J�c�	���^��R�x
@�� *�i�PpX>�ӍB�����{a�M{	�Tb��;
�T5��Y\�
����yK�C`*�z����
���N�\�:�
uj�#�'bLA��Gs	<�E��Н٠�
��+�� ��/�ō�6�
ڃ�	��f��)�� pa���tn� z��Y�7��<�u)���� 23U7+�
�*�N��vZ0[{K\�J!�
<9^
O
HAR�X�
+z-ӂ#� ��m��
@r�)!�_x�p���/�ZΆh%��+_S�
>�q�Yq
sH��)�2�K#����.&,"ヌ�Ĥ?�b J�e
+�/<#@�ID4\
+H�`.�(HIi�U8(l�

p�4�+-�в�ꖔ�ȃ?C�	�ƚ��$�z��"88ϧS'
���7��sFp�"��
|�;RAw��p9��ÀC��q����fw���[T���8A��N3���>?�›!�6�.������묥��O���:�dp�JBq	
+��M
v�>~l:"�P�Px�픲���b�Ni�܄ �d��Tc
 ���_~˃
��ᡴ�UO��șdN1����@� ��(�� p�dc/M
+t<C�@�k�М("@�!���"J�$��e<mN͒���T����A�a�8��I-=80�S���]�6ŀ��{�uՈ��#`�i�U8��M

�
*4��\A��7Sh��Ր{���]�=
��î⌝
����vh�!u�`�dp�%σh���Lh��PDi`B 
���� �]�I=`��zg�a
�Q������-��A�xN��l�Έ�� �
��S��*���i�U���V=?�pl��B���.����+�cg/�9����E��}�%:6]�=O��0��o2%�{+���b��H�U'��f�C���
�N���M/��;.�(��4Bl�����n+vH�8�"�������>1'���_����M6,O7i���~��n-R��� �Ǜ��2/-�&(WZy���\�!�H� 
l�15q�sK2`&�vlB��.��'��-��aS�0 ~�Z
�|h�E%
�j�F5�!�� �]=

+����5Ε�3�7���e���U���d lX+�AB��@E�*&~���I������2�"�1��PC�ѭ�3�Mx�)7����* ��
+�z��$�P]����YDk�w��N�]ӟrR{Pz��&^�4��k�J�LG��A��@�vZ���
"UnN��v��J��.�N�1�����[�c��҃�e��~���)��f���ӑWx��%��m�G�2&�Ai��
+�i��E�)�H��Ax'|�-�#q
Ӝ�}(���v�g��Е�P{{�Bmn�4ʩ�����Y��G/pysju�]䡢�=��W0�ݍL�N�⯸[��Q"���a6w9��{ʳ��=��t���mZ-�w?
�����%Pf^�>l��w���C��@
+t'3���w���PPw�J�;2E�"�Ed�p:~�DV

&���%MBޚ7^[�.g���b��Aw�`�~��Q	�Z���uQ*:���
*�	MW
��r2H�w�a��hI��h��n�ubq^�c�W2̩� ���"ʻ����4�sI\I|(��q��:�~�32������� �
+�"��$���N-��8�	E�V��5`�]�u�=tM��	�|Pf}x�n��`$^v�ʱ$�I�@(1Z�ڳ�Dav�({��kn�%"͊uxB�5��DϞ��7&���H
pFTH
 ���P���&Έ��E�H����5���ْAwZ���c(�@u�w��j{
��d�
��̇�T~���u�T7�m`�Cll���XB�.�>���h��
� ��
+8<f(��|�J/�ǣn��D?�x��%K���S�� _�]z	1�$)�[�f��~K��ΡrQ��AQf�U#�
"����'�u73���ڙ�����X���Ҭ��l��I&>�S��ZU��
{E�Ԫm�CI?;�T��L����n��S���egp's�w�rU�4��	�C�EGZ���?D�Z	���Ms�,i�j�G���K 1JPl
+)J"n��b��q��w��}u�pV� #�����~<�����_oVf
�8^�,�l����Dwf�<�@�扢�e�������*���p���n�[�+��/�݉4���i�
?l���!T|������
��'��c7�p�
_�օ+#�
�I���W�F�d��嬢��	��H̆����s��
+�Lg�$}:�\)
l�%��������ѯ�68`��:�,�5AIi1��
+�lYf1������q
�䫅
�N`������Ų�pͬ��x ��8�a[ų�)�D
�q3�9���nG��������LBpNpz��Zx"
GL)�3l���O
Ƅ]�1�CO|4�zG�W�ͫ��k�2$`���Nd�ʋӻrn�����ӎR��!@��C�
�ȕ�oK=���9�`9$�j�~�L���H�&H��3����w{��<jc����
&�G����kߗl��DVn����� �E�o�c�`�D�_���އGZ����X��
+]�BV�*��. at h
D)0/^)R���Pz1�+~��X��y*3�XL��E�뀄�`�/gT��}1����K�8½��~�"�bG珸�gs��#Q����iS��h�ܐ>��`�{�C�W��pK��� ӛ�3�k�����/����y���'3���ʩ�x��: 6�����`�]:��8����5��.A�<ޑSe�0
+o�fa�6P���{��%^J��h^��
R.��U�+XV8��&��9W�|��\����fh4�o�!U%�� G�yV7Z�na�-a��we��:cjr����g�
R1�?�ǙS=c�� ^��=Z
P���
A�f>�u��: ��@�
��
.�k�{�Uҡ
�M��@4�
+�R��¨ż��jj��:a0�BN
���<�p����pY�o%���7�Y+���@y���~��M%�:�=C�

�`,y��bVY;��oeY�)���:�o�^�:�i�J$QH�w\�\{����a xP�Ű
x=v�m0��GXX�M\gΡ[��`�Κ$�ϵ���<���y��P��1G�n`<�\)�:�rD2��;�f�(/��f
+�@�<5Q �gS�� �ߒ��,>�6\���B$���t��?��o8=H��@v7���vK�y� ?ݖN5x����8���Tۀ��0(Jd�N
�e�!+�O��]�
+ߨ��)ŗ]���Z��2>�.頦�qV�Pbx�c�*#��m�t�8Ԫ��
:n�b���k�o�1��X
+���moZ��m,eT)�:�,�/�
�JQ8��5Z'g�A���+��
�T��&��%W�r GOyT��ò'�Ó����Z��M��wV��2���(����\p-����B+=�X�e� ��P�G��� s?���t=C
���a���
J�۠>p�G�]iv�x�n�`��-�֊�Z�,*5���Q7&®���+n䨧����� �=z
i�J��u��"<��:�
t��I����yI��W�{b�1�
+@��!&�t\�/
/��cܣsvWY!�F�^��e��=-��b������
��t4~��R�r�~bW8?��;}Q� �`5��N����ݹ��<*��Tl<Z[\��|�f�4frӚ�Q��8
�t�������؝�eg'��`'�S�w���G����������Kv�‘+�q���a�{�J������r�W�Ix	�X��xޙ�ʯ���Th
�x��Z�B$v1�SW*��=�"�+*Ƣ��0(��'����
+�;Ki8@�H��&M��.�e]8K	͈U�>b}��kV�5����Qۖ1�v$BT�݌}����F�P
�y�ESm���h(PC֨���c�-rK�3���P��#�c�Q�Q�gw\��FA�)��``�i�T��
F.�y�ү�J$$
+ـ��Y�G�����o @#8'�X����(�Z���ٚD�˷�x5�F`�uͫYi�ܶ�_���a⌊/x(à��
+XTU~T��/�b@���s�$�'� �t�%�Sm��@�-�1:
b2��z� G�/���#q��'Ⱀ\;���+vA��5婆��;m�j�u��ufv�[�Wp�J7*�� 
��4�T���]���(,yD\�b�PYb�!RYS���S�ϛv�1LlI�
śW1@����Cjq<
� sa~,��E����5~��2�j�u�&�����O���X��T���Ao1�Hj��o9�VZ`�Fe�t"�`Ht;�s��zi����T�3'ǩ�
+�c۩:sZ���у2�.c7�2t>�ۆu�[��V�
�'(�B�u��7�
+,b�
���\��j
 ��0c�j5
pp`3s��7��^+̏�,�ͯP��Z�ZT
�:yX��J�cB�
pe�Sj�MUt�-D7�
+7�� \���1чȵ�>�ۃh@�S�s K����#�Yˍ��J
| �W
�=�q �T�z���~���}��n���H kr�.�0q4'oфa8`�5��;e���=HI܉(�@����D�
kyu�B� /�T�1��Z
� �8p��&
]�?Q5�<O6�at�
��L�H%rY���L�*{�
�7t
��"Sg2�
��K�C��J�1
��?�
�E�*U�T4H塁��S�
N��A�*:�w��]�
�J�
�?�d�GY�����ڭ�v3�F����Qm�w�ݲ��������
V�қ��(�`�
d��Z���d�#:���el�S!
d� �@ީ@�N�C'���A�j�j�p��
��6��(�
�3P��
�]����<!�D�St9:EY�
)��� (NGu�2�¼��YJ"V����F?hA�TQ�y�1�
C��N� ���&�R&��A
�
�})�~�j����V 0�hG�
{�/ʪ��•L �<��1L���c�"X:r
vK�bC��2�x��}�O�`q��U����T�H�잜_1'
VWCַ# � �'���
+�����
+���0�-�*���l��詹Kt�%���Y��=����^ڸ�L�k^�APB".9:�Ѭf��01"����hY
��'�J�N	���[�r���Q�*�39_��T<��b����.vLu��7�Ѫ������.��B2N��x?��NHá���f��6�
=uY��tA�
gŰS��
+�����aU=S&GF�9h�J�m=0�>�}BKt�U�dR���
� ;�dT1���r39��u��A�T���Jx�.��wq�*��7��I$Y�ݥ��;�uj�� ��Jw^$�h���`�ž����/
��il���:�2�,T��Z�^O�P���g�W	� (��~k�����!�F�j��X� �[?�b�'�!�W�E��b%L�I]�� �p}�82���r3&NŊ>,P�LX
e�0V��Hv̉.��< 2�X�d�,���!)��s]� ")�i������V�=<L�{�
Q��g����
+���N+�Z��2(�a-7�
��d�ff��4e�4f���=����'.=�.8;��Z����3cQ�>h��y� �"�;�Rs���iE}�	:(K,������yzLL��'[
+� �׬\M��Xr��g7��|�y�'r'qf�+n?�j2���r�!)!0*�H��sq
�(��~���p�`5��qP.��]X��D�X�"n3�p~�y�CY��9L��ٸ�u�-9 D)r&��
+T5X��
^��A�@.æ�LV�2�U���
�;�K⬋���s���um/�=��Ny�A4U�f�<ZI�W��<��ܛ�E�(4��
Ί�@8��#�*�ؑjH:�?s�V
'�s�;7P�4�p:������W�n>�h;*��
�_�(!D�ٽ���� ��$�\B�e
��ﴅy���\Bh�@
�2��Λ����e�<,~Р
Y:>�iX��M�;'X�m�+�^��"���"Pe�ML����2�7���l�T��ѱ���
n�4p�[J(��<
+�%E����JP��f
�0�Ӈ����2�����-hЭ]�]u��08ٙ���E�f9
�)`I�3N���D%+k�E��G�=vb�&ho���;w(
�;6����
Y��]T�����IA����n�6��uQ�6�ƃ��\V۶Z�[�]V^P�T+ت�1C���=�;I��y�}��T�DI:#<��ͪb� RR����.+��Z����d9�(� �h��h ph[K��)9
�B�|(�;�w ����a���@#dGl�^�]@u�M�J� �f/�v6ఉJ}`S�`e�~8��D
n(V� �� [�[�i�x+|Q�a�]�&�V����!�΂�T,�]Iy���ǃ`�.	L6��>�]� *v>��K
�3b�l�6O�4�6�D��K�B
+�(4��9�!�r�Qk�ױ�ˤd�y�>պl�N�,�ⱥ�A!�2W		�l���:��p�a��>:,᱐u����e.$����\!��eDxY?߭�
+�6�P���ҝ����H]�*X`��|�wu���-�
�zૉ��d�Y�5_��'�(��`�
�L��X�
�(���Osɠ��w"��U�F^)���-��.�C
ϪRBv�UųM8h��E齁�2*	�E&,~�Q[us�`C(�C
�V���2Q��`>ڑT�ʖa�<��$�1���������USf������G�����4Ł%��6�
E�8�AGV+0T<S�;�W�
� �Q�CX��D��pGa���5��ʦM p
���/Z
I���ⲛ�6�N�V<��D�,��1���̊S�F��Q���rHRL�N
+C��"Q��ӱ}O:�X>�"��#Wd"ާ��އ������‹qsAɈ�ьd��� \��ѯd�
J�9��>
�K
�%�`�DN��r����]7oފbi�7�Zz$�����F�͑N	g�ϐ�`
�4{QنD����~asxi�З=�ɇb�K�U\��
+�{iVe�HK���6J[�}LQ��2�:�X̠� �y�d������K�xmL��������/�0�&G�������m�<����*[0]�BA�v�
�G��E�	��(u�Q�4�ߟc�#,��Ϙ5����k�
 Ʊ4��i905P�@J���0R59ؕ
b&�.��wc1U�r(j^>�Kpū$�a��ʞ!�IX�����c�lCP���t=
�N
"�Biݪ.����$O��lcz<��?�J ���Ƨ�?�u��-H)ޘ��J��jp�M��J Q��W$U>sz
�o�uj��
�%�ߍ�T�R�óu�8-�R
��-�SB> ւF�T�D5�
�~��W�4
��t�?̱ݛӆ���O7���Z��l:��0�B}��0ѡ0�vb0Έ�H��ȗ���$�[a�P����&?��y�-08e�9Gi�z��Sx%��;Oy���C�^̱
+E���
VoP �YqE�,��ٙEyYۉ0[l��&T�=u���+y 	�(2��7�}n�]f�k‡�|�V�F�
g�Vh� �۹�
�
�:I	^!
+����4�
� ��&���s��Zĝ
+	[{:�N)�,{JoS+����	�Ҡ+��7�k��+��P� ����?�;4X�펁�����7��H�k�&*��X���ͪZUV�ME�x����e��Wf��ٵ��R 6����5���HV�<v5�vWGظA�ˆ*e�\�X
+���Y����`Y�����
��u��nk֙wf�gʵ4�
g�\$�p3����
j��l��rW�e:�.��)��e�"�
Q����\�Z¸�AU��y��S�>�J��uJ�Ё��E���_�}T�wx��i�M�-G�����lG��f�b�Ӛ"��~��;�73�/2���5�Mp���
+p%F��;s��p�t֡4veV���W[��0��A����G�FcaD�]�~��l�!p��S��t��L*�-�R��]��r?�~~��0���AK�]Qek �5�nVH!:�	�v���c��]����g�h�p��zR\�;튅C
�e���0Q�MS�
�����N
+3��:YM��_)NTg
��֋�9!R��{X��(�
2���AJ���=����5T�`t�P
ʸ�e��zĮ\��� W�-�֪�X�x���[��7v�0���'+v�]O46z-�V�&�]"�o̚i?�!�!X�� mfx�����e8��X�ao'���y&���d	/f3?nV��c
,��w �WC: ���x	�wf�
��������b$�1�w���}5��d��U&�7=Y�˻J���(��)�� ��[
m�uo����i
�Rh�K���|���݊�K��ч����jv��9O����T$��od��ks��
+�Y8���2�������\��0tG�(O�~�I�c�� �MΪ���.��1�N�>��`����A��/ޘ�'�2NJ�p�I辕
���0�3{<ф9� Q%ٿLF ��M�y]_W4�G���@�:;Ix;��km�d���
�A����*w5	�����L��C
�~
�ۜ�\IB�8
eNAPY���bY7A�
����o�������2ڬ�SI^M����]�[Mr�ژ��v�A����x$:l���j�X�.�ì2��2J�ڄ���[��J��R��TTx����� x�~P^�T>�?�Y���I��&W-"!)��Nd
+Q<N�`�ʦN��$tq�>�,1� �l�^�R۸Z��:l��
��U��4ć�
y���R�m.��a���SY���ȵ
;�d���*�T4��m�4�N��0��;�G0B5,v
e���~>����w�N����QTL
#gӱꌋ=��~<�a�*C8���C� @dA
B!:�2
�*�kZ��$�|�i)_�-V�7���p5�!a����?��ܚ6a����|��㽽�ν��:�vs�+hes�b嗓���
~چ@��֔a��Ol�M�M�cL>T���~�
E�[\]]O}z�DY���79.�pskj 
2�AQl��]v=�����z/g�xs���6�L��h�`��Ϳ�
����a�:�M��B�
YCRUY��&�
���Y�	�Ӫ2���M�
k�ҦNJR�J�Z�� X���{~�o���*��F�-Nu�`y1(V�VH�)���GPn��R]����`a �J���]��;�I��huw�e�b�-86a�0_���
V�J	N�P�f�Ǵ���☰�
��0EX�L"���^�y6,�OdXm�H�#����xA�5�"H���u�N蜒�|�If��'�b���J0B��d}�ǯ�S�Y
1�rF8��x��l�HD��($r�KO�hݎ|>��e���R��5L�?�"���숣ڕe��	\Ö	>��Z��w�c{w�e�+��#MD�xv�m^�O�G���{ݘ��ǾA��!��ݭU:��r�h�����0ȎH'�I9D�y����\�=�g�*
Z.p;�������@T�{��B"�v;��5�A�ԫȼw
�D�$���mF�Gb��4��p�/(1�O�ՃCC��3�����w��`���3~�0��~���_QnQ�j��8�
+�5��
+�`� &T�nW���g�koA!�.�,�`aXׇ�݈���Ȼܦ��7��e*����bF�
+�s,G�������I�̶�{�� u�����g"��z$G�i���~�����+�ѯk
aQ���q�V凈�/(
�XP�F4
24J��a2�>��nZ�mD����{+����ɔv�v���J=F��O�ޤڊ����@*�=]�
��F���@����8c��2�7�Dv��
��E���8tR+������~F���@�M�?n�v�ȉL��"�*
��J�T���z:}E{�x��(
/�$�nE�׀��������ҝ������ytu� �l۱��_����QH=�2�N1��(0���2���Z�� t9z�t����9(y򶃪�C����N5z�rO��"��,�
+p>7��ez���
+!�D`Ȱ��nե�Kd��(�q?�hE*J�@
���7T��!QJ�Q��*G�k3:A���{R>{���
A7%/6�
 �����1��k�iu�t}Z��)BÖa�k�
�7�Oq"4y dSy(�^ݚ�f��pf��	���&���	�g면x�~g��g��ͧnA����U��`�|A
4ӣ�-��	Τ�!�A�j��l�yR����_3 H*t����O�'�]�i)��fD��-:(vp��|�� ������2�e�%>�ٯ�&� Ȩ�� 
�����X�Js����Q��(S��5�-{�mߥ�9@�/8D�
ҍV�	��C�}7��
��9<$m��`�J�l��O�լI���EA�Z�
ךr;bu�����h
��I��M��E��T�a�?��������
�@�~��|�@ b�{M�M-���Sl�4�hY�:Z����`|(�@����,
��~H_�]�v4��M�{&;f65U:�O$�o�\߬]k�ؘ�l���;<hz(kQ�C���<���]��3�+�$"n�B�PN�a�Qa����g�"�W���:�:�~|�
+`�M���-�
&/�̒��x��M�(���]�EzS�&�L
��G���K(2���x{�
�@ z@�#���`�|�eZ�
+,�B̲������T�77�H�ɦO
T�R��y9o���I0<�ּ�$*
j!�Mg��X_�61�ہK�%� ��}����}�j:�U�����R��Jy��Ə7{�G
���%�(B"wt<��B.`��5�N��s\����A�2�$oP��@>�
��|���EF�V��_��4R���
+ֈϒ���P���FjA�+~i��ɡV��m��#�D�|���2�F����j �+-)I���5 %�uu
R&� ��*M<%C������T�	~(oe������`�*3=�Я1w(�M�6��`ܙ��æ������㝱�bU�#F�k&��}��ڈ�g��
2s1�r*�^�q찞/ܒ�hJ���'�2
Y�
�H��mȬ�n-B���H�2p��h�y�8�6������o Tw�|��O.}y��*�3쪆�A3R<�Z���3f��}�\5�.0X��u��4A�c;�Bn�mtJ� Ʀ7�K�'*���
�
�E�rq�
,���o8R���I2���N�7��^���FoP+��5���T;.��H���O_���^���/�rL+�䌰mW�
�)�
��C�^�5�';�
+EC���Y�/Va���`�u���O]�a� �'h�B涕(RLպ�қ���)iȤ�����!��XPQ�g��Z��^�2l��WA�DT1>V��2�Q�$�Z�#��]7A��� ���l
+�ke�s����
���Md�M��#Ɩ��;��
Ռ-��kH|�D�'	��^H��-���ɽJ�njpj�9씸-�>I��R�*}m<;�a��=!t�|�f�k�S�e|�x�m�
+���	1c�k��08�u�� 0
�%]1���!�lغxl�ئ���u��.�6`�󽲥F��nll��P
�͚-G�a��^���8��n�]�V��/
�s � 6��
������|���U
�Q��=������E
�=�����<4���ӓ]
Q�A
j0�֚1�	�~�,x��($o
����0﬌� ^e�
5�<U"�x
������|��
+w�
��Jv'њ���7��2��v�����/ؤ�� l���;�J�
��;���F����5[��͖y`ja��a�A$`��E���8�
F6�sRL��%2D\
hk���*��Zf!�0�He��[�ADrjʁ�SH��e�(�Mo� VC��t�ˬ��,�q�/�+��Ƌ"�1r��B��
��o}�C��_�%8Fk��L�h�A�6%�N�MĬ�I�u��6��@�Q&9ڣs�,��M҂
+`�E%$@�wHo(�	T�,�&�c�Gn�h������թ<p��)��Ϫ$�}�Dn���&e/w�-'K��n=����v���1���)���n������M(�����8���0w��lps6�Z�!s#e�#�E��U�-n��sj3_�1��Rv��9V����=�7���OhLm�
A8GЙs'�0��
�ٽ7�xπQ$˟GS�CkcjQ��b����V����N;:������ę��<TQ�= j�qGg)�AG����T"(�<h�U.��Jjc�
i�(t�%Am�E`�^����aLk�;c�Z��bse1�� ~H��}�X����^��J�]�� do����7�+��B�_�_w�LkSW���(�ڑ��'n
�N��S�+�����R��
��,]�p��
�B���nŖYvtU=�gyV��il�5\F��lE)\���`��,��u4��LS���)~������g)W𻭘)@�l�j0�Cp���!
t]�
���ՊT튢|�?`_�*�*�H�bʬ�ʮ�6��U(���ӓV���Q\�&�^�*�q��4����(���1|�PD��XS~��-��t���
L��/��u(]p�իU�oOV��c�g��N+
+�f��A�+�D�!m�Y
��A\e����Y/IeC�2��|��T�_�
�g�yV��pfi \���A,�Z�י�-��P���[���|�|(���aEt%ŒS3���ܙ�UZZբ[����Y�-c��C��nÜ�,��⽪�y�%��ya�!C�Tj2�3;=aR]�l��9Bc�JR%�;Y�	�p�-V3̓�8�Eb��q�8����<b�M�� �\@PF��ū��wS��7�-;k�'h�׵����Sv?�J9�k��N��]=�ZM�]����YM����CVwۍ��gwb�~&U5�?A������#���ī/��!
�y6f9��ai���A�p,��R�C7bZ����(�d����x�r)�HQ_�u�?V��� ~Wf��xv�XY��]�
+�U�m�W���#*~�a�K`�?M���јZ��qȬ���6ȷ�})�]mg�~�i�`��̵���PV,������׍#U�C
7�3VN|�7� u(D<u�x���`��~_L�
��!��v=ֻ����YM鬹X{Y`�ck�N�d�B|�
+��
�%���C�1��W��_7���IqMJk�*_`�����L��I��>l�Q������;?�3�!�r����V�]����U��y�Ǿ�6��O�S�|�v�é܇`���
&��[����Tx���E[v�jǖV�2t��묟D.
�[���������	/[���,��yY|��P�b����_[kR,]���.8U^��NC��<�WLm�'VI��
��h��"���vފi#�,	����M��T�PD�9�ru���=�5�l]��5�p����J��
d�> ��3ɛ�سz���%c\R&�;�l����=�h����Z�lR28�Ј��=w��̺e��CX�FuԪ���̌/�*2�wH�
��C�o�d�
�".*@]�n9�¸�Ú:�n�)?���~�/�p�����}Gg8�"To�kZ�gcV

B�jX�Rr5x3 ��ь���/�f��dJ1w �
�����/0����A
+b���,�Bk�X���)n�����_�?�UQ����o�̓<;T��v���i�
$|
��Ѱ�2�VS�
+��Φ�Ag> yѫ��ap���
�
+ip�c���-��e
ǽ�sxŪ�YZ,(P�Zm
Vk;x�����J��5���]+��y�}Jݓg��=�l�a�٪���V�R�b�LdH���&?��}{BG���AN��{�����J�iZ�#���J�g0.{�Z�*&�	
w��� `��o.�4�du��1M,v�{^�loң=�?y
B�
��K:���
7�]�\fgA�$���!��0�'%�j5lV
=*O;�$F��7k3Y����!�
+�P����� ܃b�'��;�S��璯�	L���d�b��C(oױx�z�[�>���<�O�x���
�����u`�3֎�
��4#+�g���B���$,ག���a{�
��*h�QS:�֩����-�{_t:w
θˊ�z	>�ڿ��.�Z�L��wh�hz����eY�4��7��4=���;}p�ʞ�ܦ�'��2��������
�k\E���_�TzOA4��
��5
<
ap�YӏGz�'���Q���辁C#Oc9jl�Ke��V����c*z�r߭j����6J寇Dr�ɕ^��
�
�gO��9j<M�
z*޽��^��a/e��A���{>��%ц^J%{g?��?�S{rx����W�mJ��R`s/ϧ	�i�,�OZ��s�Ɋ6��O�SƓ��a,�l
Z�ϝ
�]��1�t�ƪ�<�X���X\zy��9=�fn�?v��J/n�Xv�<�#wy,� ��]�ت��6���E�I;���������u���1

u�g
�;��(������=��t'�laG���d]n
 !J폽SB��'<�/;�,���nй�xT��؟ⶕEk������k�`5F���������4�R:�
+
��'�-�*���;�(��<��X�
+::In������zƻ�A����5�R���̉�c������7"��m�
l7�2p$ߑ
+y�1 w�3������{��i�H��l_�7E�Wp��:���́q��'�
+�Jf�
{`�~�
�&�ß���7%��,Yt5܃�<n5���)7�|.]ƈ�p?
���m��X{o^���$nE��hᔴ4F�3��錚�?�_4� �@��@ػn�,no
PK���jV
���)^RX�s�,~`��C���>�6u0��9
���zͥs�����[�ϦQ�
�+�:����G
+� �0B�\{� R�J���,%���]����
�N�4x�n ȹ����u|gc�?��H�o������it�(���� �`��w�ݓ�CK�[]Z8	z�&ߓ.�o!
N3IR���3Zŵ]��?��<�Sr
3>�+�{�����D�s�؉���
Clt�-q��.y�Ƚ=.`.!�{/��(~����
tn|
Xj�1��#�u04|��<n�ҵW���Aq?�g���&�(�޽K�{["}%�A��%Zs�y�O+d��4�\�y},4���y}�$?c�iԴ�
t���l��S�w�Eg�����u�̟9�U�����>���w�+/o��&.�?���ٍ�������?7�4����ٺ�u�8ڔn'��*��Y���w+{{��R4�^��6�M)Z6�ٿ3������'7{g7y/�4�RVͯ�'���}��]M��kʋ{s�z�a���=9w�5���D#|���	�_�<�ul��
���c�g?��џ�N�N�N�3	����0�0��]��ik|���aF�M��L>��
�K(�Ξ�E5`�
���w��^�mV�k���˃�,���0���&��L�,�w�X��<�}.���&�}�P0e�duZ�s��M��`	9W���n���ѳ�6���
�+�a�nq��?�y�Cg���	�v�[��Lh��}$�tLGFO���
+�Юc�M�Ї�v#z'൑rx����	�eN�}���O?�m�z���@�MKb�%
�}޻�ZG�g3\R8�
+nF�D���n�w��X݆��Z��F��;-�"�V�O!j��S���N��~0n�4��N
��Em����N��x��;�U���X��]�b��<�
��aЌ����b�D���&ڨ�u�-c���BչM�
+�m0���jh��?���
�=d�>��O;?ذ������{����� &R߻��_8��d�a�}�9�C8;��]�
Nq"�5��>���,�y
�2C�c
S���-i�x�pދ~1.�[�Zk�r~�*����
@���<5���9x�AZ5��RB
��
�f
�J����w�
`�;���1�����6��_[�$�*
+&����Éj
�Dt���K/�9���ҕͻT	��9��
���^�L�KH��)�mm`��Av�V���hj(�ok�TWoV�b�ǀ�94;ٴ��ᘹ��tM�N"��e�N
��>����)!��£�N$�\��-���Ҙ����{D
��ڐ5>`_
+��x-����}[o�l���
+��D�SL�*	�­��!T��Vcu��������t%\��MPp�!
�
*J���^�JO�6\�Ur �[�t������
c��X�
�<���:MX0�H`�L��ZbkT�2�{5�W�
+9�������A�섛$(Q�u���ێeK�
�>@��y@�f�/��L�RA�l1�!�P�¨9�����<b��������Z;V����ܼ�a�y�P
�e�f'e.L�ڨ�/b�&�$g����c@�ﯳ@W����;7��-��e�U�
(����QXD��
j3}44���)�
+5���i�!�
���
�~�Qz�#�g
+_�V(

��:cc��qn69Y����a̭t�m4������G
�����>�?c/-GK�|����1��F�(4y�*Xl*mv�.>�J;zU�ӌM�
+bBu�r��GѬ����r��X�����X���HX�0:�6
�lm+6:���?�i` K6��^���Xg`p���������\m��J$��XbSv
+�bP�"9��W>��rz�d�
sӏ
�2R|�E508,�%�d���ىw�|pi���_�׹���c��بl�\|��?��F~f���G����1G 
�!�Y�< _�,)�n?�4Sğ؞����p
+ԠQ�iH�'ѡ^V�+�xii[~ɉ�vb����3�0��?w�Xx?
�1.��'? � k뺳��
�������
CT&W
񧝫�q��_�F5�58�o�|�6�f������!�j�VF�B18g��W=	��#?�j����V�묓n��,KА,Y|*�@��ti� Ѵ�#̺��q>��W���e�������@�ӝ|tt�/w��ߟ9=��>3�ҿ13��3eu������4?��{�1ע
+�O�1t�T���bJ���{��'I
B�����T��'m�d��ϝ���Q��e�`7��!MW�1��-VuU�'_Eja�2�w#9푯
yg
S��
B��S�#�$
E~@J���VEDo��W���9L�Mɖ����3���u�i�V��?|0�?�
�kIW���
�b����pD���k*�o������g
�O���~Sl�1N�L�W�I���3��&�Or3��ssw~�>�yj.(���#�������7�+@��W�>mW:�
���`2
��&��H]$����?�����`�v�{�'P\W{�������{]vc�f P�f�s緖�������^�ϟ}-+
�|�/8�����sަ?ɼ#�M;�U���-~{p�����o�\!�no֊��oQ��]��{��Y|��A���!,�t�,=ؓ7�#"�?6�'Y�ٻ�:���SS?=Y��Y����۟�T�}��d�+ܺ�ꧽh��5}Q�a�b
x��
Z��N�AMU��x������<S1y�#~�+�1T4��%��9��o�'�ޑFx �s�^m.?��y��M�
l
P?���v���qR�E���k^�}}&�������<2El,�U:�������.�g�k*w�kC���d��|��
��{|m�=�A
b�]�Ϟ�N��|r˔�<��T�3 [...]
+�5�󣟿��OhDb��A����֏�
��T�N�Q�P��ڍ�Р��6ӻ���˺�G�����2��� �\B*M�B�Wʝ�xྮ��Ǒ��t�c͡��dը|��W.��q��5J���b�]}�����/���
r�Gv�� �L�PD�P�x�x�y��"��jٙ�[�
�q�/o>}����hu>��TZ\d=�Q)�^��2o�����D�	��y���Ţ��6�Ț,�5��Ο(ڊ�Qa���#�D��v�x�
�ow��A!�� M�項s�gr�9I��_+�R܍���d��r�$h���nfw���{rRm���~wˋ�Ɵ^�C�RЌ��KO������tn�`�p��y�s�ਸj�\!ŵ>��hL��U��6��w��(�����Z�b��
�Ļ��-&�8��j��cE��W�h���(�Ds`뼼����.���f��2Gt_�L�I��J��3#�IԘ������h��)f��-���3v@�s(������+���3��~�%{��c����������3���� 8�XXlP�h��/u�zG�sO�Qv1
����1�
�3\Y�Y$�X���C��t'�y��݋��;CZ�td��
+����hޭ�ڛouľ��l�I�ޮǙ������j{"��BҞ�}ҙ�Au������ڗK����H���k0�
��>�j��	
-�����I]�V�>
p���}6^���ө3��
 
�y��Ǔ�
�Od9�
͌6�'�	lw]t�ܙ
ݫ� O
���f�?]_Y�١���{v4����+���|xi�[�a_C�p+�;\�<�q�=59k������ʧEz�i]�ٵ��/�`]�v��F
CPH��.z���
�
c��j���X�
c�/�B�y~�#	
+B�]u�~��vhO�CBm{��~A;
Z.{ݿ�~�OTk9�?xET](
m3/�K[�Z�;V��t��`{9����'�ASc]\�J���v
�N
͟�3���YJtZ�W"^�
�:��N����
OՔs<9���l��i[?���
� �e����F.��
+������B?Ɓ���yvn�GZ���1����ׯ<Ȕ�va*WxJ�m��y��ZV*/.ٽ��H ZyR'x��{�v�
�]
�-O�wf��[���}2һ1{Z�9�/����}<X|]��M8��E�ᣪ*�2�(O�w(�+���8���0N��ϟ��}���GK���Ѣ>����iU��ꊍ�39E{Nc��|H�C~y���^�����T�g��?8&���S|�C�5b
+_g>���_�M|����Q�p�p]�Bͽ\_O
��
W[�|��Xv��(D������<�\W#2�gG�S�)�I������������ֳ�v}�_�Xƺ�x��-)~�~>Lm��I-�˂��6_F��I��ӕ2�@'G��C�^��+m��=�<�^Fm�S�'���3s�9�Z{pD4�p���Ç��)d��� �ؙ����Jo:Ӵ�Ȁ�{�V�_��
<Ɍ"��J	�h_*܁��i�XI���ş�u�{��Ӊ����)jX��HF�;��j�B���zpm��ӯ�h
�r�.˛5�F�6G�3|nȻ2�pfï
�Yb-��
u
+�?�}�V���`�a�p`��K��m�<�4R���
w~������PB��v�Ⱦ
ُ*��N��Q��>�{8����cyU���8�?���t*�t2ɆL�����A7�Y=:skv������ѽӁqVrR��#..�G @�
+�i��_lM[
U͊㣦37���aD.�BC�5)	�l5�B�ic��?p�J�*��8>%a�ID���N����8j‚xw+��
� 
��3`>`�S��s�Wk��Z�X� �=Eal����f�@��mL�OS�HV}�lҶzq�4�@i�1�6�h��n(ņ�t*eV�+�	
�f}�/�W�iX
� �zS��u?�_^i�j�A65v�����Ġ�ë�5V$���aX��3LL��jy��ۆ�^q-�F#0�
R&kqiO����<;����h�t��"���vH�ŋ�\6Nơ�I�a\
ժtZi>���p�>׽
�ee�����ˈ��8�:���((ٝ�h|
#xkқv����
+�q���91��t�#��܎��k�t�1�_����.�G3�ȼ
踜Y^��ه��s���.1�J4��1���O�*P��&� a�i7_�piiJL�A���
����fo�/`
���g�
����zrj0� ���>
�o�͕���q�
+��A:�Dz�A��d��2��"O��Y�l��Tx��W���7�M:�Y ��(;
"
UA�U�^�q�`�ΜU��`cca�����`�z'
+�2&��)�-���oө]_��'XH�г%�-F	��A}�\�i��Ƈ
+��9
�<܍�)

;��"|�������
+�֌��V|�ܩF���z�lwԯ�+,Y�h

�XVHі��O!R�C��oW��Ů� ϯ[s��!R�wf�K�z� ��,� �˨	pO�tj��a�l�WO,��^��I�;�c��HRLVy at X�r�ep�"��6nN_����|Ŀ-�&�&�K
����Ҷ��ߨ?t���.l`�G�-��^qw�{�*��?a�gh�ٓG�)c���+��8�0��R@l

V��K�X�S�{Q3�|h�v�܀���f��i���&��ǵg��
+�V
�p
!b{ݩkm�
���b�9~3mF����n�j��+򛮾�ޕ]\e0�NY� ^�"{ttJӳ:Ɵ�o�
[
�:*�=&	^�����c��⧘H�x�
�⤻���ֹd��ŕ�׹���¨�a���
���g9���Ru��_��dG���ix8�Q)۟8�,�l�.�@x�@���n�Uޮ&��~a|�h�n����X6(� ����@
�p�]���;L�w�Cǂ+,(\�/ �3��N�_����f�8� �2̤��� �
2]c�"�gEK�bTqbU@;�����:��
s�yr����������Y�7��_j��h
0��
���_�P�����=X�6��)0-����;�G�0V��3�W��H`�`Xr����S��z��5��
�B ��Uo�W����_0m�j�X �),��L1�^�V�.K�l/߮�˫`����”�%{�BY��"����a�ᨃ������8�4�I��� D����V�|;�Z�%�n�ҟ<�L���Bm��@�����~�q­��A�E yg|c�X)�Va�&�b� 
�E|'�8�JY�؞&
+0%&h;=|�n���g/׋EuE�hd�^��*i���qK'��4��T5�Y}��h#rbc�iI�m��c���I����Ap��Ȅ?�1��
�n��kKo���Z;��F\�O�x�g( V�4�A�ڃQ�%wa�pj[ʙ�PR$�W4Y�`��x�����ז/,����
+��=�C��
c�ٯ|6RN��c*��Rj>�V��3�������������)�����<��Y2���g�)���8�[�.,����
�?���|TӧT|=Cn�]��f-�����g�N
�6Z~��0�c'��~�m�I��,�X0�jK���
�c��v��8�6y�'Lr�
�V�ʤ�Ga���^&Lz
a�ٓ�b��-
j�)vs�
�3,k��/^
�X�gW�����ă�
ل>��#˅��̂��,��YlW�c��/�2����+wÙ�����=_��nG2�s���������HV/��4%��u���\��d��U]˝�H����ԝf	LҺ��p�d�;z��L���4M����H۽*%R�aZvGI�?s"̀��Y"8�Uv�U+�f�p��I3i�$暮�-�a�������Ypᾃ�n��-��tw��J��\v��d
K�n�Le���t��
��!���ʺcAX���{�`��_2����id;H�NV��ll�	�N�yC
醶�̘NX3X��>̾��i�)
�\ ��N�n���g�� ��
�
2
��^
�i
+iq%H��A��ś�$�U��`����P�R��E!b|g>�ȍhfn�4����:�F�����=���
b���r��g��ū�*�q9�6��X5�K$�ͭ��$
��ޭW����O��H'A����kD'
��aF=�۔_�Y�=���
8�
+�F��:�y�����4OR�t/��;�,]�xY����n�����pf�"���3 �5x�����ә ���4����!�,�y�)���-~�Y_�����e?�;��
o��.�)ֈ�� bˁ�
�LNI�q�a�j_ٞ���O$�ߖTl�u��	iAw
T�A`�L�,귧\�&j��$Koj'�>3�ugpn;薚�#`�������E�
��.���Xd,�Wi�
fŸVJ�y�"LU2��8t\[8�{��������ny���V64�UcOn�f&|�+��X����t��m�-�e���!�϶�K��vl6�����ez@�����w�݇�5"{�
+G3�ِ@o�d5�����h�q�Oi
��G��?r'yks�
e�>	�*�� ~���r���),�\�hhy�����I�tz����g�3 ƀ�;���n���Iw�I�סb��"�Ì��p|��v
���
..l�x�dyq��ҏ�Hy�[U���v
aTp<v���x
����Q),�L����MK,6g)ٖYGP� ?l8`�Z1Vp¡>g�X�����{�l-�ټ�H$$D�2���{�ũ�}P��PɥX��W6,N�$��ƱF]x�y{h����S��}
GV��DZ��ou�l��jZ�
"��
�$�[a��V[����u\~�B
�煖��I 7Ax8�;��kD-\җ�^@�9�	��b�
߇��+��<��[P�"�ɗ$�9��/Cj�I/C
+�� �!PEV��z�P٪��U����c�_��
[x
��Q*��}Rs�q����t:/�d<F�j���PS��@�Z��m���ӏ Et�X4�t��ţ
V�	�Z�M%��X/qt �j	��k	wp�N]�y*���i*����;Pv���T'�W��SF�M�{��t��8�I^|�C�F `���C�P�f�"F�{�e�����|��+�b�Y��3+��>����N�q/Y
#�nNP��PG���ck8u`B�w`|6AvRMw��AK	`�c�3˵��h27����m–5���dN���7NVXQw
vj�Q���׊�p�64���~��m�f�Dz���#�x~*�VX� h.��0r����d��7����
+�k#<CO�E��S��"�ņ���ȼ
+�B��Q.}�$���'wOz���+���5y?p���}�[���q�G	37�S��Sc$�m&���J@"�y����*��F�8�]�p��S���~���h�����M��J\-J�F^l1��8�}9 -��IF,3T���>�����b��
ݭ{�����~��
k��K�ƞ��I�ыw���C��!qǔ��Ռ�����,|���Q��a�I׸h��G�5Xvn�޷�Ӫ��� -������3 �������̈́�玼|܏q�O����؎�k���n���0X�ӻ#��
||��/�֫�S	<���~�~��)gW#�~d
��|0��
���lI��,~��~�J��B�NQ���sPV�����` A(��[b ����
�{�3N4Ԇ�K����_h���xM��/�
�*�4�l�/H���|i��Rn�[躷+(d�{��0PHa�UK@{\�@B4&)��s�t��}��_&bt-4z+����O#���9	�@B<�=
��
ȏ�9�cC8���ގ5��
+��^�I��O�A2�4�]"Ұ5+�g�0":1\%Pl�FRw��S7
+٩��P���+~�LQ>4�56���M� /��Nj����X���e�n���^c����4��!?�>���i 
7�V
d���
�&�P���
/"��c��#��&�$�@Z��&�
!v����wc
�L�� <�=i�Q�p#U�?��P�a�@
�"�
�8�e�&�e@~f[o�FZ�w�*#Hjy
��ɤg�2
+�Nf�1Ɛ
�cԶ@b6-�̄���3�Ƹx1�ð�221,��}
�9
��#�
0l�6
;f�ccc^�J�:
�����vV� �tD���mh�ӗA�<k4�
+���K�	�;��^�°���vEǃX��zPM���P=�Cp�c���U�E
�! P:q=�zQg� ��&���Y
��9�
�m���Pu�����n�tqy��~2G��{���4&?� 3`Ҍ�4�� �wJX`��
3���C2�X؈.O��Y��o���N9X���N*nI�Q0Z���Qkm\h��>+
+[�A��g�h��)��"�#�y��	��|���m0,0��T(�G at w-�p��G��H)
_���
�O�%����\`��5��60��8=�v:o	
�2H#{���BD����ӅF�e�ψ�(:=hH�嘯�t��ȾR���+Y
+�)+����H�����'|��)d��X.�n����0��6@���zg� �<i�$�
�ڃ���4.����mvf�@八��	���`v�D��>Z.?�ޱ���'��
k����3�ƶ�\!Т��F@�U	7ң��y|&���\��J����ь���%u'S�i�����_ ���jOs
���_�3 ���a*1&��1�ES����V�F����4�7v�s�
���� 34���C��߸�4$�s���X.�2af�F��d�U��0hǠ������xeX��1�
�
+��D�TLQ��U�*�$y�P[h:�zgZ�kψg(B��HMĈ�V�+��O2SlZ�9
�f��9ڈ��j`y[�J�.� 
+=K�B�
+���$aW�Or���1>1�v��%�6����{ap
ˍ�v~^Bx�\ޣ(�宎NOۯҸ������(���������Y�::-~|�a�(^ߑ��r}�p��_ZH�ѡ���l���‘��Byv�@L������Ӡf��\�Χ�֣�k65��~�K���b ������͗�����,h�M�
��&೭߃ƍ����}�@�G-%+�}�c�];�
+�SC�=����|��ҝ�:���X�X"��t��b�Z�<ia
�����󽹆�D���Ɗ[w���gK�>��)ƴ���e��j�W?�����'c�'Ϲ�;�z��)��{l��ɗ/��H\n7 eD�X���v�M��Q<���_�P�t"ɐ��,1 �@
�VI	FY at h_�`6
�n&�v��z<^ޤ`����zf

u0�(�E�jw�[���%�<
+�����$��u%�驕�onSF����J>��S{����O�^�L+���O���S�'"�0_��9%G֋v����,���\[3��P
��Շ3�J����-�"��e���Ƴ��7��9(j��^G����<���^#�ٶ�z�1�ߤlLϔ3��V<D��k��s�ޞ~H����4�d���y���xY zgõ�BrR)��Y��wux�-R}J�Iɻ
�����z�����q3D>&��p�
5�\~O�<8�0�����
�[m038���'�q�&yKfЖB:�~U.���fq8�F��=?����	3G�wnv���^�1�B�W�'�x�C'�:��
����(#T���	
��S��".�G�c�a}X�yҚ�OF�������YG8
����o
s��l��$s�*�ƻ������20���*2
U�:wv
�D�Ó/�%-�M!�	�x("^�c��u"~�wj
l�C\���0L��ʾʌH�Z
�y��|��_�OZh��t��0e�C�(D$�+Bsk�'�̙�i��Dk�e�x?r��5�=��{�����Mw��,�/�,=;�Hs�^�CX�7wR�W�}��{���>�A�(T蕜�^ܝ��X���<�v/N��aR- �_^&���)*Y߯j�E6Ѻ;�mvd(J�����3T>�R$
����|�F(���HO�g�a��|�8�7f��ז�bZ6���AAYL? L�Z�R�yai�������u
���'04?�D”�����A	���L�50�$�
���Դ�����#G��F�X��[�!�����{M�9�����|O�'�K�Ob��r6����R�)R�U&L�A���ΊX��:�{+s7�	��X�Uf��+O��Q���JO�r�G3��0��
+G���R��=������=[QZ��
��o�R���ٖ��{vV4v�`u�¨��p_��٭;
�>�O��Qc�2.�
�(��x�ϵkL�%W�
5N^�&�鄅��|�r�6�<
��`m��\Kz��V�K=�r4��fϘ��}dxVC1�t��8��"� ����f�'��H�6��N���0�
^�w8�Uә�
t�-H��e���;�tڱ0
�ci��1��x��B(�mYw��1�վ�,�_���@�L{7��-
+%��c<�?~���6d�X�){�DZ$B.������e����-�I�/�Ɋ�N��X��̩%�owW���_�I3g׈JNW\f��
aK���d#�u���]?�9
ݜ\qCL��5��s{+�;m����eW�����<Zfy���
�����A��N��4?Tc8\j��ϿL��/�D�S���5�;~��o)Ӧ�X2G�����ѝ.���n4�k�+p�*[%[��J3
O�;�9�m��f�;p�a��ew��-p]M��Y
���3J ���
+ԋ�>�]�x\���#ѧ�U0��/Y
�U6IJ�4jcY�F�e�H�j�˥.�&6Z
�(^��ң�������::�E���@lq�>�
�ݞ�++ьOE���~6����o�
�a[��hB&�s_��,�zC�^��5j!��u+Ț�0�5[���O��#{�|�OܨСW��lt��+jƧa�,?���Ɔy�[|z���kq�����������/���������L�!����?�������������|��o��������_�����m����?��������ɿ������q���ߥ_��w�~�w��w�_���J}�����������
���K��������/��ѿ�7���/��@�`��f*�
u�T!~{�ow
+O��o�;�#���ے��^�
�5�=?�ag>lږ

��� ���|'�FC���{��!���O-y����-�Bw����y<������s��x�m\������q�BX��p�:	sΙ/�Kt���n|�pY�,<�v�k|��(x�`*��J�:��,���]�f�P߁.��M���B��y
+N������]�ޭ�/PE��]�EX]������Ζa3\f��
+�x�{y{3�*Z�v�a�ν�
�k�_��І.|\��\
���a�����I�# �s���ʅ�5�=����MԵ�J^�lc�

+x�t����HW�
oy�� ���C>
�!�ŭq0(�� �Ǟܥ�{�qܧ�0�	Y��
UՄieo�\��l�O��Nx�?\R���C�a�
�N�\�%��o�_��[Ȉ��qk
+fϯN@��Pke
)ta�#�^W l��qq�Ŏ�,ʧ�f�rt`��JT��X��}�҃�I���ꦷ
�
?�;��Ÿ'+
.���r�!E�]�G���ؽ���F���'��2��iEC>�P�'��Y2�X+qM���=i��}��S�F�
+!
�ʇw[��T�=�8?c��<w[�Gg�m
�!0㏔]hV'g�u�Ln'�
�c�����ܽ�%�hV���=��o���_v��Mϯ�5D0c��$���g!?d5>����gC�m���@��x��� �q����_m���9}�Yy�� ���T�nB���h<��CdPp�[�x�g
�Ô❲ �>853[|*N����>�Y0A��O�2��#b6?���yG���(��8P��W
R�0���.
���
�|���gm��Ӣ@N[n|��T����w-�s
6-�9�ֈ��y���C\���3AY�y���ˊw-��4E��v���a˪�x �$"�e�m�mB�Ѫ�<dP�����m_7o�rG���'��j��7mh�!��A� W�
{��
i{�^*�n����� l�n����2�ܠv�����kBs(���P�ڜ��:��Lzv��Q�r0{�t�!a�R� O���ͷ����U2�f
�P�I�͚c+��u>�R��0�v�b
�9=^��Z9jA턛@��1����R�P�g[M���Ӆ�_j�
'(���
��>�i�A�Z�_LP��==����Ѳ�E�c�f�7ԣ�� {��VW5��
F�	�RX�nwuX
K��A����u�rc`s���A�@_إ�›��L%xy&A���t���n���`�l����Tvv��?-2��pv=�+Z�S�#�[���[0���<=�9	�=\��f��l��)�9� ,,���L��9ֆ_�ѻn�!	B�:�ε�XR2�`������`;R��	�|�F���:��qЌ�Ѕ�U��*�� [...]
+���%��l؏!�ɶ�,�!`:��03a r�bj!��"�|F�c�!�z�y;=�
r,�B�ݔn׋yoa�
�
+�k<R�ɖ�Q�{���R
,��/*ǖ��	�wݑ����K�:����LDT-._E�4A*#F 
 ��=ɳ:^��+�H��.� G�oR��SŅvLz�F*����
��Q㓑�b�3�[�-ӣ��L\ض�ڒ�\Xh?��v9�
��j9��Pm�����M]x<2RWx �d�ǣ�K���
����V3-AE>\>�`�6�o��V�r�p&��'mO��0��'-8ʖ �4�s�|���n���p�&��-3�"�����MMFlNd%Ms��E��Z�t�{h]^�
7�٤��$>L/�
Q���T����fマ�m���Ǚ��r�g�đ}�G�X��{�����%cM�9��S
y��ь(��T�w�]
�����Ԛ���)�3��N�‡�p�
B+�'EP�wMK憫V���]Q>�ɍ��Ђ�~?��:�V�
V�`%w��rV
ï5tA��Z(e=���ܱ���v,7��٣&��Ί��=�o�ᶖ���"����p
Qf���b�-�.��PX��*j@�����L�|:���B��)wak,j߆�
%h� QJz��W#7y������&���^|���ȹW�E [...]
W�W���
:/U�����'o��l�lR��
�Z7�
 T)�8�]����r��h95ώ����H��Nwo�!�Ȱ.m��ab������R���!`��N��`�VwM��D�H.+�f�{
G|x�)�
U�]�{��w!���mA����=��~
����D�t\o��|�,���/��^������v>�_�x��=�?��/�B~�_=�g��D��|y���� 4,���>D���M��z���$��!C���
օVq��}�uZX�H9�n�5Ko�gE����Ƶ��%
{З{�j�U��|1�"�No��55�N�C������	V�&��*
+(V��
v�FG�s�:��'�z��
+H�,�&�ue��ܝ܍��BKc����o3����s�i=��

W�Ut��Y8�F|�
VN�-�5`��Iq�
T܃SqS�p�!�B*�
�qKݘ��C]�ZrnR֌�mwۺPnuX���-P&���ٽ���&akR�X�ݥrW�4�e�[~����/��(�mf�L����\,�>�!<����������鏹ba�"�o��Z�9�Odɒ�e|����e��,�B����yc^���s��n�8�ώ��nt,�v�^�}
��l-^3�}��0��n�*�
Ju�c�o\н�޵z���,�	��(n��s,)��^�;�?��ȱ�]Xys��A8����L�iGT�
d�$3�tN�Vg�,��Z:�&NT7�&C4�<J���`|Xފ�Bmh�˾�k��D���n*��:O��m\���S��o�V}�V��M<��s�ӿ

/|��
Q8�P#�V�
+P\��#�b>��b�W���xأG��%���w��y��Tn�L9�S���(GJ��gP��(=ŗH?�R���A� n��T�"��.9�|�4��{��l Zޮ ��=<���j��";�
S�r�e����;_��]�A�A�
��n�"	!L�楛.O4�A�J��x��Ɨ�'��L�n
 ,�\&;� R�|�fϪ���G~�,�$r��������@q�_QX@��i�N��8����K��
!Qy���
Q����_~]>�5NE>c�T����||�r!>�
]Ը
�ų4����^Zp�N�р�e`ś�o��?��ĵg��/�5�e�zH
�@���!5�L�@X1=[ݹ�#��x��$j�Y��}3����./z��i2�gzx��W�֭�
��Q<�1�j�T
��#L���RK�qe {4k �\�P�� ��8 �]�e;Ṫ��%�Ќ�xt����7ˏ����x}i�iϛ��=2��qn��X
�����~F�c":X��1TW屌�'~V7��ž�ǡn��Y�cF�1^ �@1�^Њ�[j����W�
+
��@&��
��a�:�������
����z���k`9W�ޛJnr������?��_���?����o����?A�O�X)ö�?��������?��O��o��۷������?�-
�����x���4�r
T������NW��ᙛj2xV��7{+�u���w��\������plK��q�5�
+/$熉�K8��ՙ� �7vڇ_�
��o�]ͮ>q�|礇�m���Hc�Ic��/�-̥�<�)�
!
s� б<^�L�c
�m�!����m9Y�a��
a�E��b<)_�0�m~|��k_��d�>�>
ӍB�_%����arƘw�ŕI�L�X�l�tJn�[����҄�%�������q_�t_ٶ-r� 0�:��	s�ud
�B�!~<m���a(3�nɦ
�oM� �e`�l���Bs���`q4�2Hn� x�
���q¡��fo�����J4��g�/_r\Z�{�4w5�AP���\}S3�F�
�
o�7�}
��q�n?�w��
+����z�w��]
d
y�-�3���K
�?�GY&�j�T��^�������>�{wI#)��6�~�F�Mв�5-�<	�A �qC��eA�eO).�Q�ɤ�|����Umu����J�p��%d�
���R����
�eL�(G�"����pr^>{�G�[�N�� ��iK�	s~��h�
W�
/��
2�#�x5Lޥ���B
mQ�[�� �S���%8u���2�}iZ��/,(7�"6��
v4��Z��׭���@�#���3%�"GE��&���H9..{X�$���g��%�����g,�����K�=VKk
+���
E���m���ި���, J%ʟB��'�ۢg`9A�7�`D

r�K��2���<��"�
d�
��
+ۧ)��C��vda���h���a�cڠ;��g�Xs���|��B_�y
!��\�ŧ{�vu��R#v��>2y��t���5��a%ߘ�=#�a��OfXʷ�"@
(��
�������kʭ�.�۬Pˍ���0c��[(�ú[h����>1���%�&�;�r�fE�+S$݃>�^���$ț�,TQb
!t�	hE��VNj!
��ǘQ
^S��|��
�R��k�z{��䄶o���b�d���Í�=h�|��o��Ѯ7B�bO�V�Y��Ԥ;�H�T���-
�wh>����u����&��"��7���b�/A���2���7e fb�z��/��I��p��>�R�,GN��
J�����ɥ���!�	�7�gx��WaVy
H��P~��[�E'X!m�n������
�%�i�0(�҇��|ZX����BcI��FFū{%�����J���edea[68�
�i�pVʌ`��!k�R�P�6��xV!|����\f���`�8؄Yb8T�,�9�yrG��[
>뼊��O6�J�����=�_B܈쮧�����w5��!�X�+�rŭ�4({�?&�q����	�~;=|��Z��G�J��n䘰^X%�cT�ݜX�\q�,.�3dR�BQ�����ԅ�-|������"�������5�&vw ���)
'	����.���$gV���qP�2G��$� D����_�1=�?��8n�;
7��
*
YX h��^�!J�59H~����"�<1�gtQH�6,T���"�q�|���H�%���FQ� ��a�2�*���-Lͪ�@S��n���h@y\��
�@.��'��ݛ�{>!����t��y�[Ϛm&pU��g��{���=x�B��p�
!0w�X��,�.wS9��h��`��
{D�S���C�Ңoʚ]t4[�MI��
�t��?�C�h
+-Y�9��/�
�9���?��ɇ����\��<��yd.�h�>>Ȉ�7�B
 M0\���5a�֛�*oF��b n���V���sa����VW&A-����fq1ͽ�p@$ץ+0Z/x6�
eb�c%_<Ʈ���b����`~y�
lb�
wg��
����#|7�&�be$~�\������|x���B	X@%��-�
r��-���}�
o�
O7�z�
�C�_ᖘ;�0E��H�Zj 5:�Sd/Z�m��{ ,�i�,�<PԈr�K���$�՞
���`����a��o�b�u
�2����*y
+MF��Dq-��in��"φɇ� ��1��DU+��ɤ<�\��
�
�5��\�92�>�%ʠJ��c�$Н@v��|�<U�DA^�������Ӣ���ڔ|�䂳��
;f��u����-G����?��~�k]�a'��e ̷�L���{m�(Zs�����I:A}�pș�~=���
���'\-9U�y��:���}μp���̜,<�fҪ����_��+��6;
-.��glcqZt��=={ �ꙗHc-��O
�-5�x��7i�����L)��S$|<��0/`�i�����;�
�z�����Q�i���܁�&�2����rf�}��o1B������7�7i�F�J80���	s�ˎ �ON�Z��%RvX����~)�h�C�?|)��-�r��V
9�s|��}t��:�����㜮�E�J������㎉ܳ.���HUe\�þ��>�vyǥ���tv|�D�s2E�x����7����
O_���6O�I�G�AG�Q��T�s��d�ygfG�a:ҽ����w�O�K�?><�ط�|3+����лL7hזW�3� [...]
+�t�.���$ �"�O΍��H��[$.g.�����_^~�
sׂ�g�yZ��?Ts-H)�+�]�?�·e�X5K���1>#UͰH1��j'��n
�cp"'%	"�1�r�p��qy���i�#���D�����_\���բ��R
(&7�

��c6C|q�+��!�s?�@%֒�9,c�~��R�=oec��!Gf��LI��Ԟ�Av!����u�nȖ��D|1�{��ys��6YA1��u��7Z�Lx�J�u�c�D�eI�����
T��w-'�ϊeh��QY��|E�De���8�
8�z���>-�������'E����J�V
�ٺz��#I�]i��̫`J��,�yV��F�|db�d2�K��f�8��44ƥ�9^K����u����m-��_i�V��o9Y=Kr� �~r������
+&��y`v��a��q#L�i-�Ŀ��m�H5f�\�=�V�;���(�����OTVH��g*�Y���'S�rn�� ~�5}xق;�?����I�Ь�����o8�W��as��ҏ�HG_-�ʂf�A(�)(��aF_�(Y�dsB$�V�g#Sy�A�������ЁJpm@ؤέ���G�z%������|��aS
�ʬ4b 
�0�-��'��RN��:��
���*&طc6%��K�����co�<���qk8S��c�o������w��*�'V :!����u�
+p�]g���yX�k�����ӁZT
+)��
���@����b�_R�J��6Խ��f��;��ά�j������!�$��}Z��1��sU� ��V��s��<G�J	+8��1�!L�ά4|� E�*�gE�y�tC����:��B�
z؈��"l��<i&L�	
lnU�B�ߋxT�TZA���؇
h�$�Z���
D%�����ܥ�X�X�D��+G:�l
��
+�d�@.����&Cꀇ�W����E�?܅o�a�bC�F
����(Ҡ����!,:&�eڗ�X>
\
v���
����_�-�$%�EA�
j�9i����m`٦R��� �u�C�81����:�{�����V��ؑ�s��;o�C������M+��1c%\g��q:W�QƦO��'*YbP���^�7&@��M
����U͎*�����VfH�[�&S����5��J�e!
+�(m��?D�өi�G��
�vد%��HC�+,6u<L�R�]%Tm�Ǥ��(J���˵`z���Ղ0���,�T���>X�'
+�J��qZ7�����GmMaE
/`xB24Y�	Ze���\J�L��?O�[��h�=6�cC�r�gʋe�{�˜R�� ��<ق���R;	���EV�D��Q�mV-���
�_l�
_�]�U���<s
0���Ð����Gwۍi+
�����`�9GD�;\I�F�)9��+(�-)����6
<�D�^ϋ�`Π�
�48�3��
�Tf��M''(D���B�tpL�����]J�V�I�ˆ�5�OǷ�J�����c��t���%��4E�F:� c��9va�_Z���	F5X�
ϭ�!O
+�[ao����n���J/��y`]�K�P��
��}�yTŚʓ�U���?ܢ{�|��>L�]��*���}��Ҿt���&���I
+_}�6ے����@�T�/~�r��W�'����X��A�_d}B̭
aP&&�hؙn��䅧:�
+�Hw���� ����x�4�;�0B��R���V���r�ja�Y�/���=?š�
����©��cB�̟K!���Y!����Qa-��!����ә��o1���dQ��!��*�HP��,!�
�ҡ/*Q��V��L�o���g�5��I�L���>5��*���X��
]�
���Ag�k�0_��"��G�(5�0Q��7�}]h�P�,C���z�È�f{4�.Q���J������ �Y1	��T�h���͗
�Њ���T��
�@9�\#,/$a/��k�@������crJ at D�S��s�\
+���KQ�$m	Or�%u
�$��)�%
���C�UkA����!O�����vC!�oMv%Pd=�
&t�2�lN��>���ˇ}8S	(�&7�)zc�c�x
�ԡv�A�`
�a��cok2�uݼ��ݹ���w��Z��)c���gN��W��M��J��f�;y~>�>N-�7��'����}e�B�y͓�]�3�LGm(G�r�X
�B+3�a�^� LJ���H��.���O��;���J*���=��ڍ���XЂ���a��q[�� �BI.>6���7"�g�//���A��T���oQ»�ݾ� ������W~(d�`��K�ܢx��0��_q�R����Pv�
l�8Q	S��Q͛㸂�eޙt^��'�gS{�
���&Q��tb#�8�}vg�`�4-mD߶x�C�I��o���Ϗ��-��ъ����y��X�����Juv"u�eܛC̹Շ66�
+�r��ˉ�Ըc1�Q C�p�+�Pr�߿�I�8�n��
+���.7V��/��@ɖ�\����[�/�F�}r�������򸂉49�!�`�/����>�^����#�B4>&�Y�	XKnG���A��*O�
���S�ʵUL��A�q[N�Š�n��GR#�5_�k=�m��!t�
�d���y�䐸��[�}57�R����]
���gK
<��ñwv�o77���|�
�~��E�!Ό_�p�"���z�y���םy�Q������)7E�X�`;��~�ޮ!���k_?o9�?:<

�ikQ)�O|1:,��5�/$�jr�k�@Q�
+M��%��=Ի><-���tӦ�#A\(����j��wx"�7�@]�
n�P��%�?��\T=|W�c-�%'E�ݷd�
��c�B� M��њ�E
+v!:�_T��4(�Y�S��}�1t�Z��
Kmo9	��	
�Y�)a�z^'D�[��ٝ�_���
ˠ�ҿk|F���p��K4�xn>����j
�{^t�j�-V%��I��=�������w�ܬ�+e�c
u�I��Q�I&�\#��U����fG�Y��\Q���Y����
!�
)Y�g
!c�����,R�á�n�(%����r�z����rV�z�!
+.	�����Q�N��މ"&fZ�5���^.Wv/EqQ���M���d �JS�<�n)+p�+hr
Kp��5J�y߇s��H]���Ȼ8��vλP�����n	�Y����)��iu dYT�T�@n��7��}��z����
��=�[{Y�YTOe;)0���J�$��nyU�=)0V�uJ��z�u	
�xZpF9���x�}4��^�45�Ȏ4M�x��y;�N����jB*&�|PȀ~
+7��.|��_�Nv�P
�39r�
”T�M��u�!�h��
RFy���dO�r������
�G��`��Zn[���
����Wj�|&ߏ\wM��aB�P�b ��s�׻�}��/�� ���{�
+�[��xG���@
+9�.�� H�
hv��!>Q�
l��l��\}�2�P���g��A�߲gxF}E���boĚ�٨����k�zx�ʝmG��w%-ij�`$I�
9JPg���'!��sM�p��{BФ��(|�� ߮���/��_�p��,��`a��s �j�A9N��F6�LU}�8v������/y��)X݈��A�\��o<ɍ#�,�
+�������"����&���@#��&R
��f���h`L
��к�P��TXcX	 ��U� �0���
����D5�z]��"-
ȴ�CI
,>ɭ1�B�/ŇmQ�zRQ�L4��KKX{~��
��P8�D��L
.�6"�����7;{[ ˤ]��� �e�Ö-���ʌ�'��l�
+iv[M-
ĻO��2��
�qU�C�R��Eo)>m�5
��,�eͤ���
+BQ��U����\���pX�P<
υ;�'�M��2w���Xˑ+��ڲU#N��80N,?�!�R��-��\�ߟ:������ş��Z�7��q��8�7SF �:��q�#�
w��
D�H�3AoƟ4#�.rč||��
��L�(�8�����؊��YP��u�
̺�p]�{�
�R�#�
@)��6�ƟK��6\��Sv
+
p�
h�����h]�^�w�-�+n
s�^��U��Nϩ޼sҝ!��4����U�W <�~�d)Zء�z�2 �nX�.��d�5�L.[9;8�-�+Ȗ
�c�ߤ*[ZW�Ȯ�6b�&��]
��De9eJ�,w���̧C��Vu��?�p'�l#]
��ݴ��o�Q���(���CZ�TW�
�'��ps�1N��7"ѥD����T�e!L�ke2��xΓ
̞��Ȧ�5s,�p�d��z�+β��\�u�;s�	�8!�
e�=MENqXg R�F�Z"9z��_�\3O�*a/;s.��B�bF�˻fs�����̞~��c��)�`4K��|9{�`	�`9&\Iw�RK�͌L��C�AhT�v(�q�)����߉�m���l:7�v���(��=��i�c��1�&�r�9w�vq��K���p�C�
�_F�ɜ8<'�"@�Wpu�\����ҁ$�گ;=�뷞b+4�����
�ē�|��e�ioJm<�d�D7���rH�J�ҩ� :�I�h
�|%�j���HWՏ��T��%�el�\���nB����[o��!o��Ԭ5v��@��<�\
CŒt+@�D�߮�
�
���Pl �B2� -�k��l�L4�E�a|��'"�ڎ�

��;I��BE�c�
D��) ���߮"!#=��,�tx�\A$�O�/�Д [...]
+$��MD�.)�v�YP�¢{~i��<�si������y���iI�_K;�.�����7ɷ�P��V��L&��!��<��E��ܱ�
��o#T�����Ti
��i.Ɗ��dDpne
�6ܭ�#��K��U	���!34�S�o��Jk5��������g>���B�s-��MI���hO] X��
+5*�6a�ͬЮt.�O
�Ϡ�i��疐
.�S�N
�g6�K�H��}LH��\�vMN�C��
+�BM:��,����<�ւ*Z'БM�,�(�̤;v*��?r��߭�b��g�xx�L6՞(�RC�դ�w�,�r��GŁQ�"e�����SDT�r���'�

�%�x:�z�PG��chv#kL�0&��)�
+�#�Gv�e ,=L���
����8��x�U��#�[��;لT�
+SOO
K�G��f�;�ȄE5� ��hA�������6��6�k#
+l�\/ȉ�<����P�
�������.Ʒ�ܑp��,�p����[#zw�LXz嬑���挹lj��fJ"�M-(W$��,
C�M��0�d�B	�{���F���$,ME���v�
�.tZN�b�!� -��-��Aڼ�[�����d����=�,�;��/�1���%F�.L���H`��(A�U<��%fݩ#B��hQ�9��"��|�U�9����X��=�M� _:'��
+<O��%�f�f
U]،�w��
�e��J�S ]�<�T�"m�����2xe��س�Ro�;���'N6�U&\Kq��m8�झ��uUq�v3��j��L�uS�cJ��'v+�	bX�� �|5e2YaAJe'-��Rj6j�NU,]V��h�
d#X��RWdE<��I�������ƪ㯃ɀ�C�
УL�P�M���FZ��Z*;
fX�
��j�^A6�� ��g�|���1B�m��,�|@,�pu����d�,Y`��N�8f������e:��=���2_���O~wN�Ύ��m'�{�m�b��]��ک���-2B����`9Tj��Q���s��c�"��-3�
��L�%��:3:�x.$���te�f�\�ñ'M�߭l|�&A,x��3�;��M�)��zg��Qj������=ZDH�<���V`d�]p�~X/$`򤇅Կ�;��#�!o恔��"����v�=ʲW�b�.��]U3�
��!��FS�(�H8S**x�XO�A��V�J�^�PF� [...]
+�Ap��b�q�8� ���:t$6G��?Ѫ/۫
$D�jD$Ȏ
*��
������<V$��\�A���^�8�{.'[
"������Z��όc���`2�\�v_eq�����˩_;�5G�,v�_#����
�r�~'��j���y�FR
��B�з'�>�k$W�9���ߥd�Σ�^r�[�:M?�s]qa�9��0&?���R#K-ħ�
�
��q����U���7��]Q~��
^�z
�.�� I��o�N1��N3
�t
�*x�|�:@H,
F�ŭ�;y��5ř��
�`jU/ �����w��
������o��k��K���s�1�O�k{<�N�4ڴ�N·
+��
=���pd
��A(�����UI�f�
F=�.�(�0oKy��0A�'��g����s-�	GAA+O��T��V�('kW���^[|1�`#$Z����3Zf�����k�c��Յ=��ˡy���28��z� �o���Ck�
�0L�&Vw��[��>a
�~�NjH��_�
Bإ�1Z lђ6�ha=.��,*�h���g�������~Y�B(��
&�I�
;���
���@J��Z���������kS��C>Nv*+_"!fȒ*���B=ǩ�W�U�B�a.f���<��M
:Xb�D-��eկ�r�0�r�l[p�
UU���<	r���c�5��G�P{�>�~�.����N]1���ea*�N?S�����m�hW���u'��v?��9�P�`
+*:�=6u�٥��k���?�\~�vȓ�J����A�7j{���Y
҃��,�7�kƎ�����zv�w
G�C�t�a'����;�ꮌVi"Q}ӗ����L�K���ן�WB�%��m����S#Z�Z�{m�j�˷�g�

'��������R��
�hS��&�[�z,1�T�
3Vġk*|
+yh4�
�����ܑ8f�"Hvp 氀���S�
�-3Q���[L*]�������p
H��sd�t|���T�6���rmR!MgM	YR
��Y=r�SD"o0*%���Ȏ|Y�y�ၚ2�4
�ůő��f��~��my����)[�u�`��-�k�⁓�}7���
C�³I��2��fȯ|��U���)���Z/��E�7jp
� �%(ZP+���=
+I�\vW�K�MSZ�Ք�n
]�ܥ\��~W�C�^�K�V�M���ݪL��ƍ!cApK,��KM�Q���t��Pk܀-
+;!v��##��:Z
� �8gO�0V#}E�A�0��"[�Bg
�r>Z��o:� �)�
@z�G��)��B9���c���j���t���
=��N�'
C�1|FY����6�MCO�0�F��^���WF�H���i�т������FS�
+��SHa���C	��)�D{�=��YiSڥ���6�����=Y\ȏY'b�Q�(���ȍ���R���-�0 <�PY�o����F�����AH��5#�H��p:fi=N⭈Y%�����<^�N
�RL�5�ˀ�M3ҧ!
6�]"8;`
��u�+j-�"��|A���eF\
�#◢i���=��*�i���B�Q�ixq>̲�0A]�{�0�}�Q
z�o=�GLj�9\��������b
X�}K�0��_\��}n�.S_�G	~���Q��pxZ��Z�
�M�5L�"{�Ks�J��,{�;V�M�An#b�"z��_`4���~�]��U�[�׃��*uw
+/�����
1-��8v��[=8=�
+ʜ*���
�s�Ī"��Ԇ`�8�id�
� Z������
+C}1��Ѱ�K�!,N�a�s�ϋ80�8���"b|c
��)��.T������^Ba5�x���ɲ1'>i,�.ltz
+��Տ�g(N�3�{�;�,P�<D�q
�8�@�6#�"�L;AB��e�,c{XQY�-�F1>yѽ��7�}g,;A�.lzU?��
 �%O#k�`���3U>
N���*i
+>Sjr��'��W@\�W��U,7u:,,��ٝ���|��l�8]M
�;j�!�b6��7�)U�
}������2H.�\��d�%��M$����^�� /��o��0���k����׾�*D�^$J��)Ox�A6���)<d#vv�뺗��x��1�Z��3QADŽ��@��`�]�ѷ��u����A����ð��	=WnMY���'7G��'�(.Β��4.� ����=���5-�W�Wt�TAǘ8{(D诊V�"���_C{ �I����^�
�p]�`��W�Hrr��X������\qOU�C��Cq,�uX��{�0qZʴ�#"�3�16I�]9��!�ڟF��W)���8̠Jm�Z;��I�'�EDt^<�^�;�W�f ��2$��P����}TC�5+I/�I���:Uw~�h�$M��q	�nv�
��u��}�]-�3��w�z
��!QQ	��\�P��)˦p� �=n�Μ~��޵�#�|`qt
�+s6R��ć�4�%�]�UP����;!��$�
+�(F�%m��3�)ʬ��c�Q��ED
�S��O��
3!��!���v[�C�i><��XYv_�϶
��g^���� �Ԝz�<ŷ�U�g�V�2Zȁ&R8�18W�R6J0h�5�C���RqiO�H��ߑۜ��v(��w�����^�� 4W�
ũ�8���!�����
)3�E��M�-5<Ha�8�-����ߪ�"
̅�
ǻ��[�=�^�I�B5�퍥�
���P
�a{c��$&�-�\��y^�6�x0�GGtm*�M�Y�u0�`bk3����
��n,ۼA���֌��::>�cj�7��!>�C ��Ԋ7
+��CqlS�>
�7(,��^fN��3z�\�[�̭���[O�t��TRI��iF�)}�`͛�B�
���(1�q�_M��~���=�l#�-�m�Я��Bɭ߱w�����
�3
�� vB 0��=>�vs	�~
�
�x�&�0�F�1֝bTmKX./L~
}���eҮ�N��`�9��j*\5|�!�
nq��f�;'}�N<��H%�NO}�\8��*����{C.
�%�|BȺb��El�S�׋`ZA�V"8����y���T3�
�
�<C��刍
�������5�.�!ؠ�
o%�
Wq�
p�~A!/+Tfo��F���L�d�
��e��X�a�3�X��Z���Y{��7��M.
+�[Y�+��Z�(]��7���M�
��
+2�
+m�
mg��S
����+��a�o�B
�

U��g�߷
U��
X�` z_�Y$��l �7��V�O�C;j8X�k��U�z�m�d��U񰌻�A�S�U�!���%Lb�׃�;�

+���A=i#�
:���ϳ�D:�
koQHv4l�ޯdJ̀c[���&H�^���[>�k1�H��Y�"M1�PL��{
+���z��T�����N����=̂�H����&����#�J�����<�+�V�`)�TH�WEKcn��/p**�C���Fo?c�I9�����L;18p/��d<#cR@�*�^ۥ�
+-���Lj���'#�H��
+�����'X��n�d�w��bЄy�f@QB�ӯ+��d�A���Y
+,F�g }��Mw�z��j�����-����I�
+/?/r����feTFR�
+�1��.���>}�ŗg�����W9��g�����ˋN�*9"�
���z]��O�T��z� �+Y�b�#
��k|�N�;�]��Ys�����a���TL}�\����8�t�K�DŽҰ
^ޕoK���ӭ�ރE�SLg`��r��2˨��]e
�JqS�X����8�?�9��+QP|�)�.׽�l��W�P��1c��뢄G|(���]
T�m���x�\����˾�����ԙ}AN����2M!��RU-y�'�k��9��p�
K# Qɑ��Bힷ_
-�Ⱥ�CoSz�
+Ne
1���3��
�ʒ�n6�~�X��Q� ��/�V��
�-�����F
RƖ'�F-
)�;x{-�=y+�ab�Kr,��՛�D)MΉ3�Y-�*���]�ܻ��ta��ֲ��4���VrD�?E`YW�Fe���<,���U.Χ��)y�9>M��v� ��?��g��Xǯ-_�y�:��'��Ѕ��կ>�F���N�5�{v�&�c
+���%��t�ha`�
3�5#�\��J�vk
�b���\#���kjA#�q����b8�d	��'�3�C""-
4�ɃNu���
+B��L09�!����x���bk �L�pumrK&�����"\��.��Q�J�~�GߨA��O�͆S$tJҷG2���7o5
����y}C�G���Aa#���,��&��y_�O��Z�*��/Z�ʪ~�
�պ?-��F��.��W
�ְ�֔
+˘’�f-��!Z{�5
+~.���Č�J«�n"�]>��r�j��aJ|���fQ
+_�%��|�~�%�B�E�9�b���c
���fdX������`׉�*�O
]��x�׼�pFX.*h�PR�����\��ߕ�_�C�\���(����~��FĠ� ���S���ċ�`
�d��7]�82L
�<eC�C�R��\���[�
Ƨ�r"g(�W� V����'k�1R`uܦ.D���K�L�^U�w�
"�%�LU�
s"]�C��ܞ/p��_eV����e�Ѭ�sB��ݵ�F�]��Up��fys^��FM����+|�i�W�S#So֝S'ʼn؝ɔg	���Egk
�)��ʇf�p���O
1C�mYýg�j
]*#��=-��8y��dd�
~�JֈYa����e��s�j�u��y�p�\v
+�ʻ��/�f;�հC>|�����qʔ�m���.x����
�w��=9���J��|�SMq>)�<� �!�c���G��zH�Oe4��������2jM��xu����U�>��~�h�Ҝ$0A�����_�گ#����7ƾ�22��]-4�=��&&��D4FN����
�BY�
l�����
	j��i��_��ٍ�WT��qu8�h�V�}Qv���ȵE��KQa
��<�
+K��9J��9?��M�1u��T4m��q{Aw~��I�M����j�
٧�r]Q��dqVp��?V|�
��oT�������� 
�	U�u\{��j\R.$�
�l
ׂ
+EH
Q���%!����nZ| �{�KPfh�F�
^[�-���<�.
} J-t� ��	����A�������1l^�7ə���<�=��Ct�K�:2-�o��B�� �(�z`F��n${�0�4Y�b~�a*'A�M5�v�u%� UP~eh�
�,�
=����@0s��"�_��*L��j�9)�	�γ;��J�nᨶ�v��,�`#�~4�=�w�ޮג%;{��p_������[z"�~�ц
�I�@4I��0
B��"V���C�Ca3s���]����>"bq�=2q4��
P3�984��e�K��X��TP؎G�����1�������oh5�[A)�"��!w���F��2D"��� �/�ri̷�&;19������
(!��xkY"����"Vֵ-�]�*��&?��8�
�q

0�
�)�W��\�`��
�Uf�����`�
��㶆���A�U� �YY�5@�.�%
��x]���8B���3̯*ז��o8ky
�>RW(����0�(��@���jS"
+���ɲ���c�Fx�O��5�[�M�
����,�U_GҨ�I��y�ŧK����n)�C��&G��m{C
5%n��u&��6�kWtj�����p��c�<�	��]�?j0zp�U_�)�qċ���K"�ł�$>�
/��޺v�-�.m�����D����B���$v^ҥu]��Lh�����܎�0����X�!s~�-'Vg���l>^�FX��5���V�A�ɜ�1Иh�	pr8�z��v�ZY5$]���hK[�3oKݛo����D�`�Ʀ����ٌ�0�F�]
aK�b������
X�����8�Ю�� �z [���h�X��a�B���jo�|�ў��q�m?	ra�8�kow4��Q����3�‚vK����Т
+��"b��5R���<�]U4\:4Q	$+������4�����Nۺ-y�i�)nD���Ǎ����B�w�P\��,}�	���lx�0Çk]<3��B�v��nQ	��R�]�kZ��r��m�xn`��V$��F����&5�m�
+:ZȤ#l{D�zU?�A=o��5|����K���7��V�+�[f{\�L�L��p��Դ{�7/0O�����! �ش�S��I���{ښ�
���
��6U�$�k
uP�H�I�'	
���e߃�����Gu���P�Y��sS	!H�V/����DIK�g��Q���BL�G�m��ڭ^���er?r�7�H_�[	�c���N
PVGA��3�
+:�(!��"uo�
5����r�>i�lɝ�w}�~����ϭEB�0�.�j�ZCwDn�T���3�Y�.;�"�Bֶ��f��sWe���dk�
��$=�W*R�6(��`ޞ�
�x�
"�����p���&����B����v�Ļb3ɧ�*o�NEb
�
�A�A�]
�bصi�x�W��W=�G
S�Z��m�J!s��Fo�Y�$<.�Փ�`���@�KiK,��-{ڋ�z�Pq*���c��n!����b���˖oE�����z݊j;ۋ���:��rjv������p�k�2j�j"~�^���$�iى5/h �=�s�M�~�r��s�?�=0���nv��Q;��ߍ���8��llS8�-���!"�����&��A�=7�_�zS$�zt8��B���B��Is�Go'Dh#u5����
+
e�dL���C�c��.)�
��Ӯ�IL�=�f=E߬��M���]�| ��i}&=b��yMq
T�ʖU��R����lmݗh0f���Z�Ƹ-�r�vX�c��x;�
�O�o#V��&�dQk�P�CO�A�G�:�IZ�`�!�8��q�ơ�k��p������G<�=�"���IOG�UM�[O���[DMu�4�G�k���"��5�k��1�Q�/u1׫5��1VV4�{����-��^=�mӇ�[�QX��&���{Vy���Vk�
�n�l4��߈�8E�����&W<^.\�y6pȘ�hs[w��
@���6��MȬ9�l�|ۆ�K<2Qm0�9W�
�זy�����Y����#��>
���a濩�8&2��>�̀�hFx�U�zh
ܝa^�B��Zg�G�F at LR��m
Ƹ�뺷��I1
������ ?<��<5#oA6����}��L
%�ǴJ?�6�lc���ׇ��}Z�E���)fa�F9�:���W4�1�ު
us�Ah����b�k�J�b_�F`'
�\�R��:D~x��Z;�F�Zn�nm��
�g@�"�'$�!��<z����
�봿j������f�l�om����ƺ�x%w���_����~R���J�o�t4b�k^�w�<�g����/�q��-L��QJ�`�#2�w�4���]�ߢOb����%*m�Z4
_�0�@g/���u�m:���ܟD/C��S�@�W� G����k���rȒ`��P��������1��[��I��B��-&�,�,/l�'+੡�8w������G���gB"��$}���#�[�_uCɫ�g�4��cGo��`{1�
�����"q �<xr�E�E 
 bij�)� ��i�O��C��QF��	����.�8idOc���_B�� n�Ry̍��R�e꧃�Tt
zW5%M
c�;n)����vT�8������J[A�T�*�,-�f��
Za	�"G8�2��z�����=63�P||T�EPr$Fn� ���L
䛬*y,�k��I��DT�[|C[F����j%�^B��v�������/Q?_�ʅ2D~}
�zJ�<�{)��YC٦�P�,) V�	�� ��h%���DI��.OS����6.�5zt ߰���^�3'�
���ҧ���tڬ������U�H�EѼQp �`���H�.
�� �p�>3Jh�繥F�_��1�yQ#�T����cofWy%�w���
~�]�i��|�W����5	7vko��j�@�^�7�s�3b�� ��H�k
���#�
N0�cS�7���#w�f���]#\_�2S���X�"9�F
d�Pi3 �{�nT�+�w���xS�=΍�8r��A0_#t�'���ÿVs\�/&�e!��d]�Z	�_J��ZM���)d/3v��E�fϦ���~�7��8�%EW R�h�PCĂ�*�9���ͳ~
�
V�JPT����9�"Щ���ꙑ���Ya��Y��m�Y�� s�Mc�EG�ۥ�F�7��'*�>Sb�_�h5\��WU�� 8�5��"���&K��&/���T̻SY�t��vq�K� 2uS�?�v�j��/Jf��E
2�%��:
2G��6ѵ�O�B�PV}�;q1E䲶
�-8.d֠�0�
����k�+���x!��L.��ע�u�U%8�xX�B_�c�Z��A�5`�{�����
%�)��
��b
��~)Q.lS��ƆL��
+�����1BV�F7F�
n�՘��~�u�9�\�Q� �يF��	e�t���
����e�uc�W�]�@��M�N�����Y�k���#�.L��N�Y��;�ĵ�Q�<S(�]:W��)�_���XK��W	jL��G�^rH�(d��81�q��v��A(k�<��؝
k��g��K�P6�l_:U�w�и�;��#��u��v9���j�j����rW�IɊ_և,(>H��"
ڽΆ5���[O
�y)0 �f����X	���w�'j�bF��z] )vыؓ�p6=@���{�vW���+��G
�-e���5��a$������h8XQ'
+
��N�-���
G]�lg
>c��@W
�i�kS��'���)
i�l��
��B��j��|���Sdڍ�]z�2�;�4VŠ�Pl�߶F�#��]Mnkae�d��
/�j�jp�ݽ��
�l��k[n�1B
��\?��k��siң1
+n۰�B
_^;
U��#�x�&
���eAi.����D������Y��2#�t�z�A��87u8�;�n at t�bdӡ
4z|tϽ�^�����s5|p�Z����z��ϯe�l�t���4ټwz��;/��+BahIv}I[�-�Ϩ
���`|E��.v�3k۽�PK�;�6�Rj�y�u嵩g�
�P�ظh�_G�o��ŭnxK\�{y�*5�
��kW��I�{d򛅐�+Z��bO��CќO� �
t�;�Zš�
�.W[N,Uǭ�3a
��A�,���k�u�U�ɜ���4�}x`\7�
Q�J�{��-8UI�$��
r��ž|�Da��I���
�I�K�V�{sy�=�|��V�ČDf]�#�j
`-�9ע�.{�J[h�0��Y;bm'%���5i�h��P��
�5[���|
�Wx|GB��6���
B�gʑK�VC��E���a�,��
+EN넣��nd��2��� �vE��Ե0 ��p�cg7�F[��g��O9�~io�1�J�v���_��4Qޟ����SW�oe�s��>{&XZ��
�������<�f(�x�7�����!,�E+[!cch5
̈́6Hj5#倴��5P�i��(7�[�v�l;\��g���
�@�C;��������j���pﭯn��1c�cC�@��Z���k1��t
eۂ��F�)��5�}�{��p���
DԚZ�c�Vҡ���nˮ����b��C^H��4���a�����0*5��kZ��8�rA�j=4^R�R
�gc8q�e���<��A��UkD�؄�B�4�_�=��u�mO�{[�"�_P�'��^�f��*)k֊Hj[�&鼬����w�r3a>Aж
,�>�>�����^2���ö&J������R԰Y��g��V�
h+)���:`S�����/�����E�P�P�K
�tE�}	������	��a#pU�dtM
0�
�1�+о1�ƕ��r鴰�(c�\��S\"f�{��ʽl
dl��{H�
�oFu��<+{ٔ����.^�_k�u�ٌ%��ﴏ���
������B�c
+=d�!��榕U��4�:������+�p��"0a�����*R������JY����(/S�֍d�_��kA%�pӸ�ǻxw����/~�n���Hn�}�ʹp>���z�o]�,k�ciw����H�A=�*�͜�)��4"(�)tƨ5tj��5ټO��P���K?�ԛnj��O���J����KzM�w��l�5�g-¾���[|{?^N�<�4u�A�6�~��gC�2�|9X���G=��"(�K�q�&O����=|(����~e��V�
���K06Ȝ�
�k���ױ��8r� �����!��e~�Q�
�@���5�"�.=`�wu�
+Zt�q�z���1�ְ��־m7-�cq@[�5I�w
qD���x
��ܟ1a̝�^�Pp#��
���b�-��po���*o�
�˯�
U.0A/�-
�6���!�0[����f�
��G{6�=��~�G������g����&��ݺ�<�<O)����ܒK�m�}i�@z���VN�<�{����J��v�^s�#ǧ��u�r1T���j�[]�"�smDߝ�D�t��-���a���-�=l����[@��K�����$2�&/r
�m��
�~kf�%%鯸=�#���J�ʝ$a
p��$��!�`
+	
�FW��|����N��c
����V�X��K�o�d۰
+�����˞��c��Ԑa��D�Ǯ�@�q�}H^���H�E�ؖ�g��Ubde�fZ�S�s�|���V61D���P�C�Z���k�
+H���Eb ����Fl"(x���G�N*ޕՠ�	�� �w����$]D4�m�3(��9�
�3`N���.]���>y����
IQLX��hY���9@��O�����K�>ۯ��I������6�V���yU���.�=���OSX��ĺ�s�7ߖV#T��b���|�^�2�y��ۥ�vb�:�9|>�K��`��ϵ���5
��d�a����
�����)E*��ED�,dB���|��
J&��^�y_C��~��=���x���hY�[|�{�7a���[oʶw@��
g5pT7��{XkPei���
߮����o�kM]���0η��H&�:+ގ��KY
�*E�Sh����l�5gT����łn
Ҧ\]W��4�y�"XN��z{�}<�mv��i���dI�����d#�Z!�E��!*}|��W�J@��!��k�fb�a
��&�'�nq�n%)`
r��o���ݥ��-\��EY`:`�t�ڤn*tY�e9`w�%dr]��Rw�jF��S-:�"ǭn�א�ۖ�|��&���9�`M)E���D���q/{�V��X�s������`I�����^��k��?�m��N��Y�s�~x�f���1I�
&y;�׍rA��B��i�[�U,jQ�7�ƗS-�x
qw��
m�R�]ڔ��Ml]0y�w�! ����F�~?(�"��F��
��CͪVKe��j����=���^4b���O'�@
�P����!�ݢ��_�����m_�~�K�Rp�EM�K7����Z2���
�3zt](Α���r��.�}�ѷ�����=0L���	�T�K�FF
���^�
-�6��Ѣ�j�:�7����gc�ye&�ht	]�
�Ҕ-��Vg{�q��S{��D+5�X-r/A���D���t#K�6
���转F;�FϘ�ӣ�lu�=8�jմ'����r�G�d�/�+������ڨ�6WFNW��y���]��v�x��܍Q�iM���F at pݮ/\sKqMߤ[�
l��I���609
+j���u�a5q��ދ;FP_)����V��;;�֍k��Nt��U4��[|r
òs����qTc
����'�y�d!p�u�)����7��
CPG�A��c
+pg����}�	� 9cF/�싎�Xj��������I#�n�`\��6;�#4!����*}!,n�	fݎ��g�h\R�dfu-�=}a,�+��5� ����f�
Kg�Hٖ�"p[[���}Df�:Q!���O�\����[�
b�l����+�3+���Y{S�eQVf��ýdTf�-����%'p���앤�N�S+K1��u,��f ͬ�^�FNC
�*=̙��ؕ�3I��қ�姭9`
�p�A��R����m|
b��7
��V�bj��^�T���j�>� ��"7���<�����+CH�!nۯ{��o2>�N������~J4�֗�=�]�����3���v`~�fZu�ʷ�c
�8�QU �?Ih��j%)��
��_{8��^[�zmf`����!*�ǍB��g��PryM�F'�A�H�N3!"G������y��5F�N��>�|���J�(��[>�ct>O+Y�~��],������,��ȷ��{gx#B�<�?y��xLd�:j���������� =B�bD
`�@/$$����~gw������‘��H6e=��B Q�l�������F_!ī
�m95�x�����o��7�
+ڶe�ܤ8i��o���Oh�D�Tl�a��v"�^Fr����
�'���Ō��=��a#�'��=��5U��dVfWFÎH
�TT�)MP
�
����4����Pp������M
��
[<��
�%j��E�DH�N�4��,��,��[)X�Ps5�.�1�.Pѝw!���G������!a���J�n�!n'�y���
�"oS9=@��=6{Lr��os���H��T�Ãw�M�ʭt�I���
��
��Zf��0F7��h��G���*+��<@��6�ƽ�w(a�za7\	2��:��"Է��eso"8��0���2���mݨ��^�U���� ^$*ه"���k�3z���n��k�5 ��O���TGV�rvq�0����E��a{�;�����`���X��č�X�{x�F^?�#����dv^�
J�ކ"*�������%ؗ
~/RF�3c��E��ts�⾛ �X
 J}���#���q!��do�
(0��xw4�� m:F�m�E{]�a��LV�?��$�Q���ׇ�[n�>>�
���Q�%�a{�6
�q��'~*~B_e]��@�x�<7ށ�2�3��z#|z�o�G	{$}�.�Rlfl���sԍ$�1�xCo#�O�޴\&�ӕ/����<���
+���
�,�}��_��Y3
�A�+��i�q(\�`��(�
!�O�����
+��ff��jTwvg ����gg��V�	��a��\��#Yw�m�P���\
+^��Ǽ��G�|��j��
�GF�
�l=���X{~�_�B��'ң�;oo�kFg����M�V�ʻ���X�SS
�
C.!�7���C�G;A��zW��Ԅ>xy5�����>�3���PÕ�D��j;9�(g��a�*
+��Oސ��j���0���R`�^�!)���B ]D�~�
��^f
���z��<
�v.����ka-�;
+��c�X�/�;���y��#?
�I4Zik�0��φ��'<׫��uw=m&к�ڎ���2�.
���\-k�R0�=��le�M�ծU�_�F�l]bW��{�n�7�׏?�{�`/:����7�4��K�hn3��p��A<�!{|
�	<M��gFɘ����-��F��8!�#��u���&/L\��A톻xk��Z_�)S��XSp�vq{��/V=�&ںn>jQb��W����iF
������GW�S�ݖ��R)��Fcȵ9/Ѝ=�3�����Æڕ�N��}��σ��I_���g�����e\�Y���
ydR.��6�&� ٶ�k�������SZ���	y=�_�ɿ������W��O������i����������?�o������~K�_�����~���_�����w�K��?�~�s0d���ɿ�G���K�����?�ϯ���^���K��������_���G�o_���i�:�vM��0�+�p�.�������bC�m�'�>�oy����?��dbU����F}���=+
+W���P�٭
�vS����ZRf��0�a���Ye5�	���j�Ɵ�����D"�l����l�a3�6��kj�f|�)���3������_���~�?�������������a�S��^�H��_��������o��/���߿��ǿ�Ͽ�\�g�������?�^�����HC|Ȟ�˱p�1��8���D���,%�����Q�p�z���"#�n7J&�Gu�]�G�iĆpz�?�4�˛���mM��e_��o$��h%U�؎r3Zoj7���l�u�^�a_�$�-���ϰL
���Z�^��nD����
����"_�w
PG/�����]�������ů�Q��i�<O�]|5�����?D�����nFͥ5�Ն���V��X�O�3�7�4DŽtH���|�v������v|� �����0osX-����eT�7h`M3�����"����]�bpmo��D���sb4j�H���jL���9��ΟP_�]囩ڗ��ۨl?�2�Ӈ;�����ԍ�Q����&�nZL~c��Ɯ
+�_v�C���lu/G�3
�
�J4!	�c�~�8��z�j7�7�rF�Pj�� �z�v�`�3SZ]��k%���ns.�T�.����'%ǵ���9�xe��Q�����"&Y�B��d~فI
ܭ_w�ϓ�������k�gN�~�m_�p���ա�X�Ս�U�$�k��Vg7��������f�u9pU�O��H���3nwd�p遣�]|s'd��� f������� ���%�D�ۀ1k�|�os���V�K�[L���n�-�[�w3h����?������C��q���Y��n�}��Pv�S�p׸/� �˜�L#�S{�o�Px��|�r��?�.�b��_�-��|{-�ƧL#�.7�qk�t{����/Rb{ݞkӊ���
*��iߦn�3�r
#�d�����3F��/��L��2g��w�<[�%qcCȍ͗��|B�`�N�ž������ϥ�FK������w�a�5.�C_vZ��S.<q���v��[��
+/��
C�#�XȒ��nڟ����tq�Gv�����S܁���KG��>i��O���A���=���Xk�^�4c����^ۛ�C#�~i޾��

ϕ��m���cV��|ퟌOwPc’	}��f�a=�d-��=��r���x�+:�m�΅s�m�=�Z�p��O�"�>�	����X��kAj�K#�<5l�Z
�����]>e��΂K����g��f�ܫ�k˼ش`�hYX3�* 
�2����62�U�@,R�x�C�F�,�ɽ����A�`�{��k�Ϛ�����	��ٺo7�K�U�qHi��v�����X��ݫ���۽��ew0��6��Q�w�x���
�/
�{�q°���t�:�|�7ƹ�1$��8��c�t���G
�!�:gr������
s�~�i��;8�����gA�
�[���,u�؍�K�x��Mi�̩w�y�;�W��pxk����~�r~Xf��k�z��:�_��.���)��Ĝ�����m/;
+e~ځ��?9��h쐨���AcF�
��t�t�a�y�
�r,�ȑ��]ޘ�G���8u�%�跣b��{h���g��<o8�`+����:���Q�����+{�3�	���޿X6�^aW��
O@������h���q4g!
�1�0��H�e�����OF���_���/�G0} ��GM�O!:��A��+
l{�-��?�\L���
+�!��
YKx_x#�
�g��L�?De{��{�����õ��꺃�|�Ե��I�8 ��"^
�j0���~|���E{�[9\�ߧ!W}S��F�U�]�����H�f��w�!*����v�^��rE�l���.On�[g �Z��c|�#�μ_�i�30��YM���fQ��	�=��ͮ א.�9!'�a���r�y3%F�L!/�Ao�^�nL̗�[���_���5P �/��̺:�O	o��Dܚ�}���26��@�.S)|HLJMGl�ݴ�ܨt���'#0
�mi��]�]c�ٌ�
^��%%|kJJ�[K:�� ��l��F�5���c��7&2�?�h�G��fWA �-6�fž1y�k�Sw�C!墄�`lY����?
�t�>>�y
����ͫvP�M��3^�e�[0�%��*è�
	����_�k�1
"�Hr��m�}�������
+{�Z�SӐW�:�g.��v�fT<`\�IU�(
��rѡ�Gkj�V���b�R8{m�JU��z��)��xH-�yS╶��D��G��4V���,�%�G�ĖZ���f}%�J��������Zɾ�1��~��e
+Ş24�G�ݷC+�VI�f+wg����
�;$#�2}��q
�P����b��r��8������ ��k b������9K�B���]�'�eyR��
���>�+D�k����y����v�*j�~������8�p�N��#��@����2#�X5F+Ѹ�D��X:A�f���ف�ˁ#�m�Kҽc|�1P���S_��5���{sԇ��v����`/�
�c�VͿ3\`���&�
�漏�
��.}����v���o�0gV�2����eӭ��{��c�^Fyd3����P�vcJ����w{^�C��[�C.���2cMk���6��f4_Ƹ��Ɨ�m��6��C��M��e����4�t*Y� -+l���k�m���]�C3/Qth���*��CN	є��v�5�%3�뇹1绺q���^p���$�h���ԇ�T*��ݴ�j��^ۙGt>�����!h�����P�7R4�5Ћ�?gv�
�OQuc�[@w(�A�h�G��vo�#T7j�[��au �̛��@��x��� ��H��~
+�6��)�{9�d��`Z
��y ڃ�ףs�e�B�~�٭���
%[��}M3ڌm�y��ә/�+���쯭(��͖˶�	u�^l�
���
�V�a���lFK2ᛔ�����\r�4��ʉ=����V��!���
<�Wj��1E�K׿�$Ȁ�MW��ir��\7�7�X���
����f�~T�Z�dƻ�7�&��pd�`7h��SK�{�F0�x����
���Y�`�w�K?g���꥝�\��B�m�`��ٍo�y�)gι���EJ5�ݦo�s޼�:����}Cۓ꿅<t)�]^�,������%
�23�����)����^L�I�S��d`4��K��?����#W3_d��f7���y�.m�}�7?)!�:3?��ס}~�
 �- �_�]Z�Y?#�2!���4�cڔ���9�=��nm����ȱǖJ�۾�(�رxU.�
�v'�VY��Vv(k/�@o�ν�s#�'{�Z�ٝW���%� ���y�\�0t��/�:h�:�K�6�����=���f���Yddm{��6��H{�\�PȆG�8ơs8�d~8���rPd��\���=��g��-�G9��JF�t55��ע�
kr�"+�H�{����}�$k/�%�X�

�����^�����h|3�}5"�^g�g���-��1&��f�3љ
��K��1�I�X
+f�Ym�.;���^�ռ`��)� ������kϡ+v��>0�#��[��|��\ug&�K���õ�g�_y�͏�󰑭������y��$�����Ư���<=��P����W�:!���÷�!���{������q�f����
��=��M��>l��m���?�OG���y:�ޏ����xJ
�����tR����-
]�'��c9�7�Гׄ�r3�WT���ύm&�bc��ـ�:�g��L5�Xc�����
3ֈ�a/��QMSѣ�9�b��?ٚ���q�:

��á�tB=
g����<
�����~8����pt-�N��cy�]_��o��}~�2^�qa<���;.�|\��S
�
�<�6Oq�!h:�Wϱ�)n;x�`�8
Çx��
��ǐ�>�sT~
���Sf�!�pH8<e'���S��9?rL�
�.�
M#���9�7�)<
+endstream
endobj
25 0 obj
<</Length 65536>>stream
+TP��R/� b ƹ�*�p����j�ϕ�Z�>7�]�
��q�<�����J��ngD��\�5�]R��
^��,3j�GKH�^�{Вwq13�q��R�>���ue�۸��jo������>�.I��

ڑh`�e�+Gh�N5���^�������i
r�3����v#��ų[Y�w�*��
��zr�K�^���/Hk�2�0��X{!�	�|	��zʷ�ތXi�^<U�Y�yݭ���$~o��46�7�c�`
��;
+�F�䀽�O\��#¸��ŷ�.�n��S��߶�g`����Ѐ�5�ݓ�r�,�9�-���ۻ�5;��5�Lj]샺�nl)��M��f�kJ�E�22-� �
ΡZl��#�r��]�ߣ�����
�n��������V� ����>c��}]?7�Di�e]���vЂ������'�&N�΋�
�v��
T��c�#���� �?��4��~�S���<�y��X��R���;iF� ��O
+���W�� Xt����$։�Z�u��.��Q��e�9�:����<�{��ME��btt+uN�؋��f#���-gI���yt<	�w����Hkڪ���/��N
�����$���	 ���U$YE�
L�$c�B��Q1DB6�`��d�
|�-H�3���{�>�S }����#����=��l�x��R�X�'��`ܐh�y,c�Lh�l��+����v�3��lO1�5.�U�ւA�D1'�
x��4��n@��h�%Y �L}x^{���� C]�T�g#�[A3�	~H����1B�6	��/��*
	
����H�f����i��u^lJ 
�*i����a�<1qh}=� ���&rOM 4�
{� �e�1�2\e�w ��)=^Y�bK�(i6j��N�׶�-ރ	��e��ua	�W��0�m���?��\Wӏu�����
�
�:=�4��
���A^nΛ
B�kd�mpc
�*���V"�P򿴗{�,3:Jnj�ma}���8�
+�8M;.����h,=X�y�h����b�
l� J��_�%G��C)�ѳ�&�cn�/΍=F(��i��f�\L�P�0O�G ��F�����C�H�q�L0�XY����C�y��o�M�f���\}a
�~�9'hy��y
{���f:��������i�6Tr|�ũ��d�I��y�]�O�<���hK�2�οoޙ��ſ�ѹ�_�N�L�ÚX'G�
�
�|��[[��B� ��}���⸇�0�ڃt�]���d�Ӛ~k����G�#�Qa
}����*~4w�Gx�I���
�n$EHq(�k�*N�N�V�Ll̖)
+|z%/��C|�C�v
���/okv��`LJ��]p�B�)^�r�Zzv�J��h
nlD\�!pxzϊfڹ�=������Ѷس5vþ��=ņ���I���ѫ>���
};:����Y���%_�S��.���o!U��JM�!���:&[a�8#h�,���_^�?d�|�M���n�8��W��E�AL���X�c�j�`��_�'�A��Aށ����ž�N�kd�sX�㌍��
Xz����s ���e�Û���Ae33����M����oQ�f�z@�b�E�f���ΦB��36F��#�N�����.Vn����F����$���|�@<�u�����މ�;y?è�-��`<;w��� `
��1�k|&������2
ٹ�0Z�
����f
�x��ص��;\:���p�m�iXˏ�ɜ���3�L�.��Ӄ���� �ț�վa�ϋ`?����L�.�����
���.�Z�)P�yw�ǵ�A/
7�,�DϽL�v4��t��c�Bl��R\�+
`��w�8����$����G)\k���E$�U��e�dR��7j~ ��$s��Ӌ7��v�m���+5mz��E���.]'36&�'�
]�
*AtS�W2������.Q
�d���Ro0�ѭ����ܾ�.�Z��2�b+�,� �f�|Ax�N��J�����y�?��.T#���c���_���5ˈ�5�
��|,������PȔ^i%#�Z<W�l7�5J�9\�V�C5��9�|a4�'q��I�\r
�
���˦�L�v�����:��3O4�"uo%��9iKT<wwʝ��F�n�|9�3��{Yo9��"�F��;�Q�ɛ���;%�
ʯ4�=��,X�	.}1��%|f��2��q\i�Y���Q]E֍���݃
��������Q�
~M�KX�{�B�b��-�;��M��
`����(F`vO
�/v>��*(�q.��>M!~��W]_tV�|��_N��:���
#p�j(�T�")�#M�qm<hgI�9�W�QвF09Y���j3X8�58��H 8
+Vn�������������[
�a
��Zņє����ފ���/!��ߵ�A�[��l1qUC���X�^�w���l����V���B�i+'�8fK�Vonܢ�-ȋ1��s�Ǹǃ�uևr��
K�� ~�B� �3̀����ށ��7� J�W
���ֲr��1Dp<��(�I|��Qn[�q��
,G���\"�o
[��h�(��_%|��J�!���Ė�М1��`9��ˑ,�]͗?�%2J�ʫ&����W���vqR
+D���q�A��D��J�����_����x

���J,�v��f����n�C{�yզ~2�eC mՒ2���`����Sh�
vy���CO�ҕ&�6��w��t.ȦV��-��w$��v�9�
.�c�`|�=J�K��9Ҟ��
��PBS��^

.-�U"2���fh��/�1�L�}��km��J�TB���L�5��XB 
+lj� �'�b��f����u��ڹ%�P)
b[V�7��͵o$-��*c�
��
�%�
�|6K����o���87�k��
+1
�����{y����a
f�
�)�f�##~�rof/R���
F
��HWmd�fL���|�B�
(��^�vc�z��� S���t�R���N1cp��~Gb�37WwR�
F
+w��%sW}�fV�
+��\=$lb�pK
��]XvGX�*7
��x3Uř7?-�\���<�̋	� ���˦���F��p0 4Ȫ�%�u!�"!�t0]^�b�nF9e�*�]�O8
f����Z
���R9B���Zl=��+|�$���,W#1� Q>�`䏛�P�[����q
%*I8h7?���bst_
+mMC��0�abQ4U`��8]�/�!C�l'*LB�^(�?G�E󵊦)�L��5Ts�0�M&j��.Fȗ����ګ��`*���S%/�r�K�V����i�Q+�
+�D�q�(^�f��������k�L��JE*}��9bnN!�M܄@��3HsHj�V�ݳ�0*����~�i��
G@�CoH��i�cy_���֕�q-]�7�����!�F��d���O��7 '׽>��O�#U�o�#��G�o��,?i�s�-
�w���ݠX�,��%����la̗�DH;E�#������*���pn ?�M��m`g�ё
‰.�CpY�#x���Xk夘�C�ʇ��e-�0�-����M#�G�
\
�Mqhr
����
0�v�9h
=�������D'��"�p���ͦ��n��Z�I�h�+���Fbw#��@���\���|D ��偝�
�oq��}=� 0���?l�W��̍`Z��J���R�Ûa챱X���9�lD�֛���J$
���G��F�E�tߜ�k���~
Dh����t������F�Y��
�W��"����l�Y��A��U���T��iw�	>����kۻ��c��3� T��s
+C��"gp
,"F�<ʃn�:��4�D���4̌;��Y�6$�ۣ����8�~HerXi��?�bl���9��$�
{P�����XY��-���z����`��Bu�
����{c;�z�S�� 
t��
���@2� 
+L�ۖ��!ԔK�RR4���
:��
!
��9�+Cr�f
��?#��B��� l:��`%G^�F��J�7��j���

���7��C�`�7�����a����v?){�`$%F�� �_9�-�s#�y�3(�����L��/u�)�
#S�0ndnYcW�(C�8�|O�n����1��z��P��y(���cL����yo����#O�@�y&���H�nV�m����|���+~��&�c���-
��t�/(88{BFW��Q���
+
+Of�EZ����B��~�d��*�ތᱡ�1
+�x1;Us�껎I��F�\���S`���'^˺\��{�8�~�ku�e�|�
\�6��; �9w��:\z��6	�}
�4%�s��Yu�`���Gp� ��œ�H7���<#G`_m�;��K�\! �R�&`� p@%�Y
+9�FYx�c���	�
B�r��!��yOä30%�~(S)���a5x��!�9����&�&\����g����ۢ�����A
W`�Ǿ�/�~����Az2��
h��#.���O�S�R2轗���Iq�!� |��YW2�mY��kҸ�f�\
�0g�p`�ܭ?�ׇ�蛦�����G����j� <��Ť�;B��N�B��������L���b}�([���By�⭅ݨL��&�:�@/NFCj�b
�
l��~{�cp�Ĺ��9�I���_`�r�$`�� �0�ě�BKb
��j��T95h�8��I���tD<���.������?��d�3�����h����_�z�[�>�'2������͉��u�m���{I��I
�ȯ��Y��޵��bNS'䋿r4�=t�=�v�d�'�'�|�f�V�y5���c���M>^�U��E��
B)�75�5�>�O�����Kq�:ex����A���ݠDȨ9l�z+�u��nݍ��F��:ڬ��YȠ [...]
+d��H��'�41	��T�1���tW'�e�2
�����Io�#�5ޚD��,�[
ؓܬ/���.(���qVJ޾R&����~s
�����~��Y ��[qӖ�F:���9�$ܪD��Za�>�Oձf���6��LCW��OQ��X	�o�����zO_�B܌�^�NM3i��D�BH����cf��5h��uc�SWټE��Z�ҽh�z������l:Ce�@�$Ӕ�'����=y̙�g_Xӥ�j���j�WgޚQ��T㳻|����L/'����	eO͡�-�'t��`GEQՉ nsbđ!
m~�^��38���eE�$7���q�c=��XOK��<z��/����+	΢B�aQU�=��Cծ����
+!���
[~d�����WU�Va��N	���bd�{������:�#U,��|�G�&�X�Ch-#<_��PTQ�K�^��H
��t�� �!�sH�{�CXZ�����O���j�^93�Y��X��_2ph
J�E;�jl69_j?
�Y���Fk�Ug���
���WMݛG2���X	����k�/w��ͅ��R3�!j=

�F�.ݸ1T<h�&���И�'I<^L~�K%���J�d�AS��\��"��P��ڽ��r�
+�l���8B�uމ&�ճP�����D�ىd*<�Q�����
*�l3���� ����‚�OM���f�
�$gj��� g�%�oK�<za:�j�DŽ�I�*	��p,��z�)Z�	�
+ő���i���=�v�I��N��#s/��y'� ]��m�>Z���AF�w�@J<� b2�T�&�_6�5����Pv�p��gA��W,u7�<��،��΅Y�S� 1��É�<cq��WXo�O��ZٚWE��"�����
&�!�nL/�i�9�������3F�E��9p�B�`�����&_�� ���Oqv)rƗ������@�gNW��`��-0�0
ƕ�~ٳ�
vY�@C��j�<�w�6
��ՓYcS�<�	\�%��
+|
��9;��}qX*�m��jfb�kC�>�_cu�䵔 ��@��S���Mg����7�"5�جHvze	�s�܁{��

��V��
_!�:qIW�,q�u|�E�j�>ë�`W^
�Ҍ�	���Z� �Қ"�u��'>�%�&�
�Jpq��$��C}�i��`�"#W�����*�,Ѵ�rN���x�;dׂ
2F�ԫM���ڢr+9̘Iwo�� V:�$��R���F�燀%�읃h�! 4��ɹ��``��m��oa�O�]j{��"=4pz�f�<�?'w��
A*a��F��31P�y�����su4��3����Gq�Q�آ�!���ԧI�(
��D�F!��L?'��4�P
��k��
�+��'O#�}�A�����{�d���Rxv�+�[��]�P=g�.m�˼D|F�	�IW�*h������^%���`�ZD)$�
+7�����}���z��@����+������p��p6#Ƀ�$,|�9���
�J@�#܅<W�Zz���6�%r?����?C
+ud=��k0:~·�A�+v�G����q���<�3V�͹��͑����`x�">��$�#
�̝<-���'���y��>qH���#5���z$���O\�#��H�}��
ȿG��3��H@>P��x�$�]��[}$b�(�O��3�H�	�G����H�?�矸�Gb�����?�
e
5�Rg݃�H�AL�Yw�(�p�s8k?
�"����g�����Y�(�� ���q�x��x�9
�
%F��H�%G��'M���ʃ�ʓ.�A��(��
s�9�<i�
�lN�7O�8')���Γ>�Q��(��t:J=�=�
ď�:IGQ���ҳV�A��  ��u�z��zҫ:�[
D����ZG�'ͮ���Q
+�I7�(2v�#{�.;
+�
%�
�ӎbkgY�	����Q�IE�(9wҦ{ұ;�ޝ��~��w��;
+�=��
���"�ϊ�G���Pᓪ��A,�IY��x�k|�v<
+A
%#�%�b�g��'��Ạt�Yg�A���yV�<ʂ��C��F�¤G	�'�ӳ6ꛆ���Q��(����� {�=�Ξj�R�O��G�ܣ����I��(����{
>+?i����O:�) =Wt�kIP~�,�[/���nIM%P�w��d`r7��	���g���[��v�8)�	,G��/�@�9Pm
h9�3���
:R��d�33�Hc:���QT�w��?�D�:Ӿ
8bgBّz��S;�ڎ�'�ܑXwb�=��
�}G�1x�
��O����ą�o�d�L�<p7��GJ�?�r�X��N!M��]�H�=2f���
{d�>S��������|�.�H�O����g�D�>2��\�#-�� ?s͟��g���~��y�G��=���?���j�G��=����Y&ᨩpR_x�jx�u8(@<�E
�%NOrGm��
+Ɠdƃ��A��I��I��� 
r�9*�
�K�J'GM�'����Q��Q���rԆy�9��
�i��l��7G��'A����Q��Y�� t�
+z:h�k�L�褂��q���Q��I��uԍz�B�EoHIV��j��yaz|BԠ�ʱ j&tUCA3��јӺ
!#��Yi�^��uӳ�փ2�Q��,�uT;ˈ�%�
�ɎJfgٳ�����Ix��vTs{�~{҉;*�
��
�ꎪvG	��^�QY�A��A����$xT
<�
>�
�
��O��G�ģ��(ヂ�Q��,
y�<�M>HS�������/��;��]/����}���8{���}�����Q
+� ��0�$Gz.=��
%Q��OJ�GY֣����A�("�(8{�=�؞oOڸG	ݣ��Q��I��Q��M
�(#��9|�'>?�
��OJ�g��D�Q��I��(}�~�>
U%�O��G�쳬����➒Z�G����wS0�rp��K����#Hn0^l��xѫ�
��G䎑��L��
r�F��4������2F��t<��+y9LoG�1�i�!=��#F
+����4c5j�/5�%�Ԭ�)p���37���}N�U��>��l�U}G0PӠт��T+U�gM���.�!�R/y
?3�����-]��-0�Ч4`$\E���65�qHB�aI�x}bX)B��k�t�{�ĔYx�w��u�5��y�v\�=�EF�#eF%3r�I{ƫ�؈�d��`
֞6G�W�*-3(|�Vs_|*<�:Z�v��k�[M���ڇ�����k�g^�oR���laC
P,�X/o�ˊg��bj��8�:�.�!.v�/�.#`�]}c,�e[����8f�[�E��IE�#S��b�,!AI� ��q-�æ�S6��\��W�
B���*��{n
G��ȁ`n�
��y&�e�n��Qk6��^����j�����L!Z�
=r?Q;������:�b�3:b �\�R�����
��y��dG���=NG
�}/;u��g������`���z��*խ�;ˆ6���&���"|}X���?e���
+���m��P,�|b�K�[p�c
i4�h����'n���R�L�u?� ���/��$�x5�:h�� Ч�s���ܨU�@y�����~_FB=p�n[�HU
o
ܖ4,������
n
��|ozi�n�Q}0�������"��Kg��u��V]ōi&~$��
��l�6a�T�Ý�C�Ê���G�9U~�-&��%�2ޥS,-/�6�����
+�⸴X^Z
w��0�ȕ�~��(�Q�������,#__�am �[�	�����X}�t���V� �q%�����XM�+7�]����5�[�
 ��U�E���=	��b��0H�=U��/�Dv
�������f��3tם�9�|n$J3��0J�W^�����/|�u�c
;e���h0]�@�&h�)7�[ӛ����u�$
���7����T��^� T�0�<�_3��
9�+�:��*Qݺ�N��F��e�}U�]U��I�>��jL�����y\d��7_\x%��xY�Ƭ����R�t�"��^���V\�E�����B�q�Zbu m���
+�,(�
�&Jܵ
�OXIH{�X~S�^�]X�t=Q.�-�Ĉ�1E�0��B�19����Gk�s��Kɱ(/���|�
md��3�x��=���P�����G�ln���7�sxj{�}H�HU.��O�n;��
��p)b� R��?�Z�Q4�w���������
06
r�J
+H�
ߧ�v��=v���U�,���ʲu���=���_��#�P"�"�����W����;Q��Vݍ�
e����~�BW��7
���ރqE��jc��=���n�/�s0�
 �ؖ�X.��!%(3����a�����$a���ZU�?
��>����B��LR�A�>d��ץ
��B�Rغq:�ô�-�N�3�XK�]����Fb�#�\A#Z�j�7�թE��)=�N#591Z��*�8��\~��1�
#3
��M%+ËQ�ō��
]�r0悲k#d��b�jS]*�ٍQF�r��x�Z�!Ʉ�i���y:JFf9%�
3�A����L(`JҰpzQ�k|�F
�w��\�
��,
�b]�F

+����EU�Yh��|�b�9�{�w
t�؛W���֤��
C
!�ͦ��ê�����N0P�QX�L�%�9��MXGI�!B�a2B1�u �`��f�~�������
�,N��_̨n�Y
�1�dUp���&)X_�
��
 UJi�J�
5�0
�
+Lv+���a���\7ӓ1>�uI���s^#Hc"��cƪ&�Ì�/Xx�J��"Y�vc�D$��.�v�o��1oK�o����Xo�����ׯUʰ�D �Է��^W;6����|
�EZx۪��cM��� b7Z�K
|J4J��nE�nE ]�
%#K�s�]!�K�ɾ�oܸ*ƉEЖ���a&�J�܄:_o4���l��	���!X�Y��W.pn���
k�Q�ۇ2B�%;�ߏ*dK�<�oѢ�X<���9$�T���/Oz��<�z
+��
��=	�c��IOA�{sX)�t=K���.(R�Y�"G�[�Zv�R�Zd9����d9»��I��,d{�=��>��
$w�Ҽ2���Gq೒�Qv�(P��f� }|I~RT>�/��D�O�G��G]��I���k}�>�e?ik?q%�������qvc
�L�Q�[����&A�+a�~���
VSIF'ٚ �.��hL�k=,���Ī�
�����@��S��T�V��^9R�f/���U�*��Ԇ�N��xŪ�Ҹ��A�z��ѽ5���%��iI^�
���3������� �e��
��4��n�a�R����*���"Gj���~m�xؕ��
�w� ��q�O�������/Y6�;P��2�T#���q�Nń�K#�`�����
���ϓ
9Sm�C
F�FK��ɼ>�a�ao�1u�obmc��]<�5Ki������d�6���0��–�W�l�t�
SŻ�ZE5 ������?&�ٺc^�)	x�
s�y�c��!�ȳ��{*�rb/#=ᾈ��
դJ��*@�@�;U��G
�<�K�|�oط��ZW�{��Uǘ[�
�
�웳��q���Sˬ7/�u"��$�w-�U�Ȭ�]92~5� 
�����1����%�Ӽ�PҶz���̼O�
?1�|�>
������M���bAq“�m��apܹ���t���N(F�
+nS%�D4����?�.�I��gtx���5����ه�O����o"��Ӯ�r
�۔R|m��F�N�F���lƐ��N�6����2�f�ω��B`�/�<�XF��&���t�7R��@t�[��6w�B����;���?��Ŭ.q��p��W2	\x�^���Y:�����;���
W�D�q��,��H� ~�O�If�m1źyى�@��$5
b�{�6�z�Q�~�*��d늉�/��<F��67�β��A��
gW�2�}J$�mE�4c�zۿъ�]G�l ��U���M��
`̱�������d���Y��������J��
d&�}T�
��Ӿl���@V7[
��z0�����
�(�C"-�e�=�\
}U�=v�CP '+ٙ���L�P���J
m}1��
�&�;=��aG� ���9�m!��@s��4���rH �Ί �f��j�w �yy
s����E;�\�POYS3gtܾ{�F]�
+�{��Ra����
�1p/.���
�p0t��C�ބ����E8��
��j��:�¡Z>hN��
�����
f^��6��s�)(�؄ ���&�/-:��6	}��B<Ʃ�Bz����,�%~��'���W�#�h���)c����76�!y"�#L�Y��7`�XXL��K�Xĉ��� �Á!�A1н�
T�2�=��2p~Fy��#
n���Q��C��T���Ԇ�����:^�����-��P�B�`�2d���[?�5i,
��췂kX��H�~e�Ux�F��%�D-Z��
za^(k#y�D��'�=��Z�
Қx�8����a�ܛȁ6Pb���P�oK[7�~P[5�Ǔ��

�'o��
�����
�
�'���E;:sO�ߛ�xt&O��v4J!��������T�>,��
��.��W-��RmX�LW�"Y#����gG# ��W��h�^c�Ǐ��������q'x�6�ƶ���V�*(
&�J^��vq���c�J4N� ������xz��>����u��W[�oo
Jg5qۂq�[_��@��Q�(z��xՇ��CP��}��j
��x�n�����>
9%+�s����,��ƨ'����XL��
+[�_�^�h���Y����&�_W����`���
+	
)!
{�p�E�#5y�L|yX
���
���H��h|g
OR��KGaiQ同���Hx`��o�i~��G��䂰�X�(8�y3p	�@����V
˜�w�Bx(�i�k3�2M��x�g
�
O����Mr����� $6K@ߏ���L�y�����k��h�_U�s�F�r��|[�~N�L�������3�`Ę
7��FN�Y�X�8�6�i���a��H��

���������> �k�!�u��MVv	�,r����U�����=��(
�8N���N���|>�����	����>��r�[�˕Q�"T�Y��&w
+$��!7�n��p�0����)�6�
��L"���R�x��8WG��\>��U�x��D��/��)^y
+n�a�{�t�r�ʙ��;�|��,U-�j
v!=}8�~v0
���y�	��zv��鎹y\�]�l[�O�z���6&�F@��'�'v���v�O����|�T
���HM���F��
�
hYa*@��)��)��x�`٧�B0���u�uy��/�x�xi2���4
���~����ڜ?�Dh���j��/�S�c�����F�ǖ�����{3�S���;
S�"6U=������$l�G������b�Nf�=�;O�/�b0�(�C��r0LTp"AF��{��!e�f%�gk�[{�9_�H�e��}���,���c���
���E�kz�{�D9�6gvVƫ�H����|���̉�]l�V�I����.J`4x�z�
9\rt�E: ��p��ޱ)T�����������H�&�~:�W2��aK q
n��
�Gs�
�^%:�}��.32�}c��+�ׇ6����S��G_�æ�3�y��{A�'y�<�a��oZ�H]�ǚm��
E:Y?���'���: �fx�
~
��e�p�V3b
��z��{�(�+���
�5�ᢁ��$���b�����D
+�������L?@؟��H�!�{ 1���0h�
cM�:��օB�z����O%i���G�۳,��n���)�i�I� �v��L!��W��Rg��Ĕ@�W�3��][�԰�ST
�q,se�&u�O�ӄ�
k��v�uҿ
�jKt�ɱU�H�� 2>-���Q�a��.�8����3��;����Rz P�E�0|����T����"w��wr5ߡ1���m��'�1=P
��x�LTZP�iU�TI�.prg+O3Z��
�d邑�ߍc�d�|�וpi���}��c�q�#) <<�����X��
�!�
�)LW7a)g���ሯ)����F}q��ޙ��+��Mk���"��=di>4I������0N	8��.I��	�_LM���	6�@���>��3`��%w,�M5&���G����(vK�E	(Ӱh��������
����^gWG���ށД�|��O���e�V��Cu(��P��R"<=P���BD�[s5�����~�Mu�B��|� џ
f�_q� [...]
��r���Уs
+�l��h�۝q�n��l��C��<�V�p���&���tݕ� ���^xCU�$�	9�K=@�vP���hF��V�N3�!7��hK?��Ͷw�t�9+8�W�u>Dp�~���ylA���In��xɉ
+���Z�L�K��ZÎX��d.���*��H��-�mdo�f�w~G�����I.*�X��B�h|�س(��zv���4�;�C�+O��WQ�@��0�'���#���ܽj�[#z�j��KQ��,��H�n���W�"�
5U��6�:��5x6�������4�f�9&#�j���cAJ!��w�D�/�13������99d�+�U� ��j/�W�%߅Xp��,!D��`
��A�'
��kt�E���?Gh����=��o���O	�cr�	a
�$�V�<0�S�cA�xq�r��D�����d�G؏�ZG%��j�Q���$
vT;ˑ��ˎ:g�hg�����*�O$���ގ�pO2r'͹�6ݣ�݃��Q
�IJw��{��;��
���ڃG��Iã��A)�IV�A����$�xԁ<*F��%�Z�G��'�˳
�Q7�,�yT�<jw>
}�UA���G�ѣ2�A��A������$�zTg}�q}�|M��#
���w���QC�:>C�PPFN'�F"��X�� �9mq�
+w��kڒ����E����zl���-5�G�%��=���k�
� ͛�4���?�52�>��2����1̥�Vy��`���<C��o�a�5������=ڎ�07��i!��;���)��9�)d�\����ZIuǦ�7�g���:�,�8&wM��A���Lu8�fH�ުw�5�u���Z$m
�tSDl)���?d�H�A����w	9p*Tv?��=�nJo��\�oB(���!s��M�"a��=<�����-�G͘U���2�;h��0T�\
,A�8�C���F�\����j���
H
���;���c�4����H�
+eT�����a��tqM
���Fk�k?$F�l�'B<�,�
+�\������a����r��)�
�`�7�-��3��yt��]aէ�}��96֢�;l��
{!�f5�Nn�ֈ��f����Z�=:m�
X����L�A��.MʖH��2�R9ܾGl�Cv���5,��r�vK��Xh�n�[m}��o]���A��x]�:���]
f��ا�+�x)]�)�}�%\
4���h��Cp(������E0E�����+j�(s(��8��E at PB�o��c�*&\�CW���q�هW�/��R���).Y�-��-�^F�L/��!��;���s�z�Ky/,
�5c�N��5�w9
r('@�ΰ V�{Z4 NJnX�n
&l���-Z��V���6$3F���i�
���n�~�pkA�Ӎ7M�lm�^�
f��$��
Dk��*��3B��$ !��$���k��[j���0ce��B4	F���M��� vN={~�#xu�;��N�����y�bMy�°<�[�$u���������Q��Yz&��E��DpN2��	) [...]
� 8l�d
�l.�:���a
�{�07/
��zr
������v�3ƀ3���Z�t?~�9�}�Ƞw��

ps���ǃ:K��v��k��7����s�ۆz���YK��Ќh ۛ��M�pޟ�3�G�2�Ћi,�8��UjK�����
M��K��d��N���]��0��i�!�]���C.��f;
&T�	�3R!��7ݴ���|.T���V�/��Yŋ,�ZC
�u�S@�N,��[a7�d��6C6,��)�
O�s[���Uw 飥bjŐ���F|�^U�I�	ע�
�k�@������
X��~B�3��s������"[
�0���`C�H[����U_jy�,t�$��4�[�H
2Ś�M��-�*��/0��,��h5�h<]�PT��^݉oB�Y�y?n��}Q�<��
n�؀v��ge�����;x3��r�������o]��,{�q��
L/�w#�w���M�[^�5�<y��7�v��"yۮ�$�%h�
�j����1��߂Gu
���v�%A�Op�7l�?��x���Y
&��J
^��M�W���9-�â|Z�)6�̖.�䎺��y�
����;c,�6�m�
�>m��=���7�-)�-���:S	�^.&&�K=D	
���$�P<.7!�H�4#��
`
%����F#y���F)���x
%�pEZ���C:�XiS�h�:���"ş�2;z]�3M�-DI�6��
@	=�KiP�T��Ly3�0O1-�']�89r�������} J��B�jn�Ch���V��0RwW�(�-{�6
+�V{
+
���Vl�S/(|���
�����C�u
p����_bҁ�����1�n?�s��S".�֌z�
����9€��'t��
��oz C
aSO�Jߺ����-����n1���t#��cf-ؒܠ�̊�pO�y�$ǽem�� �=�b��s��U�.�V�̒���\����+$�U����[�7y�M+�O���
�Q���d��

=H�Bž
����膻"-mYx9v){ͤk�AN�z�#�n��Ӧ�c�Z�x�P�67fF���T��C9
+�c��� �<q�N�)��Q��m���=N�[]λƒ�_,��^�S	p𘂷� �
'G�;�}�.�Ne��� j� =1�x�2�����-ZPø<��s�	�c�c�q�F�q�)�9+��(d_Aa/�>�
������ؼ������}α�α+�s
V�q�]һ����uI��}i�fB	Ú�t��~���E�AE�ۂ��ʀ���fɸ��Ljb
_L��4�~���Ќ��
�53}Y*�e��=�N�����
�x�1>�
�?��0���gG	��ċX�	fS�q$��epN�`h��� ?
�h&�){���W���yE6!����ʽ^yII
+�8M�K�3����m`>$��u�����;��c����R�Ì
�@�Tʟ�c(�م�D�7�s[O\��\n�Wt�����
Z��<�i<�[�R'�\Y
�#��Yy e���8/y K!��Ɩ�z���!�+EGf����
_��Q��j�[��
+:Q׾�|���	R���U��el�M
&��[2:��{��\In]�~W���t�=W�@	Xq?H���������D�b�9.{XU�ڿ�b�px�UIZ%
�'dw�Ae"H`c?�^��?ş�*��Խ�0�!iYx���ʫ�K4�
�����]Pz1� (+�Ӳ�9�J+N
��Fu�>���q�g�P�۩�8$�LFL앖$fa�
��Q{���(>j���հ���h���c`~6
�����\�-Q�C���Lz�I�t�̩�-t�������Ӻ��s�N��)�wV�T��������� |�
p�O�.Q�ˬ�,FQ��ij�F?��E�B�O�,�mȯ<dbޣm�R�Ba�6Z�1��~Q�n�R�D�?�b@{0R� ��t���v��R��U�[Hp{��z��(�a�����ҁ�A���Ά�b�l�����	�P��D��
uJ->�4����t-m`1���T>l�^�,J<�T��0=K,~8��y4_��Y�v�PRb
5�s�
[v��`,2�b�m��3�F͛�T�(O�U͚Sk2��A݄+�A��yTU\�2ކı���Q�e���b����Xì"G3���Z�l
+��ǔ��=�Ƀ�Hξ�$��y� 3f�ڬ�$gQ�
@,aynεEr0�o>�����aP���V�5�S��"`�[m�|[��ώQ>DY6oX�eB�2�K
g��NYc2��4u�`����q���9��sK���Y
0<�p�j��S�O�$�4¥�Zy��3"���Z�t��Up�j͙*%���s&1_ۦL�]\)t]4
F����5'j)�:{�5)ﰕWSo���� �Xi}ѨD���̻M���z�����ٙ����&���]�,
J�
+g2��A�4fC$u 
p5O�i��x:�K��E9E4��@��ls�^,elf��)�'G+_
%��U�m��\
W?�P��"kP��X�a6$�/��_rT�^�|�ؗA�ФVUf��0��g-FJ�bV�
+�Т�¾}�.H�<Tenp'�c�j}�`�p6j�պ��"����腺,Yu��O㉖G�-�A at T�j�'��R���h[�.(�N/Dr�,(oEБv&d�Z�6�lq!�Z�OV��\&M�����$���s���(�
ߓ͑b��jӉ�IU[����
�ҭ��s1b9Y,�[{��M�Kw�Jw4Z�V����+%��@�� T���*�bz�89�&�=\bQ�\��=^u�`��}�־F�>�2Ư�ˏ�臜�k�C6�!o��d�ȿ��?&�UX+50�K0�`�^�`�4°��z��Au�a
����
+�R{e'�UsR�@|
�NMY�GI�B�SP#M�"I?�V�����l��U[VYh&+��� �3�������O����MX at E��j��
hhDƽ��-m����7#l� �F*�Ke�\�J)�+�A0��Т�X��,7�s{Oe�v-�feѨj�� �{-1���ԩ]�_'c�L^�ORZ3�;���C��!�{w�U�{�Y�`����
4Y��溔�
냳�Xq1E�ie_�M�j��}�м��W��6�K��9�x��^������FP�˧����!�z
�����yA�����|�-�
�f�J\����h�p�~b+>ܵ��=�9n�
+�N�P��� *B)�
O~:B��j� �?�"
`�20H.X�DXI[�7�3!I�䊵L����a��Z6�}x%�Ռ%(0q47��є�����{B8�,
+�uf 
+Q�4�(X�
��E��q�
#;�M�`���1\5�iD��>);��K�к�f^'2}q[�ʚ�����F�"D��\*�`?�j�����5L����唭$�
S��ym�$��l�qb�0	o����ۧ��E��hT67؅N3%q�2ѧ.k�G囈�Pj�ױB4q:����f�̳Q��2����l�
	����s�-M�[=O!��� �Yᙲ�5�U�9���%*�l
�<���$z+YQ@���n����(;y3�{ju�5�X�p୶ǖt,C�_�fy���C
!*It1w
�N�SVp �蔜X���|k˙�j at s
����,�v{2�y�I��;�/m��7���jY��YX���
�[meێ�r���lߕ��q�0�x�����<Ly
�F��Q2����ky�ä�az�Z.y�m�C���
ib<kiJ���� �L0�g&,(��"n`�DJ�ð��ډ	�Q�R�t.^
+
+�K�)z�KIsW���Ft� Y�q��%�0gn���`h�]ҥh�·$E�n���EU=�s1rʉ�F�$��1?��'����C��T�a^�~�z���9���Kn"jT
�+���J\'H���"�G<z-VA',�S܊��;#�)�X
0A~�+�
+�Ċ�"���T�o`�� di����Ő�g,b�{�g�����
+"OAc�CT��}���u��1
�
+w�`��6�����س
+J��-����Z�A��U�2]Q��E`+ܸF:=`�
qY*Sr?�r�|9��LdB�� yaVzea6^�Ű�l����ھ,ZC[jMR!�`��l-���Z$��o��o.|�Bb%��(�;�T�
+ƞݝ����lJ
+Q�(q�p}
+�߬[��Ҁ�蛟�ҏq�C���5Rc+��Zz��!(W�nF���({a�氖��?1ȴXK��p
�=F�!cnՠp�\�f-!�`��S�aI�NMC�<��i�PoH:�=��C���܃Q��0�a��0�=46����0�ü��$������$N,�~���s����j�
5�LS &�Z�G�ј�>��d���V&�a��H�ХdD�����܍Ŕe}�&)�Rg�����U��&{���H��
+rf�
b2����O��^
��2\�Y1�9(�bg�*�D�� �d%e��2"
R
y��D���Ӆ�V���ZurZ	�pf'���/�
���'���+�Z&�@l�M�}1,�n
�wN7��$��u���z�N�:$�]��Їh�5h�?D̯��X�j
⿖0JXK1�	�8y��ΆT�_M��n�}�V�gK�
��X���-q02�LW��"
�)�
&M�@28�
>>��%É�Fb^�dѸɜ����܃���ԁ*�?猚)�'ܹ._-6{��sMFS	����\mx��#���ԥ�z��q͗?
�Kv�� � �����'�~���-��E�U�aĭ~"���F���i��
�w�

+c|DMe��+Z����uT�ܯ��"�C|8�lx�
�Fp����a~@��l^��i��G�8yo4H�G�y�a����o$F�#�(1���z���IR���&
+��ɃhyQ�J� �n
���tj8��v&Q�$�_�pc�`��d�l�B�T�ܙ`�!�4p�ణ/LGZ�/5�
Vr��q}H�q�"\�@
��C���
!�n���R�"��
�i;e�ͯ�R���Jl��$�� =V��.Xr�Lq�yw� fqڨ��y��;:W�^ToLK4 ���L'�`ҡ%�J�� ����-/�w�
���W(]�oj���QS�	��He6�r4�d�&�LFoY$�(oh7D�
�{�`�2p�!\
ЉC
�:�q!9�R~x��
�9נ�C��Q�?
bU���5�
+^v��]��0�#p�x�
����C��>�y
���
⬇��!~{�^��C��0}�b_�����H��~
�?�Q�#���:�l�<[��M E�
FaJ��Wi���kyk�$�a:�'r��v����a��0-p%�p�n8LL\�b
e<�R#��(ג.��3W�8�)���еL�a��J��J2� �u�"��O;L�
��������ky��$�Q��Zn�8z�2��_=L�
�m��x��
�匊�

a��
+��n�]��y2�����- at I�H�'.f$_-����
��I���1*�:U��
���kBJm�V�։n�Kh��ƃ�f�Ìc�{L��<H�3�
+�y1h�idO
 E

L�ꄃMJKiЗ���,��b���F�� ^]��^ժf-k��4��,��Y
'd�+b"7�p�,�f�#kvkc���B
+G�n�p}�[ȕ�pL1��\i)90��z_�v�@d.��֊#.-�
w��9�($��4&A�]�,ʓ{�
'�����B%�5)��6�
ό���C�J�9���Q��h͛��\��`�L���e
.�]�
4	e�H��t��Y�*�P���R��J�Rc4䎱��A

+�eƣ��Y�V������f�iE��ΌP�H!5����6Uq�+�Zhѭ�hYd��'wá���b|��% 9&#�	�4�G�,es#�\
(�Vm��l|�=�p���x�%��n͜�s+"@U�.Cўb075����Y�
`�E]���V����t��a�j{\tnH���$�u$�f��-��C ��JA6w���J�IiVT���}���H�<�A	
f������m�J\���� i�V
+Zj���A��ii,�r��z� �)�"��\��י
,.:3�_���Iz��O�i��`.RbD��1@�,�vԕ
����nj��`�ᾯsu.ea�V�;��Z$vbj��<
g�a�̀��8��l[���Z4O��V8���_!���׹�7�'V���li�^�	U�G��R�i⚟���Ν�q	r�>�j���lm+A�q�s
+]���.�Q��(__�O����!��3`�_ eM�I,��q�t��(4q���
A��eN1�^	��
zirx�b)��<�C������DB��d�ļ��Y�"4'��&d⢜*�Z%��
��F4��
��-�ᐵp��pȇ8`N\
�����#�ka�i��ke'7�p{��,�12���x
�H�v���=��
+,CF�!{Ȑgd��d�`2�:�#F�
4��-4*��y
x1�z��H�s����e�=����W��U��&bF�hOp�U�}@EcU�5C��5:�!wΐeg��g�߳��3d�旛�P�4[��d��gl��Q�jHv@]5$�Zc��g
���X��^C��5f�!�؈ol��,�3x�Ϧ��N����Ǽ��� �I�W#�e�9����p�@=��� ��K$�.�I 'h�]Bi�V��#���e���n$�FquG��!�R0�K,N麴(("�FD&�1��x��+]
��2Y�,��=�����f#*�eڈ^m�F���� � �H�e��o�OAq��@A1�x���
��;
؈�c����+&>dZ�cdY�+��;xs���
MK�x���y[g��mi�E�{�GGZ�P��O��?�=�����PvFB�^���˄��T[+U�R�lXm�\�0�w��;N��4�J���p��T���d�E�<b#�A�mq9>��Q���@�Nh>,փ�E�
 7{V���/�����)!�3g���
�`}L�sK�$~Ơ�▅lw�v,��g����0���E9 ��+
W�gQOF���r���H�yσX�����+ۤ��OZ4���� ;���hO�-g�!�Q2������\TI���B`�)*�6�0e��Oڨh_Y{���Vsq��4��Fy���

 �7p4�}�F	+�Њ����r ��h2�K�/��J	C�ؽW
�
+=����*h�:��V)G��I�L&Cړ!G�
+�ʘze�Ӳ��2�Y��g���Ő$cH��Ͻ��<g
��h�
��J^Y��
2�L��$��i�w�}���W�p�6�h7��~<8nu����eN g4\,!y��bHn1��X��د�:,˺R�uX�u��ݫ#{����
Q���*������j��N�����o2\.��s��|�
�;t����Y�r�
�ȵ�tp���3}E�
+c�b��
Օ�n�A����>~�����a��a�㵚����R�ku��O�6��}nT�WۥD��oK�Ge?esd��]!�@��iE�O{�D�4�� �,.US(Q^m���	�
�aM�gn�#
_Ed�Ҳ�;��뉰QQ�j�8K
+��<���6�-�$��Gپʐ9�
+N��w���:�������ŵb�c�.Jͳ6��T�L��x
�АeȤ�F�2�h��|��E���у9A5���R��2�**���gB`haI��M6܎�;��+"aM~
����o$�A���Z֠EqЮ�w��B�'�5���|Cf�!
G4��b[-�fC9�ֈ��,I+|Jk�KJ
+3��
u׼������qہ���o���y�Ky�B�;[���i
���"��
W�Rg�V��Vt�UƦ�d�m�Z�c4���'M��)�4U(�h�j��0w8���CՐ�j��j�X�j�
+f�3d�Y��Q
1q�Qz0�
ŐRp׊/�H�#Kl�p��g��2������B�r���RL����S�i5����j� ��
Ʌ}]�R�|�V�����N�df��
+�EzpFB�7��L
G�s
�z�>���Q�^�
'������
+8�̦n`�:?�b��
f�A�
Ge=XX�rX��k*	���U����"d���"M�509�>��8�4�쬂	���+Pʙ��
p�*dQ�Q���ӵ�wpL�	��M���v�ե<���F�1L��Q
���X�;g���7�`����PJ����L�&��.�ز[m�|^�E�)��TV(�*9�01�Z�2�Xv�|���C��!'�@x�6<�%^�0.] ���rj�WtQZ*R��,)HENe ���ۛ���X���-��j!�
Әԛ�$B�.+��y%�!8d�v���u�i�4���ϐ��F� ��i��Q
�8�^”�Y�Di��ݴ�4W�� "g�9D�B�dH���ɝ0[[�$&m�6��¦(`n�X9a-��+i�F�N�cxI#�"�P�?=�Ʌ�\kT�wb�Vz���`�E8����������}0�dɟ\�S�|�C,�Nt�,=�Ru��j��(
�:�섅�CM��
+�6U�����(��)�	qJTM-��h٘G���3[ �*S�8��T�u�ז�|�F�t�sg��3��Y)�<,����a̚5���#�
V�h�m�jsce$�J"`�T�'��tDG&73�
e.J!�,�I�C�ӵZ裢�+և�؇e��J�K�y8�2��Q�mb�Nɰ�8��d�� ��F����6v'{Ѭ�{g$�EL�x
��&�`�  �Hp(��V
�P��*��	&5d����Q�D�H�e� ϓ6J�ϊ�����F��PD)�PХ��B�r��U3!���$���A"�1�Z�'��Dg�`B��&��
�O

J�O�Q��En�yR�u9�Ѩ<3�
+;�
~��a�����77�}�� }����3@߱sr�b�Vۇ|�#��/@r����Z
+س��Y����f�z�M�1A �a�9,�,ڮ�ϸg��s�S��ے-;
+�%-&�,n�-��TҜb�IV	�%F���B�HN�t�,-�s���🭄��e��8&m�ƙ�
Шig�Kp+h�6���5��I��#SY����H��)��(3�,h�f%�4���x��V:Ȭ0�Ò��T7�c�p5��}��`fW������'%`������`�~Ϡ��JY��BÂC��Dku�f�^)���be�4r2�h��t����J>z���U)x�nw��|X�V��†���ʐ
k�
���+�
���뫭cVn�x[+7�
7�3��w8)����b�*�8:Vb�Q$^tJ�N	��H&�`$h
)�����fɧ��Yi��
g�c�����<��Y�A���re��p�Ž�F�H��#j�;E9:�k���C�*�
+��.VC|T��q��a����x_������
�0U:�Djdp��
+��Nw^���Zv�
#pGX��w4�tC3������7���F�
�Ze��L���?x��w�"�p���y0����݋�ھ��/������O�?���7�>\߿�֟^����n���ۻw���oN��D������O����L�Q������?���'��/O����N���~�/
���,�0�t{�&�/�Ʃni�I_��Mݭ��~��ى
�
f�٣Yi@{��ߞ��oh�|�Q'�N)�՗�$,��E�i=
+�S`�B�)�ϕ� �'>4N3��!�:Ʌ
�{�
��d
+�	Qh�&5ʅ@%�K��P��e%�:���
+ʚ\�oy��f�v��@���piQ��K d�8��
H��ISJjIۢFA���R 
�Ēp�2���<�}�r�)�d�𑂾��T��
+Ԙ��ڑ.��E{�
�Tꖹ=���{5���Y������3�Ӹ�`��8e�F6����L��hyB��?��Q��/�D�ơv{�0Y7U$�F6C�1ͺ�c��'��Y�q�Q{�\ʽWh�%;O/��ff+D��17�p~^��{9*
�R4-t"
^Q~r&���s�=Q����6T���(�@<<f?�UM־9���t~ئ�U$�gf���CsyD����^諹i�v�ō,�x�Ew��|úȋ�;<S����� {�H���;3�����Lb���3�b6��Y�W�� ��酵/I�ښ+ݴM�e9i)9;�W|�/�4=���2!�-$NLd��ؓ����i���R��,�@�'ўEv-
O��vf��$~�B9��B�}�7�6�P_��ό��F�
�dLE
C�q��y����I��v�]@��Y�b.��Who�
+���ҩ�H'���	/��A��T~eF�����b�hv����L�2��z?�
�>�,���ҳ��é&�����;x}\HE{hi˄A��]���"�Uj
"����n-��L����d�H�U*��H�2|��R�YG-[h\�-���K{b��1��N=������z)�^z�I�,�E����ѭ�|��v���|Ҥ
��; BJ���jg��Y:)��ZL�'v�^����Ufq]�n?*g��B.rKI���=�z�PJ腶�
�
���_Z��ۋFDPd;��
>�vq�U�(�4���*��#
����Q��Op�g�x�B���]�iJz at j��N���8���d=0�
=�q�NN��}	Z�B_ؖͰs2�K�;p�V��$�e%�"�y�m�NEqC�L����y3�h��k�Tq��$lK"	��נ<cZ
�F#U^fY�>���ӯ�"*��9���
�{�d5}CM�%4�J�
���z�S�%�����]��pn+��˳�(0��mY�T-r�~�xWT�dv�1e�X
y��п
řyK��n�ӓ��΅=2�VLEk'��}
�ڛDw��?�����nY�`9�Z�l�s�-���T�v$c'�ϵ.���جt�:h
�9���.v�6Ē3�ŋ�=��mU���c��
T�ʔ9�j,
<�8I�R[�8L'�%���ˬ&T�iqv
=��8A
Ȳ-����@U�Zئ�+S�K���ʝ��Ƙ�żr��2����QO$�>�A<��10.mE
,q�-��S>���$��x��)y[U,�֗Ъ�S�*��͉v������6�8��/�ib�P �z���-��y�lj{ [...]
+�����-�F;<u�K�Dž��[�]�
�H���dKx�3���m�6-
+���Dɱ� q���T���c�UĴk�l�1��?&��W���h�8�͘�
ֵ3qᨛu��"z��{�x�
q�'����jy)4`��9�ŧ�	Ou�l.؁Ӫ� P�	r͍�����i
��_���
=z�"�޲�0vFS_��(ͪ�(2����靹��
��a�
g���T�]
��K�5X-Sf	�ur�����΃Qi'.k��V7
��5�	:�
���ZISX�^���'
 9�d�s�Ε^��˨�sv�o��,M�ŎD&]�F�^.2	 7��:(j�J%��
^!����.75[
 "c�OmY�М&�ĵY�X�����)1�FEstk�^]�VO 
II�
_�r��q�C�5硸��v�q����fV0DC�u��31����=IfB�Ս�;+x�gt��{��)P�1�w
��������I
J��+��-ҹ��J1�3��pp����h݃w�7\*S��mA���(�{a:����/V����QbD#R4��-
+�Z��t��	
u����"GY'ٙ���������
�
�1b�"kL�Mq�l�#�>Yv8���Hn�-�
T�Q��
��$~qN�bz2����قxH����l
-yPX��cX08.[�Y����x�z�dVҸQt8�|���ڪ�I�!��
ڮ^��0+4.��Ô�Z�Č�lJ=Z�ORN��̴�,
���s2b��85�����Bh\̐�K��`�n$.{>k��]P�U=i��Ds	���=4�DK�L�Aզv�d�=��TJ��Ŝk��r�t/-ɑ����͒z�5��j=��q�>�
+�0
�t�x�pZ�7x
<�z�iTi�����E'����v��bL� �uP�����o����y�4V�vqs$��[�Ly��㣴͐�@AT^mB��F�����S�!=U�+��(�^�G!��lJ�?QHR�5��ԍ��s�%�R
z+��$e�R�26SS��~'8)���6*�^�P1���a�.oFR�B[���	����
}������SU�����jH�N��RM*�.�-��F�'��`�9�D���CW
+�";��<���My�_Cy�)v6�"7�T�
U
�<��pq�3�=^�lLrh�4M"lx����
}���O�p�mf�RbJ�l-M���
�ba�� �
����٪cG.���Һ`I�I=p8�uv֓V=O>IW����I�Ƶ
8/�&[7��a`4��/L�ύѸIp�Ů�����0G=��VI�/]�]��E�ow�گZ�
Z����R��gsY.� ���J
[�]8
+<r���>��#��m"�!��`�1�â�lOf6�k;
|��A)���P
+�ޡD�3���P���6ߪ�d�A�� ����nO�%��p�1nTVѐ7U���Ia��zЏ�M���:d���:X4?���Q�?
���t���K�_���z B#�J���^DU,���%��J�g5�
��E�<��]h{0��(k�svj�͋1X
V60�uL�r����d[&�̍�r�r;�g
��
-NШ:@!m������u��
U?��;	����I��:yw���"ES��13 ��J?�ye��={"��RQ���K�L�hA���~�>��}N��A/�fq�dNS�����Ҏ��d�
9��ou
�$k��4:EH&Q*�ߡ�.�P-
�Z�Jv���B?
�ȶ���Tz��.Z$
��D{��q�t��bWN"U�v�E�4ԅ|���^&�rYP
��.
6�k8L���
Q�T�6�aC)4
���S�^KnF{j((�_��TsV�if�&�t
�!�TDZ�XXD&��,Ȓ�Z�Ψ$���v)V�:f�k5��Z<�BW<�k�L/�` � %�{�]WV	�z��%��:5?%�(��j'd�I�&	B4�J�3��� �&�C�^_t�L�Is �f�CP�;�Ya
dsVKX/ �0�D��$jM�+ۇ�ǰ��< �͋�sa�.c�
H���E���#v���L�
�DȆk�E4RS��P�}��sQS�LN>c���s1�,�X���b*!w���xx�#e뼰x�
�6�v��>�r�"��9O�z�wS�x�S,�P,2>O
D�X����u&�ʁ�Pg^]�s��K�J���l�E߽�h���Q��
���
�}�w�D�OD��sjŻ
�+
+7��������!FS
�	
�!\����%ɂ���P-�i��u
��J���6=�u!��9�ܹ_)8;�RM�^�Q��ь_�S{��
+#F1e0)pKr��X%�~
p�ka�9�gM����P
��K�
�E��;�Qj���j@��r?
+�%��ietg��l̐�3@~f��s]���m�I��9s+����Tn�ڑ�e�]��G�C�����;�����,*�h�q���Q!���n
+g�w��'���wH����)frc2W2i�,B'��^m��k�6�ԚUI#2�
;x�bTT
��P�P}�̧�Z�7��(�

b,x45kI�zX���'.N���W���L����4[Dz��bZW��,A�ق #1,�f#CR��ҩr����j�7�>�
H����K�k\��
�1��1�z�����i,z�hM�0[Z�b�a�jW�Ȃ�	g�0+�룄Nh�"	f���iEbth���*s���W���y�
�<3����z&ubPӓz�4ڗI׽V"@
�,�(ޗ��N����A�T���w�ڸ�_����M�
����紦]]�]¤�d������=#b���t���C�X�nj�Y�-/���s�&�Dž]�5�+
+���/\��=۸�T�G
;���'Ud]�hƹ�5j�FC�hLd�c{�fv�
tF�
+�
�z��)�ہW�x�hĢ(�F\�8�f�k���C����
�G>e�G��a
ϙ-�����l��Ǔ�F�[�I.V���n[*ܮ�����2C��Akd,M
X��G�xA�r����V����V́�A
�>�QC+�(kS��|��� ���DK�����r6.K!=$;D��C)�
;YA�d8ώr6E�z��)���l�O�WY��
�
l*0��bA����ȥ�y
�JLz�d��ɵ����"yKD�D$f
0��N�^�؃ϑ�x'o
���Y���*67�	E�X�UM���!�L�ʵx�uJ���<���
&&��Ϭ���Œ�4� ����Xx3ZmE5a��،6�p"�h!�6�F��?�m�jN�0�+s��Y�;%�H��E�`.��\��/kQ�o$=��M&�$3�zP/�p���+�+t��A�EG
�M���ki�K�� h�5�kX�$ Qp]&U�;��:7[�����{̸�VF[��C�즢�S�8�}kY!p]���xփbޤH��E��*�~ѣș?Z�6f�`�̄�Mmbu���oV�����u [...]
+*ba�^�P��>��-���4����Y͙~;�|s���}b8Q�,Z?IKӉ�т�4�v?a�yQ��y�����^$��F���2k5NVk7N
NL�`
�zb[�TH�t�L�s
�!�ד�颵���
�;�h���-���
�^�T'���x5M	Îc�\�\j;�d{��-�^�%�X�I��F�9
�{`�
ȴά�Q�>!�2qb�W�:h��~ή�f̺NcS ����rVEC9J�
mT%�2r��lh)��F�K��N�v�t
[����R{Щ��ׇ�Y߂�=�ѩwAf�X���f�T��¦U�ߤ�]���z�
�Т
�4vI�-	'�WD��Њ 85���yc�c/=�Nu�H�D�� �q�

�
o�Y(7I�~��H�3���-�ժ�ť��P�u�Baf�#ѯ�B���f
+�d.q��Ŗ�'�D~�S�2'P�f���y�B�΋Zz(�M�/�b��/>��
+�^��RT�I��
��_�<
�BYn.,�@(xh�O�k�J�!��B�go�ӓ͛:T�s�%�U���%ْ߲��
8��
�I�U#b͖�
}0�f� ɺL=0L�QMg���� ��j��{�~2��N��>[�:���2�vfP��UkTSkje5`�.���C	8���촴������Җ����E��d� Jy�1-��i��
m�ګJ���<����٩گ�)X�Z�Õ%�Pxϙ�Bp�i��f��U�-���MR{��NVj�����=p�;Ey
O��%ռUA�Y�L��H�s_|���MV��i�*�*����l0���G�O�_�A��2��Cl��g�Ԃ]��pu5���u��ȹ}� ���p�ߘ���c/�c����1�Uz��]A6��*
+����b~�դn��]���p޽
WW	a/��̜m`��$ ��s��uc���Ԥ���diA�Bp�
m���(
}<��6�N.��R���e�-��(�Ր�@1�
�r�-S���p-h�8�mnR�#*�&a���y�0��XR����9U��Gt�
*$��J(ى
��%˜Q_�.��Ձ�j�M�g���
+L�Yh/:?��v�ʭ]E����R�A�H
+g:Z�j�v&J� �VAݹ�e���|��rWzX�Ҁ�ŎhT\&u�J
+/��2�`V���eYQ��)U�T�T�� ����C8��u,���%H����s�:��
�䡉qC�tݶ����Xb�I�Af����$0����*�
����P�
+�;νK����d�N4���@�
�� \e�d�&EX��-ZL_�X�����&��S9
����w���h���U��(�+e�Xj�͖�J�Ѷ-�����G)�K}�T��n���g�X2[
�
-R��<K�2���`li��"�'��D�Cc��K�B		��fӓ���
+`U��_/N�ҧcB�LzL,v�P��U@�-���Q �����Fc��]�]ǖ��;-k�4w/�T�( c�:�1Bٙ���2-�*��%w[HU�E*��$;F�yh�%�
��FÕ4�F�Ҙ�K�
X��e�Sգ�e��9T�1��Ѯ�\A�_h{;#cֲmU�XnJ�R������&���A�B�g��.8@�
��
r(�����8������j�������&��6g��$WoU�hZ
�v}4P�V����x���k�Н�V�G)з¡ �[���]�t������U|65i�L9]x�d:�?
{�墩��xH����0�*��2�G��*|�+���!�ŷIW�łJ9q
+
�����
+x^�-��B�h�1$PeN��Э�d�b1�:I��[x�z�iynE�r����ڹ1O�����,M��v[��B,Y�<p�Y��1�v
+��F.6G\��>����"5,��Z�-/��]�
'C�1��`��Z�_�{�Y�hO��h:3UǴ�	��wzq��h��`��J+����{Ԋ��E���f�
Y	�,	Sr1�A3;����c+p
M^fZ��"�sq*�h�}Q�~
'yF҃��h+
���Eq�OEM��阨kj�s
Uq�4(�lV�=�������1Y%]�nQ9�w��fǬ�n2

�P�!��
�
�^&Uq!;�RL&I�/!j��2�m�X\�I��,�-�<��'��hL2�I�jL���v1�Z_��*�zD�׿�{����wn����Tډb�����W�ѿ������߼�]���`?���������ݛk���n�>�ܽ����3��㓿����w�O�
��������z�O��/^s����7����
+��x���#��������'���'o����k��'������?�^��˷�ڛ7+׀\�.�~�L����� ��a
9�!|�a�?�ܴe�y���
��{0�^����F�>�p�����>����7�=z����}C�����|x�a�;W�h�PM&~�x���������o�|s��9������������쐬�gл��~��p�&=�ἧ���������s�s
�~T�>������6
������m~X�|�������.�-G܃�7
+���O���B��_?�˺W��w8`�w�nmy����o�>�_]����w��\mѦ=�xV_���w�����7
�]����������7�m�/���|���g�ߜ��Řr�є;�rGS�h�
M�Wf�}sYu�����y4�^�1��$~���W�і;x�w�����9�rG[n�-���z�_�/�����
��[u���u��k0��k2�6}��a��
;V
���
+�
cx16��q��ԛ������_AY{
1y�!�x����!�>���˻�ᄑ{{��
��j�Ax�&���(����(�6n��^��/Gz������-����w$���o�_oX9���������[���7
��w�1���"�p�/0��a'
#��y�lu��|
ghxMg��
��/bh��^�{w����o�������<��~�!�������\�۰�_]�ݢ��u�|�����wo/��o��}���w/���"^Vo��_��~
8����݆t�����_��_??`���A/|fw~��������.߶즃�o�ї#�6
����
���7?����%�g�ۣ�|�?�������lpp}s���6�������פ�}~4�o��|��Ӗ��]�\�zw�nː��>�~�D at ugP���5��7�/��n`�p��em�0�v�s
j�鿙>�W4�����M�Zӆz�$ȅ�x#������?_~�a8��py���+�kHq�p�|�∠��mL��-���A�
����n9W�g�,.���n:]~����������廟�ݲ�Ѹy���kB�l���6���D9�ͽi-
��~MH�-�9��}D��,$���T~�P�#3ڡ?���:N�ׄE�2��?E�X���E�`�
�()^V�&,ʖ�
��~�XwĢ����(W�	��e0/����4/S�i�>Bj<������1�/R~oB�
����y9⋾�s��k�1��H� �����z�g�kc4}�\3[�̯�i�(�
+��Q�
e�
�m��Q�
e�/������G��U
+����U+�ʵ��v�k��kG��(�^�\;�kG��I�����G�]��kW�|��m���
+
����r�F�ญ����6���
;Fzw�!q��%���%
z�M�8��U�5U��4�c�*
��\�z��?��/	�m8`
͟�nm\f����V _�����j|/F�}�3�	�7[t�7Ϩ�
��
�غB��+���s�;���wwoNi4�����W���n���������8�m��ߖ���=�6�9�"w�SN͗@1�q3
��g�x�|s���W"�V��_!�����������7yM������7�|�B�b6��
����뛣�[8D���:��1=��Ʒ�
��9v�>�Q�=�{����-�j��݆��������v/�x&
�i@[�50���
_�����M�'��Ɠ6Pc\���6z��k�Y}��
���mq�}�!�t!��Q�{F��뫏o/��q�K��ht�]�����	�}�*�˳�o�٢o�O�������ny�J�Q':�D��t���
~�J�x^���Q��Q�;:����G�T_
+�6l�ۛ���Y�,_����������-��Ee:nP��}���g�?[ư���3�pЖ鿯]�3w��a
�3��x8�-�ʃ? �(dz�x6�Me򡟍[�p�g�s�x6����%z��"�~(=�}٤�_FIx9�㋾ŋ\�����ق~/Qw<�=�}�r��j��.�#�^��s��S��^�
�}MEΜ9��Z>?Z��)�>�e��+��.��
92{}9�Ƴ
�ׯ9���5pL�nо�$�Q^@������2x��`�")vD�
�<x�b{Q{gCZ��<�lK��Q�~����N��s}���/�z�A����u_��˟lp�Ӏ�ջ�s�3K��|w�//R���Ev��L'�}���q�=�2s�_���Y�!d� %�_�/߽�fK5�\�N�9x�����v�G�r����qt}����'o�
-��n�#���@,����BH�����ۯ7 4���o^��y�����AS�w��Mzzw�
���׷w� k�H�N��������wo/���.߼��p�:�
���F���>�tu������-�����5��߽��2��˷W��txv�>נ>'<��O�����l����ah [...]
>ݧ`b��4s��ͻMD��t����M���Y���w7����4�_��X��-�c
� ^����P>_����xt��&p�2�q��Eɂ��U^�08r
}f$GΣ#�ё��i�}hg�#��1�{��>{��5T�:�~���c�w<�c��


���
n�c��G������C���Y�诟~���>�{���c����q��
=�{WFs��
��{��\������]|���ݟ??�[�wsnkYߝ�xT�FQ�w�gӹ7�K��Z�G��C�Fu�
٦#��&;�ɾ�A
_����������ݏ��r��won�x��?�ܽ������7?���|��=�ώ������<���qs���Zݒ
a�W>�ZK�s������}f7��n�ܸ�q�������s!z��\���e�r�/�mT���i������00Y��p���r�_N������g�`���x9:^�������x9:^�����nv����/G�����l��DƏ���/�[1x^�鵥�?ʕtt�
�&1���Qn�/
M�s�r��͇�\ެ��^�x�[H�`b��`b
IƑ`�x8~	�����ʋ9��K/�p<�/
��xd_z���K��?B�����KϵL����������Gr��9��K�LWe��<�xM��
����7��W.����f�� [...]
�nn���&C����_
��dc�^��o�y��_��7[t�7Ϩ<l����� ���뿦5v��Ϸ���}]	N��g������&���o#_�l�����hڟG��W��9�Ӵa�ݬwӦa
�a�
�?6
�?�]�����1a���i?G=�o>�c��%�#v����c���
�c.�gFr��;��
s�6ۇv�>���:���|�L���=��[
?_��*P>�
ɿ�7����W��� :=�4��ۿ��x�f�(x1{��x�h��x�>e��N��о��ᾜ�r4�^����4N]���6�
��1�+#|�d��3�PU��3�
�ttf
�|tf
�
ʯ���e
GgƁ��Ggơ��3���xA�
���z
���|��V�5�JL�ɏ�i0G?�k�c|�R�Y->�ev$KV���%o��^ W�t0d�_J7=2�i�ϙ�M��;�Aw��b�m�Gk�0�p��m0Gk�h�
�5w,~��
��h�m�ќ;�sGsnwGs�p̹�~�
7}�O�ޘYGmM_����oj/D�w*�?���ͻ�_~��_}���������woa��_���=*]���0�����ln>�΢[R�#��K�'��
��D����������Om���|�˓�����7?���/?���sgq��ԕ���On��B)�ɩ�g9�?]:�sN��CDK>sS��ŝ�2��s�̕�_���^�)�z�
g9�����k���)̞�_��-��2�Sv	�PG�x�����Ա�<�ϑ�O)RO!Et�������
3�՟E�-gi��;9��K�A'��,�,���v��x��砇�
��)���%���	��}So
g���1^�-�&6�y�p��K�;/��Z��Bs��:w%���Y�����WO4�r�\�|>��Th�c�ޖ�y�w�>C�_m�
�
�N~��#v�ΙgK�jY
�x�ѕ����@W���I��=�l�s
�[�I�+!���`���eI
�3�]��X
+��Y]�3?_�����yugy*q��Zb����D����ve	}CZ��~��=��B#����h�]�����	7�7�}���_J�ϐ&���<��:c�Ϻb���
+���i��?O3_7��F�Œ�Vu��]ѝK,
�F<�e�b\�[h�r�_�f 
��
+�cH.�vQ��K�eJ�������X�S2�KY�xR?_�h���=�m�u�)�*���*����3�
	��n�!����Q�!�g�>�$��u1Ed�N�
�dJ�u��w�Zק�HD^p�.���[B���<}��T�:J^w��jw3�oYs	�
"�[��.hY�U:d�]�u�)�yg���e���B��Z��-`����:�Y���+ �*�n��jY�ɟ���#7���!��Ԇz7�ʢ������/��߾��
���O�H�K$�@=-,hCqu�|��&�dd�x��	����
׋�B����T�
>e
+nG�9���"��^k�h�»
I[�ŗ�4y\��I*��X.v�
k�@��I�r6'~��n��)����>B9�Y����ж�OY ��'X�Y�H�<�\ꂞ������ԧa��W��]{M��
:����Tgh.����I�#ʞec��v�����|rQ��GJ$
}ݕuP����	�b���>����g���ܺ��LzΝ,3��:�0�%]G��{�9;����aL:�~�	+9a�J�+� p섅�o����|�?ŕ�o�n�:����X%N
+7���0c�WuI����
����zK�$v
m��ڭ]hI�3/���<���֙I86�3|}�\H}zr�/
<���af�M
_F�,���K�
Po
$<H�U�U��a��j
+$�RL��]��%�

-'U	�o79I=#R��>�Ú<���I��X_���]��̪N��uɹ
��Mu{M���S�n_�d�|�;l�z�[[m ��7y�:oX��pE28ԗ�.�K�dC�{��Pk�g�Ou����Ӷ���n��$�q]��&�JHb]X	����+ at T���y��*6�cA�5��α<h��W:	�t��g����zd�zV�\��e&�P���HגyW�*]�ԄJ�b�ն�t
���>�4��l��2��
y^���bt�zT�OV'������!N�����)���}���g����9:��$�]S<���-;�O�x��?��n�XQ��*
��K�M��Yp&V���HY
��
���w�}�*������Bqb%�Nu�po��� �W~��
�$�=��r�ԧ;t��$i\�_fy�P�0��J���ėU�Ɵ�'��H�3�F����,1h��`
EY���o��ҵJv-�z��dL�~a|�<��P� }�����m
m�-t�7B�&�z�����v�eL��M��uwFzY����t&
�&���M��+��j�z�@�
��D9~Ǚ$b��BCոH�@*"
T�KvX�\��J�z-=R~N��4G�k1��F��
+�DJw��jN��
+�i��*E�ө*u���v
]9��
�83
� �

�,N<�\� f�u�l
)\�s�����Ol��=R"�!�ؽ�
J��Ho��1����L$�&�7
t֠��s�P�'�'\R7^m���V�ƪ�X͇3=�9N��:>��ͭ�]=Qa��G�����'I�I�"ʇ	)
�y§g
U�n������*,�������j�iU2�T���"� VS�+)SU�	�
�W����q��@�MF}�	�e�k��P�:օ�� �4�����.��3/#(��̰�"��t+ȓ�
����][����ZW��]�Y�v���%a�y��62?�̢G;�wD[cU��uS8LP}���2Lhyi�a�"RVр�
jg��g���K���qB�~�
i;t���l��M�$��}���6
�UӜI�!���4>��w+ڰs�Xh�P)�A�Z`�QC��@)aJ��qS'F�é5y�#Α��x��j6 ��O�38����[�\XM��Z!�M�Z@
���GC��DV���*C�-��-��P�l{�P��`���(���m�c�:�F?�In!� �����e�x�g*�9 Kxaw@]=�8GS��4;�du.s=��B#5 v��
��.3s���Y�,x�)t7vf��B���R�H� 
+��E�\�uY�j�Q����
g�i�`�:9�1�4\�>BzT/�E=ip�E�n&��n�9B�E�Y.Xs��T�5���C}�2���?��Gv��:5��M
�R�p^5;��*@耪�^�p&�D�7I��gvV9y�������=�3�{E�-�R�7�Iޝ@�J$K"E��<t�S5L����O=��a��z����o
+�_�%�h��Y_�H��T���jl�@�i�N�9^��b�O#�
��
��ykB��J�
8�7Ҟ���J�"̫��R-�%$��g�������<�=�ɑ��C[�	A8Խ���W	Q���w�a
�L.)�|ibwS�,3�m(��8��|R'��Ӫ����������.�s��4�ʞ��[\fK��aZ`	�N?	����{���BGΎEBXɱ�!�ㄜ�Xx���v�pў���|���i��\��D�2ݳJ��f&�-�8H���ʽ6�j�|u�w	}����5z6�9��ȩ8���g'?Q�	Z���A[X
;z�5�]�H��
;��+��nV�-7N34�z`�4BS�q�ۺ�`���]7>
�yY� ��
7��HZ���a&r`�Nr�����H��7�B��K
+d�F��1fq��^���R���wm
tB�����m]߸��j=�
#�D�5�p��%{/�EUD�
��z���Ḇ��	h,�c4l6̘*r�b����������pe?l"5����x|f��6�S�"�t�ςZ9��
+��
��"����e:I#i�����E���b
�J������o�@������^'0��&��:f�t�"��C'���t�+,�6��侏l�ԆzV�{W���CҚ�0��z�kX
U!��l#Vxm̞�f<�Q֛��
eά ֋����sd����.���
Q_�9�h�
�ȶݙ
+��*����S�"�P,r
.���
�a�@��XX�C�"�:$���]���v���n�űp��0�]UՏ��r����ꌳ
�)�u+`�H;Y�X��<� r��cԆ c��|�.���`��p
+$��s�E�xvBߞa�'�f��(�x�2�_�"W�	A����l���s������P�4�C$�ó�Hߢ.���|�����|V~�X-u�U����
�X��M�U��e����9�X��jj)��
w%��v�.����Eٝ��%)�1љ�Y�	1
04F��zba�U�dx�(�H0�%����xZ�2��n� �mDt�� �j���E B�;|�8q�'kL�>���t��#�b�g��N��]�5H3�p��y�
+\Ho#���_<�ľ:o3��l`����1�
��D��,$I��u�J���*�a�ك
+���B`o}x��!3 �ٷi��������B_�,Ҟ-bd���Ó�~�
����ϰN��A"������������]��W_��������� �-7?1�]o}b�}N�_wR >+Po}"Z૯��(>�^
�e��¦�~���4 ߸�a=
+@�x@��aT���iq�~Zdo�x$��x,nۂ&�3�d<��4D�|�� 9}�'��뀟(��=	Y��כ���'�
���i�]���[�"�_}��x��	@���O��۶�
�;=	n@��h��|���<�̑�n��i�j���?�"�3�׻.N�h�������Sf�C��OB"�M�$,B}� �P[��G��=�@3�LB���zL<
�Poz,2�.��c���	�ȼG��&x
+B�U��c��{J���p
+t��!j듰
+U%y
+Z�����
+"�?�X�/��M�P
��'��y*r�
�'a�L��^����
lk<	��[��a��OD1`>��c`�l��7?�@�ԣ�
�����mO at 4���i��=Հ[��k���Ddn}����
��O�7ට 
p�S0����
�
��s��ހt�e��:pg�G;��?
��=��;���E=��q�x����#������G��d~$��n
+>��9N^d  Hg
�20��G#�^��f�
����`���R:
�� ��Ȉ�s=
A�Ct늏�G|�� !Q��Ob$�M�GIԋ>�����H�����X�:��GK�C�x	�N�����H�-�Ǣ&�L=
7AK�ȉ�d
�� ��c��R}~b�3DQ��'�(�|
+��~էa)H�?
M!1DTp�08������D\n}
+�o�4l�|��o|4��=a���)
] q��x��{
+�#x
+��=o!C~
��v�>��O�]��y
+���S���)�
��������c0�>}<
+�W��q��	H
��x,��S�"q����=
���d���!<�����
�2��`����
��<�!�E��r�w����o���I�'�qr.���ޜ�����ۻ7�
��� ����������o.?|�����޼�����o������~����:!\#������X|�ݷwD a���$!\�"����r�<�k�%
6c
+�	�j���q�oL1ֺ�� B�)�	�@��:��Ԁ��
��4p��	u@%&e+�mYet
4�e�����WԻB��7#ͥ�!6
���뾁�9'�;;ɛS�3�,/�#�QՋ�a��JzL�|}h���6x�=ⓥt
b�S�b]�(�AAA$(�����
�:��$.�ai�t
����=��Np��M��jS���M4��\��4�
2��.�_��
�&��6�@�o��}��+/�ďZO:z� �?�]�p��3�ɝ�C����}OI��@����@X�
ψ��S�&c���l�.��>p<&Q��D���UG��gs1�ZG(JN
�op��t�B�y�'`q!V at H�SN����Y|�Bo�H���b=||�^�u
$V�
u�O��C��	�Ve_!�3��q�(��(tA�y����.Ƚ�*b�b{Mt�Hw$�%ѳsNJ
��e�TJJ�1���(�
?@�4� �D�
÷�"�#<�EP�ڒhG���N��@8�F�Sj�h�9ؽ�6$H-�Q����@�e��R5�f�)ԝ��w|mg3�� s��8��%B��s�w=�E��7fGOuD ��A��

"mq����Z���RO$�*}^�B�X�@Q
E��d�%:ۈ4�	
o�@_�J���B�D1�U�Z(Z
+�O@�
�+a�ೡ7��d]#�L�N�9������ݚ`�[O��Lbr���9�D�[B8���
�SG�C�R����]|H�����
~�)�fr
��C����zO���4�Wcy�F�)���ɧ��E�t8��g��
9ji]�J&>��

� 6asGBA[*
^1�U��
d��,xqQ�2�F��J�N
��NK�)�A.z"
�x��sS�-%�z���1��4<\4 ��Nlz��jm�ŋ���ߘ�#���YN��%��l�CV���!z1Zq�J/{y/�I�q�\��l�L��x*�
+�(_ g̀�|�	�M
"�8Bi)-�I'Q��7�g��%�\$|�s8#wЄ���bq�_��8 ����pA͡!�^O�+i8 �!�2B
0�&R+�9��Ύ@0�^tZ#�	����zbu��!��@�vd�B����>�#'�5C��E�"�.�.8�y� �e$
+�*p���I]z��Л&�9�m�K�B�c�0�� ��kI�Z��ȟO�h�
�i!���1(�3�
���an�a�����cO
RI'G~j���H�iޗ�.H�eb�U�zFd���9�����l���B�@�#�H	O����V
+
�÷33����I�
�i4,
���U@ȃ�'��H��
 $@�ҕ�N
��
��
��bZ`�����DŽP�W
�#��Qd
�!�� ;u�n�ڮ�h!?V�:ꪢ���p���u��|�aՋ'a��9���Yd0�KZ�r�`�c�'#�	<��Q�z{h��`BS/�lk�ݲ�8�`��5� 7T��1eR�<K�7"(�#�ߙ]�^�
D� �g�#�/�3�ܦ���g�a�t��@y�Y@�IT�'�xYD��sЉ�Y�jdxey,]1�Pa�,
��4�MȠ΂����EL
'���/l���#�0�0sȊ�
���߻&��T��-"
��9f��uЙ!�'�U�X��BT�nR�X�XE�����lգ��AH:��Q�s�H���ଯK&#���x�ֲ`��;����d��ȝ9zz��ң{���ۇc�p��&	5\�
�
~t  �pKk�ā
+=|0�$v���
�"�X�頾C(��D��
<y�`?�o|ch
+����
1pg/
+�6Rb�C�Pt�j�8�!�`vT�T�	��2id'x"o��AѠpR� <x�P���;��Ѐ��0!A
+K
w�hc
�/C�#�n���DQ���0�.>�!ѱ�f`
�u
�={�8��
Qr�,�F�<��d����� `	�?$�v��̘�K�
�a�<���8�#�Jú����(NӐ� `�))�Χ=�XMӾ�F��Ԙ	������
I�!�$��(-uk�^[D�����Z<9��'	�؊�5$m;o �r#��+
�
�z6����2L�[5�G�5<i�Ҹs�@İ+-r#�ˬŞh-dъ��CY�'¤U툻
+H�%
�|�$�YZ#Y;q��C��L��}�|�n��t9G�=
c��|�M����HX�AÜ�P�'�R�ȼq�~U� eg
���$ ��\?:��}!���$7�		d��O�w�6���
+9m�����
�A
��7l̴�D�ܖ��΍�jK5k|?�jQi�^ܛ|
X���ОfB��<gc�/Ӊˍ3;8�k  P����]#�
�py��qR��
�k~�ٍ�B����<J���y�vR��o\���	���YN8�Y�F
�0}��MPb7��m�+�,�Q{�
���#�=�󁶈Gvo�����A���]Z�#��s~U6����
+�xb���勭
y���]w���w���E�_�k�o�W�y�����<�^ՓU����n��v��.��O�	��
+Q�dUZ�D�
+'Mu��#i9��$������4]����.����,��{w-2\�.�.��O�D7��������ފZ�wv���-����}k��Q^�k�ɮ�E#�݊��?���2k�3�Q!��.\�̡%u��.���і��Ŵ�qW����I
��k�wr�"]eV��=�>���u9�5�q��A�&Y�nLs��bY`�eH���d��SfZK���Q�4�¶G�,j�����f��
2ŋH�e)���r��y�s��.�7�!i0�}-��$�0,_��E
��:���zZ�00
2`m���|f��lT7E*	/T��$�1!�Pڙ���P�Fa
YBj
+��T=�?��e����,�ܽ6����
+�9�]�4�-.F����7k\(A�o!3�k�zb�M���yE}
]F�/a�Ao�w�?2�qԲ�Dk�'J�]ˮW�Jh-�W�2�����q��I�xGu��vZ�zp�N����xl�Y
��o��⃾�րz��ʷ�y�ZxW̃x
�l2o� L�څ��d�\��*L���.��)P
����)�(�
?W����8
�
���Xȵ2�ܷy6wJ��
2WěF u� l2��%q�%
"��q�|���.p>;PT��s�<����ٷJ�\�
��)�umF�g]�-�Dޞ�..7s����ũɕk^�H�X�)�7���Ÿ\�L��,3�8�J�	Q�M�M�{h�|`�DU�g~
+��
�_S�y��-����^/�<Zk"6����A
*�����5:iD�� ��&H^x�|�� J �+4⒮���0��~�H�-/a/�,+��`'��+"���PZ��`�AX���Ī�IJ�
T�il�F�%�
�;����-����d⤚9��?��
+ v̉���
�#����M�f�,}/qN^�-���˶��l�5u���Hz�NZ%�oaG��B�"W��S�
�-z	e
�cuf����Ҥ��]���:��&1�^P2� �wѹ_=#m՗��y�
�CV�(
`��]/Ĝ0u���B@ ��IB�^��|��[�
��
7
+�_P���
y8�f��\$�<�ǼӒ�{�&R�߀l^Ep=���c�Z"[�$�:�%�e�9�vչ���LR�t�` �I�'�� �Ӈ�3��v�R��T�S�U%�^G_����4;��,��9,�$f�*�$�H`ѿg�`_ї�/�M��"�
��y��\h"0�~l�����a�U[!�'��"[H-���@X�+Z��͒���H��
��ݮ��%�Mw$��ߺ��T�<�9KTh熉���{�Г>S�-��gzz�qh���Nt�]���<AכgK���
J{�C�I�
� �
+%!�e
|��ğCHOx��<���᠆�1ԧk`������"y�������(��.$:�.��-Op-��,H=����Ř:�G�"�y~Ew-2��J$�2s���
S��M�
��j�Gg�NT+�]$fl(�����
+x�8
�̀�L��
 �b����\9�0H�D38�2�jhqh&yqI�G5ö�88��y�}u
�r��(�
�+����*H)OPHǑ��"�[/��3dM,�Yh��@�(@�	'�ż��"2m�S��Ds�������� �M6�~����?
(a�	\%G����ܨ�F�gf� JLa����EF���t6pj�Q�YS';�Ɣ��
m�gH#"H �
�bg�W�#���5�{E^K��7���
e��~��5�3�~
�C�~́��s�k3��䂚m�~�ZS2:��):�UOlN�ꭍvB��{�kP_�A��
��%�[�v�4�]�;�^D �\�����q��yg�~���; ���q�q7=/
K$�V�g�]$��&}��I��ȶv�Dt"1w�h`��&� ��fc
�٣vĨ�U�ߥ{?
�R
F�#��`��#���杛�ɖOɴ?A,��Y���������t']`G���d"=m��D��?���n����A�����=�g5x�F����ѣ�	���~�,�M,Z�i
�<�o�3�L5?�UTm���S�M\5 H�1�%���ߙ�|K��5Ep"�R���{]�.������U3|�y!���C��T�4�a��1�V�
������r�Z�)ϔsvTtQ�ME�FUr5Te?o���K�0���v��3/
bj
�n���iF��(dx'F��{F�]5����J���l/J&@��"����Zt�D��R3�2S�]uF`^�SW�+�
E+
��5�K��
V�
��3X�l\db��'���& �
Ӻ�o���`�M_����7%���.���
���v�T Wݎ�\Q[;��+‚�b�
`��}��C�� ����
ϓݒ�@T=UW\�,A0ސ�I�>��!v�
q��:`
=mpBS�{"'!��ȝG�H��D� ���'h߉_�ko@�Á�
��H2� ��'6Y�B��ꄱ�~?@^�
�\8I��I���zg�4�'��V��Қ�>g���E̷�%��b�r���1}��̝�9�]?%���K��J�D���I���R�ĩ%
���ȩk��?B��2�
�⻄��p��
+}	��fV*4��E�POf&Rhg[�
+e8��K��
�;�]b���9�n���]|�K�p� e�
{ �FI��
q�B�K���&I����	{s�Inek��w����y����8vג̻���XCD����Z�d29cXq�*����*Ԉ��j�A��U�N� y�w�,�Mm�I�2oz!�+����k�1`<BM��G��h�m����[�lZ��uo����#V5GS��
�{��e(".&�RCa���	�Z2���4q@ۋ�ֈw�zfB_�{ N7���O�جʼnn	�,ݪ�@���Y����q��~�I�~�Sb'����D��|�
��3�ݫ��
��"OV���G#���q���2���Z���6>`VX�о�Ȍ��QJ�"��{X�H0�,?�5�W��%��d�Go���<��í�`��c��6�����Rx����5.�$�	�I�
�ف�gQ\]�
�Z�}h�`�R0���A.�DN��~g�T�9AD�D�֊n�X3�ek$�����F�?w,�WȤ�_Dݚ�u�
+��0��%Ԃ��'����"�����
��
�DR�w����?+��q�%�.��=�����
���[TIv����7�gN2�ͤN���Q#�|����%�ɪ9>q�"Z�4�zVF�x"�WS�>��``�F���z��
}|2�̗nk(�趉+�.
T,�!��)#�V48��!#qoSz����\R8�\?]JoL����b� ;H'p�jj�+���pO�;1
��G "r
+~��
����7C�z�
;��
+"
sn�/I#5D�)���\����
���ġ*�+�׶
&�Pe� v�n�V\�b�6M�0�0���WaٙBr?��5������[g�my�
l!l�m�;p��
+�څAf���)q�B&ܵ��*����h#T��Y{���T���P;K�a|� �C�
JB MLd�~�ǻ@�D�����ה�t�E���#W$�d�Z

+E�N/�<CId�q����(��$A� Q6���@��H�� �O�e
Q�-F(�Dؤm�?Hb���f�+-w�)�

n��C
�`�
2K�Q�^4��l�,+B
�`ߌ5��
���#�'�J~�

�%zZ��L
9�`�
+O-�s�#�/֤t�qo>'
΢��[��:P���q���H��-.�Z
 �O�?!�:v
߸C5
!Ύ,�Zڨ���:� )�}��>�=�0�ɼ��+j
$���6����r
+�P\�UB�XHx��!�7x�O�VW�M����M�A����#�3��]ݎa'X��$�[H�Y�1�D����CP��*��v �eC����v�
+C�y�u�F��
����]�"ۯ5%��
+.������Cװ�
��>�ǰ����Ut�'���V��*���j�=
�ơ�]6s��9��
j�
�Y�
��h��//��s����~�=Yk�t
��*���R�ϖj�Ok_'S/
��"}�Z�/�2cY�hL
���X-�/��{NaJ�%�6!�k����Ɛ{�&���S	�
��6�aW�@g��t#�b�I�
+q��W U��M��'K{8�r/}�z/�ݾ�
��h@��ch
�Y�įAulH��'�5u_����z�d�-	H5
�~�x�a$v+t�w�'PQ�ԡ�vP�
+Љ��^� tgȡ�R���g��'B�?A�9�$������[XD�] ����E�@b��M�84���n
��5)1�)���
+5��T%��)�	(1ʄ��	�X�����B�䰯EoH�EJ���p?�F�Jo>�%���
{2ϔ�(A7�8��M�\��֤��
"H��I�+��(
�l�\*R^��"k
PϗI� z�����l��� �C���Jb݋Xk6� Y����
�{=q7`�8k��
+���הRA���^�$��(H� (��6
+#�
��8�ghkK��!���:�L5�ZR��t��ٽ�Jj��O�Q���J��wy73j)��5> �
?�m>���"fb�'
ņ���q����d.�����5(I@�31�s6���6c-}Wy�3Y�
^OWKk��*��z/Ԩ�l6K��0��j�O�W�,m
+�U�_l��Bֵ�5��zK�ʩl�V��69��2sײ�d����
�f���[�P룐{��Ȝ�4:�01_ճ�ڳ�e�
+�ҝ��7@ǚ5����{��@!�h��6ڇ]+߳-�Ĵ�d%S������
!Y�� �-m������
��>�‚�����q
�˽J�qޮ�Y�7�1�ܤ�K�ět�n�"N��S3�:5�]��ö�p
���ד?2�P�

�ʨ�
i����FR)�
_�:�CV��e
����4	���ބG����>J�%�f�7��A�m�,��\�K@����JT���w�K��G���x�KW�F5��h�Y)��: �T��bI�U��ܭ����P6�B��l�(b�
�l�c�ү�r��t�q���@9Ք��"�̬b%���N.BM���k���V`2I+���\�)�ym������+�V'�6#)i�����i&��ؖ����϶�|��
 yn7�AʮR��Qn#A�P�xu!$�`�<�[�H
ʮ�k�>*&�*%����D��Ĝl�r���g%z���29�~��H��Ѱ��'�В�8e�꒍G��h�^�������^����3	p,
tY�
�{�
�w�,�l7{5�
s���9�R�?�f����:�-�mH
�V���/�e��S=� �ƻ���_<HҙOn1�o����x���;6��p���ة2
���9�^��m�A;�i�|�ߏ��"������*4��9
�dm	�TdkNL�η_�PZ�M
�| �Z(TF���P~Z�!��x���mi�26�Q��{$u�����2\�^�R5gp��[(���p]M�K�K[
1������N��afuD#;��~����h�8V��*��
mG��,��%H�?�/�*�\�d0I]�WH�â�"8��+�$���S�8D�*���!�v
�����~�	�U�E"D��$2b���]/[�^VP�e�}�
�U�
+��������ٱ���m�E�
���o� �����c�;�3݊1</���fXA�RE����y��o�P6�4�8nU��lR��(��[����8��%� �G<��1w��7�p5e�eYMr��}g�NY����q��D��b����7����P,�F�ͭ!u�~�,��]�~�vRw
{�q_��L�XM���
����ow41���ŷ���uqx�����7������[7	B�S�7
,�������~/��
�"rMw�ͻ����uZ�Et���"
+hUp��j硎�$t�������{6B���Օ��
j����$�j����^�
%��Tb���C��~V�AF�HrIR	;M�iy(�H
��+�
��?+
�J����S��
��
+YDE�9Di���I{�G 
�ڪ�-u֣��
9��o0R?+&�7�l���"ɓU�2i>7����P�
�1��4�����A.�6��"�o��dEp+�	���o'��l����웉d�p�-	-�J�����'�{�h$�ƚ�����|�Cm�7������JgF/���]�>!Z8/t���
TA
�V��6���آ�rP@`�H�U��,EG�
�J��-Ͽ��܊�7]��',>j�2��5�fa���Ĭ�q,�Ƣ�'5�	<�ڡ�.�OdRGNe�磂��B!��������qҊ�f4U"��o�G��=ۿ"Dz�
�9s�"�ٌd*�T�_�"ފ����x‹$���ŹaLY� �OM`U��P뭐�q�D����@�
�:Z֡B��L�����d/$�ސUa�B;��׌'
-A�eA�w�QV�H��Óv%12�K(�h�G$�^8[�����u*�M�1����9~��f��r�:�3�

�F�1vpw�Y���C��w��*$F�6�p}Tjb���
+���Y�E�њ1���?��>
��,�fLX<�H{dz&{�;?��/
��q�(��Y����YMp"�fc��H������5�6�A�=��1�j���w�L
FO6�g��7�o���]� 퀒�_�	n�
�Г��$�Iq`��'�H�����g��▸��D&AQ��9i=D�
�Wqc:�EQ�/�W�
)~2EG�9�c��BY�ͨ���h�-��7�4/-�T�>
+A���;v֢]��$4I���=�"��v�L��
�E١YP��?jf��#i+L�Q�r�u�+�\�m�׭\�^��<�6�$��~�
+qI��p��kQ
$�����
�
w�m���x4�4;W��
�;d6y{N@����]8�V��g�k�H�ml"gL��*<��C�׻��=��)����#o��}����$v=��-9;~��P�o1�P�h��h��*7�"oB��~�A�`�[��{zI]����
��
�=�t�l�g� Ρ[��2:d���pʹ.�S�C}HBq� 	h�pU�Z.���cH��P���b:ٲ5f}R[������e3�������\
+�/@Jz/��d�e��қ�ʂ)ga.�8?_�
+::\_�+�P�V#"?�M�
PSY��)�C�l�&�� �� ~��j���Ww<�V��ϳn
�3/MCm/��j��Q4,�}
�Z�y�0����Z��,}��
+I��fZ�U2s�Nln��k|�q��g��d�F/�Z�4s\-WJ; ��W%h>�3�v�Vˀ�M4��3��q���z�M�;�9�'$�N���.D?�
�z݂}4��A����R�Q޾���D� ˏ
�/׺T�:�(
P�3�~��
�A�ģ�T��Q͜�pt9�_��f-_�n�q�4���I����י1��@��<ZyYv��
f���{�_召g��ș�2��o��t�I\˷A�г����.e̲7lf�o\ZfpK­��7H�qIb='���
+�~�P�
����F#1?k���<=��>L�s��,����%���we�����N�/�X����p�,�Ib��N�Z�q
�7 ��މg��0�D;�[穬���&�m�V��I�:pn$f�Z���Ésc�˛�wB�R���g���Q�{�F$�
+[Z���`>����<:3y�gI�P�[��y�b�`�
+�']%����
�!g�\J}�ܿz>l�7�֦��4�U� /�*��6�=�d at V��QW>
+�	���X�h
�Z+��%Ұ)_3Ǚ�:(.��E�&��
^X at wu�yN�ڢ#�ϊ$�w�?!K�G��IO�2�M��*"˼�yH�GVz��2�s��mW�Q�����3=
R���Tj��
�
+PK�u0�O]�&�Iz�`�R����usf�6����������%�X��8ȇ��34&x�˫��R��UQ�:>�TI�R[ćPp���L�0�,���m�fꎾL]�!��ɋM�YoU�ArG�:9XwJ��?�v
bk��T�
�M+.U�;9D��J)�;���߿p��	�T0V��B��� p0��׈����j%&
ο�t�D�Cc�� �}6el��rnj��a��*�?j�*���Ӧ�@�Mse_
+����a�;S�
7�2�ҐcP�b����x��Lp��
�RUC��x������

\��0��>%���C���+`N~�,�_���Z��{/'�
���v#�1�_6�W/MV�Ҳ�JH��)�� %Y���V�/њ�g!�@[�,�^�ws�\�b<uv�Z��n)�Qi.)� ���
vq�՘��>0K�tWe��P�i��ٶ*�J�{��Y7g_�ckG�L��,� �ߔ�϶c�J��;�7���!�(!R9�س�� ��ש���/�8�!��2=]�u eV��k��#�Ys�53����߉���:�>sb�0/��%�Z�Y��w�se
�#�O<r��&Fb��
�
+�Wh�d��(��2�
�.�>۪���dل��U
+��� �S:�R����n�x�fT��B:����K�B���eHX6�vZ��<�S��'����)'
��-��m0v ��Ϛ�S%�Q��n��I�vCB�[j%�E=�^+
+!�n���7:t�YK�J���?���kA�
+p�c,�pM�R��2�\�y���>τ�� �#�b�ᅼ� �ua.�j_�D>Z�	8�fx���8���|��b���bX��D��'���zf��o۔�~L�=4 n	C���Á�C�*����e���_a�~.��sTѭY�y��)hI�5����Mi�����o�%�#��c/��gJ�xf���<e�� @c_A�2�L�h��\����~�=@�M�B�
B��u�^��~`���
(,
0+���K~6=���I	6dŵ�F���ܒ7�.X"[v��}��mu� ,R��eq{S'��J �l��^(7C�M{V��}[HM}�
;Ԓ�vb� 
�c��pF���\8���
��=A����q�
����	<P
XT̈��1���a1y��*�)��U�[�yn��XB��pp˧�"p��
^��O]�7�G�c�%�����V��>� �MA��=� s�&H�=�
C�2�3Q[Ay)��z�����"TƊ� [...]
+`��C�Oۓ��9��|
6	���X�

_��˃)���&��
�9�Q����t�wK���A��![�}��{�V�	���&�{ct���t��}t�� �Qᚨ���C*+W)=@^�մF��t"Z���Qg 6F���z��1t�g/�o�R���3 �Cu`�r>A�w�f�!��ܤ����f��������&<t9���I�їV)#*0Ǘzx�jCX~�U�3w��\� �Ŷ �����J �T7)���y�T���4=� '�K_>a�C��ώk�C���^rレHze�i�#�����H������sǓ~0�yb	�ZXk�l�f4;2�U��e�'���hfEt0�V+e�U �-�W��%��Oj�U�z��g����n=��Rl
+!�N�:��<f.
�P���j�3�LE��Dr����RzŸ��xlEC<�ܛ���2v��)��,j�R�
:��	8�(�
�t
@Lƕf>�PƐ�Vʢ���4�Y��8���.��:tk�ެ�
#���,u�=�x$
��I ��z�yr�*p,~�7����V��K�fc�V�{

Tm^t늉ˏ����Q��*qv&�����p[�Pk�W �M�r�l��0`�H �&�����J�foYD7�۷B�R�|���F���^�>���rQp*Ii�51-��͊(@���@�Z:�0
:���*H3��P�����&��>���H��λ�!A���w���r'�����h����#�U���Y�� j���4�
�8 �i�{��_4�.�ݮ�F
8\�=l�S��oOҢ�����o��Т56i���(|)(�-�@���_Pw6W
+����x~~
`[���/�t>����F�M����:��&
ˬ:���j�L��,u�Vz[z�6�2/�:̷I6
+.>��;��<\����W��dfBTa��yDT0#��jz�ag]d�棃��S�#�CC�\�y�p��_���x���'�/]��C����x]4�b�'7�յ��
=b�6�=�&p��FR�}lI���q�S��=����������E�J�P�B:>]��/���:z�o%��5#};��x
�{pj�
�Tn�X����T,�	~,�k�����Q�7e��z��1�������1��rI�

��1|Y�W���3����evv��ݞ�U�����2h��r�O�:��RHxN���K0Q��f
"ѥ猈p�k�Q���ʨ	˲�J��AC��(Z��<@/T͵��V�L��q�u��4���e���BB?���ܘ�}w
+��"	<�m�
��X<!��1+��B���`M�+ĥ�
,��%�����w���	�D�x�E+Cp�X�V(�nf���Y�\9�kά�} �E-B��d�jZ~.���}���^s��q~~��C-&�ɛ}X�N����H	|zJ���>��f�p�w˙~Z�*?ag�I�[-��Ig2�J�G�)
�]�J�|񽖒��7^�>�QxB�ViX�/%Zx�>Y�s�O����;#��	�w-��)Bp�Ή}*k����{<V�2�d8�����T%[!�f�mSs�_ n��%,7P7]��5�l=�B�$�}�1���ڀ�ƽ�o��"��dw4݈O	<H�(�.�ߧ�
��Q�i2:��L"]ƎTL���Ϭl؅�3���Q`��32i��6z���
�c�h��C�+0�7������B,nXa�ِ���ڤ��B��E\B�‘�w
���NT��c��� h�?{-9e�֘�7O��
�vsm=Ό�5I
c~�`��c;F
3%���m�TǛ�x�`���� �S�
���u��(�Pa�����L���)|��8-q /w��H��j-T
+sޏ< ; �����[��|�o�'
vN��x� ���j��(n��I�7s�t�O/�9� �+9g>pY�bh�h����C�y���B8Jl���_�:��U��l���7��E�~�
��q��Wd��OuNJ��)��pN��k V�D�3�����q��Bn��{���p1ح�=c]��t:_�
�R;%a;���H��
P$k��!����� �g�c<j�ScS<��MRDm��p���ܯ5�j�{?y���+S�IK�zZ��CQ6�.̼�)]&�7�z
�/�sb�E�%ٵ֝4X�7�#p�|���^��M�Zs��f�,o�����"����tǖ���{�ivq��J6g��U�
�
+K�ڼ$�v w�������o�	X�oI0�\n%*yu�����!�h�1
#P�rO��o�G��a�`t"�����qg(֮��Ɨ�̴u���<�#ܣ��d�S�Xœ�4c��>
+�"�|��CFL�0�.��	�xg~%�[M�"�[�CLc�6��O���RJDo�3�~�F���-�Q�
���Ij���i��-
+���so��������|�дނΐVG�b$
?��G.��+�d9��|�O���^5m����j����fE'޴�� �<{sS{���i&�Ρ��9cENe�ib�;����-v�[���wP�Mv
+IG�U^*3�i(�7��
  �e<s��\�қ#�4�ـ>�zw��!�%#��|;z��CJ^��B�+�2ܾ�?9����k�
	��C�.R�9C��g�*&3ؠ��3�V\?�����tn�B��Q���"��+5o���'c@�	3����x���(,K�����9�B.YΊ�g
+g�XMNп���ʁ��_�����i�51�N�|�t��[s�RV
+�̋�"
��ʜx��m�e�������dt���
%�}-�ZZNt��h�
=��Bt�3eϢ��*6
�j�
PȈj=�,����7n���J�!�5�a��N7��Lzt-t	��b'�����+�����撖�N������暧�*O�nYDI)j�xQޥ�Yl}�'F�И��$�8�kq\��4��
s%�!�ҧFTa	Re%F��x�1�<)�B���	��
�U�Q� va7#�b�I�s(���(�n��րA�!C�
�#���Zݫ��{��מ�
+q���
1���#M
++KY�����Q��(����Y�����G�|�x`�Ս�aw�Ġ�y>]�j�D��Iw&ͼ��
�>��E�)�t57�+o�X�������s��
b	�t����?��|
���,��A�	N09o'sa����I78��[��wΜ��MeT�\�i�Ih�3�¬s(�\= ��mj��=���vkme��WN�p4ʽ݌%�N�}\cRޜMPb��2y�X�m�y��L	��Q
Q��ES�殺2m->yү����|���km��e�}�P$�Ջ���I+?c-#m���w��b,f���YbzV`+��si����N;�J��@��:Y;Ʀ@w�Ɏ��SE﹖\5�YiQO�<r3먇��$���C&���v	 �b��
�����h����������](��ʶ5A�sS���
VrK���+U�L���7�ku���в)�}ɚ�%`��U(x����>�twQ�ʳ�_�P���U9
K΍W�EiEO��s7��cV�=u�z+D{ ��*��k�#C7���
+�lϡ��+�8>b�B<��<
+����I��dt��Xհ�՚��HW@�\n&Z�� �tsKk1�yws���q0�)��r�he��n
�
7���]D�y֞��y�Hp-�Nj>���u��\B4ʬ��Uzk�{��L�$Nڤ�Y7�>��

e�oT%
3U�?I��D�#�O1�{Hg��|��
ݖ�gcj�7]3���gj%��� Xj��b5���Z��b�
 ��B���#pu\X	>�O�H�؍��nf�$��a�l�I��gw�|��J�V��O\

�t!��2�MEM]�����i�bx��Et�&"��f�����k��m��]�����~
�	+_+$��D0��sp���4�B(Xs��d�D�����=��.->v������餯�s����]I�>ì����"�&�Y�g�*FPr'�#	�d_��LJ�F<�V���
*ƶp�W�8x']��/]��Z��Hñ���>��1lfZej9B���4RKB\��s#�qն�c��2ϣP�b���2q�8�N��˹u7.��|�p���|8%.nʯy}_>Ĩ��YJ���]!21�ʪ�	w�%���DŅ&{!�����^9<�� QDat�tf���3�g]���/�2��
WwFT�-J*
��I���,jd�C�� ���j"�{@Q
�d!�9�p�ڸ�l�k5t/s�������T1^�r˅Y6�jC
�8���-1�3����d
��X�yB%
NmGJe,$�MVl\Ƀ�
��i�����*��m4�۸T�u9Vi��`����\�0�3w���ߞS�q2���y�`i:�))~G��C6'S@y3Y*���V�[�����P<��O��	��V��o���7�*P�G
V�#/ºeJ+�Y����O%
+��Xӧخ܋��
+�����b���>��t�
Y�
�G'2z�{�O�о���I��k%���߾��<S�.8<�G��W6���.�
����KW(�t֥v#wf(o�N
坢e��i��
'nw�5��ƍ�+�ݖ�ʱ�7�@K
!;�5^2�sFIV�������>��I�Pm����՜�T2t`wD&05�&��*�	�AT
)��
IF����agZ�
T�3����-–�!γ@$350a���h�W:
+,�d��!���:���Kq�aP��1���9|���)	ZA^���D�S���S
���{8��a�임�{����Ɩ�T�?�o�+�KB''��4숢r&
/z�~�n�#ۆ��]��z��|	]
W
Y
+�����wQJ�
���(t�|��:(�U�XHc�T�.m*��~�I�y�G�S.�|x2�3#*%\$;��WI�c�p���0fΑ*���H�~��q��o(Ӛ�of>iU
+�'�|�F~}��d�G�ٚ��@�|�&_�~p+��s/�Jb����l�.rF�J$*8g���>h~�9�]
��p�%tta�U�d��
j�Q��������G;
Z׳D��6�H�q1����M]m���;���ڑ�
4±~&�
�m7��QjC�Tl0����7}][�������?/��vRb�;��L
�]x~Ĉ�L�G��gF?E��4�QfI�}vl�i�a��,��y����x���:
;J�U��jW�
��tK�Me�
�;0�m��Fߡ%�m*nμt��"��8���S��GOAj(q�(7�}ߪʧ,t$̧T��옠���Ƿ�0�A��kf���m��Kt8�,�&����`����C���eJ�0��M!!�}\���p3[߆7AP�s-�V���'r�g߁���;��SA1��ہM��,��E�ݍ��4�;
�=X����=�6�-�2���P��|f�{g�¨ؐ�C�S`gyN3�����B���98��
b�ߤ��ɣ��v�'�p�̓��̍��ŋ
ƞ�Vt ��@�=��g���y�By�S�*�X��Bv�2�~#���F�V9���%Ƕk�I����2E�K��ڄ©2��ae�ʎ��Ҝ��
X�ε~(��v��
�Gy�����m�y�g"3xF$l�
qҐC�I�D桱���+�,�Q�=���u�ޥ ~��ͱ�o}����f�J���i CGj��Q
+:�<��
5f�>��RM���B(
 |�.�*g8�:Ӥ�ge��l$�:yi at l�'XX�u��
�t
����FD.h��3�ݼO�l�p
Z�j�{|���\�Jy��씶\���X�p��8�c+<���uKMyua�>��_r�ٙ��J-�Hyo�Z���;GX��w�8��cmIm-���u��H�t�ؚ� 
�I%Ȋ��A\�Q
C6��`���}�c4�N�jڤ��]�
^ޕ����"�Er��2�Ѿ����M��E�3��k��/r���P0]��)
]G�sw�Fz�O���P�
�|gr$d�X��}ȱ��(W����
b%6�o
��$tPx�
�'^�!Szc���
+
6ڄ
+!|�t ���ħ��RV��:�Y�!�܈/���NeO��"��2���ޱUnwƥ�����5C7�;�����_���Y�qþ����T�xg
|DF��ֵ�ϳ�R:��u+!��:BV��X�N=P�;������[:�0��)��P Ƿ:5q�Wyd�D���
� ^�BX$�|‰6�<>N�=�6����	*D�G��ws\I�M'3��E����
�[����5cN��~�R���@���ߊ�k��ʐ�����������%(�|��5��A_��ج�Z?�t����8�PЌ�'v�j�~M��ڋ *Ã����k 8=���p�S�����hs[�N�~Nq����S���l̍��>�S0�4p���U�?A���?�]�3V9���rZ{�=_���[��")r�Z�nP6�;f���õy��5+%ᕌ��<�lJ(We\3
�W�
Y#J	��ɜ!T0T����a_�=u�Z�x�D�g�+��^�w�
ܛg��0|	D'h��3p�T��B6�Sa- [...]
+0ČyF�
6�K{�.]{���h`�����;"ސ�K4^�B����tG77�zA�
_1�Vki�
��4ʱ�a��ᬒ�[
+��?�5h2�鲂�p߾��g�v�tG���C at 7h'*�l�;կ
�-vQ��KѮ��·c��������
+
�#�_C������[+��N�!����#��0'����npu�(n��q *�5�/��:�KE+G���N�~Sĭ�J��m�p͊c�u
Ď_�-
qB�
�� /��q�6�;�7�T����}���lR�A�D���T�;�*
P������>I���~*����~ǁ������P�7��r�����f�؀�_G��p��QH�B���ya~S� }���j���ˋ��
/���7�?��r��S�rBb�
+�	�,_%<onXA��@��
�n��?�h5<�c�����qJ|1Ca��T����a��S��0o�
�B�a����ߘ���ʠ
J��
+�Ǎ�U�׌L876�UDg�X80�<��;�Å��Ϭ���_}��A��q�
ַ	
+W:6���3�g�sDdb
�`u��GRMd��{���Hx���I��	<V<��	?�#w�ۅO�cE!	�_

��z&Y�|+7�L�\��DŽ,ua�
����nI\Ъe�)��e�j��d�<87�D�{���

+��`�޵H}���S��d �}vhJ����ǯ�2����)#����� .���ħ��~R�E\����)e� ` �i0X����`���7o�����z(���S�p gX�G
����1�K�	������[�ˌ`١K^m��R��L�\^�@�93.�q��X$���cjȖd������GX���z��M��6�dŷ
%N��6
�E�8�O�]�yeh���e]ԓXG��"X@�R)�L!3<
+��d!Ǩ
ģH�#��$jnn����x�*l�+�2���*&
9��-�����Y3�3�y���� ��"R���
(n'���Iz]ã�՞-�Ў��

�<R%�,e�tpvf���m���ie�d��_t��op at Qk�)��
�3@}������H�!\-2ѡ�4j0�ƼI׵x��e�ѩ�4�0hIF�1�
+���n$J�������D�V�4
�7+���
��:Vk1�q�xC$���,֒G�J
�B_44��1!����4U�V��'8

����!0ubz�1L&`E��?Z��>aF�HB+�{��1/+�o
�s��gc��
��rPu��;m�V;��.8�Q�G^Q�"i)B�O���*���9�<h���h�u�W���-f�V���� �Z�Ra]�r�-���U�m¾
+8�\b��z�UA�Q�	2����ac.�0����^
���q��K0�(����
�ѷ�]	;��o���u,	h�\su6p�Ч<ɈA�t���gp��	����h��J!.�<���[ʅ����}�!
�Ϩ�@��D�F\�\"��`E,��Ř���ٔS�T�����\e!���Mo�EƮ�ǵ��4(|G`�{G� ��ֻ
�X~�I��Ԡ����I��~'��zC��x"�u��;B%7�
�F���
!�
o��B
`��:64^]�0���l���y��=1���@�o
���>¾(ʦ����Ĵa���*���*ǒ��iv�n
g�L���06��Ev
�c�J�H�J*��*��v�1"b��㦲��`U�~�O��G�K��
/�C
��mV"���s (������A�
�:LUeWC�N��TQ�5�3r��爈�#�CN��ۆ!R
A�e5e�"�"ud�g�
+17��'+���K$�J���nU1�
�b�C7��D�OVT��iL@]��{��`2�����
+߲�!�?�8{��ղ��d�������3	�\����$y���A����.��x8C�A
+��d����$!��0;�֊���OVL�%��)�&�9ҁ艫3)��U�	�9����B�
+��A8͊�'�c�QZ�hΊ��X�WŕR��a�&=GkM�̷��@��ۤd`��jp@�L�H�g1u�5�O�\�����eo%̀|ʻоTT
�ؕWq��bq;x>'�����
"*�`+��8��r��"�[�=Ԋ�$:he�y�)��L�Y�shmb
+34Kv�	YQ#y(
��j�d:����0�,��W��ԇP�@�N�,6�E���=>�2Q���5ݟ��/H��^;�v�*�0=[;d�{�5���h ?��,��ST�TЇ
��baAA�|"�"E��
Y��B1Z�Ȑ:��
N
+\�ioRn M$�J����
���oH�>1�l�e���ץ�:޻�`SS
yk��^�#
��4dr�j���:�H��ݎ�����p�z�[z�W
.%
�5��l�/�f���<%'�R��W��xOTK�d i6�^w
�q�
a����*���%\����A2�G�0h~��,�@�ׅJ ��āNM�K �jV���
+�aza��HVL䶆1��.�.v(��
���
�(͵v��-�ob
�,�={��82Y,�l*��D�������ٱd��Z
-}�'�{]8m�><�O�8�r�
.�y�-�|��x³`���ynj��'���DZM�+��"�;��t�˜��^��,��
��㤑�̼��u�������x��yvޜnid�������$S��wͤ�9��:D�y�6,A�KZX�
�����u+U��|��7�`�d`P*_\s�������S'�*BK�ј؏w4X6cj�2lS3������!tE ��.�:�2��w��
����m��}�
�bP:Ѯ��M���I{:�����:�BcNb/������������T�U���"�7�D���:��B���_<��
 /�'+�2
{F��
y���/d\���Rb��
��	�
�'�"j�
��#���l��
��
���.
d�)4d����u �%�q��6��l�I����
ϻ�jJ�9�7-~��5��?�F�כ��'����(W=���SsFX��s�q^�
Y���j�fk=��3������5*�
��aZ��ȳf/��RHp���[��}��嵨?��|C����Ղ���{6�e�߆�)��5}�[�P�J�׈�T������B����V�6b�Pw��u�r��b��
�
+y�U�M�� U����!N��|
� j�ɦ�R��P*����J�CE�z����\��M�RCa�K!Y�!��8�c����矊��}>��O
S�
�<i:�^�ʫ^L��q��j��D�6M����Z�>���U5)��C?Y�ϡ*��bZ��_��
+U����Ryٟ
+p�����<iL$�H�{�6<j*��hXy���Q�=��A��aO�I��VGC�
+y�U���Y�s{�	�^GA(���X�g�sLJ��zE�^_�2n�h�A�
5��v�7l
��I�G5%��A1����A9�i�ڞ�6��5AE�2ŌO�}�+����qp��
�oH=1�zc��D۠jTU�]����ǔ8/�r�$�m��hi��/�ύ�8m7�(/�Š�1�\�3UܮS���y����撐A���֑C�蟱��:���X�N�1�
�o/��
�
m���7li�}j����c�
�E/�-�+�Ƈ��oݚʮ���i�
�*px�D��B��E/�	x�ezC`O
+���fex�.��ݺ!�5eCo}E��ǯ/#�PLf�l�޳���gE�<
H����H��#��j�O���r]W�x�B�"
�C��c��4����}�����>wV�[㔩�ږ��ڹ�n����uAC
�P�֭wV���

N�p����-Zs�
���dbf�a�78
�'r
��˗b�X��
�[>P"��CW=+ꍼ�T��@��gfG�D!��t��9���cC�q!��p]Y�.��a���z��NۧI˦�
���b���'��g��W���)
U�gl`V���� >�m
�	iM%ҟ���jC G��T�.��Y�U�&-�O�6� �9��s�)0AMg{�7	U���)�YʺU��\4�`pV���X"�7�`E�V{տ"���o����a������6�u"�p=�iT9�}T�z��;����N��/v
z!
_"#����o��R����
�v	��,�g��AQ|�t
�,v�P���ll�WԼ�����ݴ��
?h
�
���!�:P0
؂�]�AF�8d�\Ldr�$����o
a�{�af�@��?D 7�< a\$���E���D�. ��ȥ
fRH�R	8+Ŀ&~���?E�X���b&
����o��H����J.1<y%�Ȁ��v���n��C
'p}�
��PH�w"�!��!��Y7]HAz0+��̤
tK�Ubh����ړ$����|��[�p��
l
�j�b3<by�bH�rR�˅�~���{�%B�� ���"����h�?xȆ�vx��ދi�N�`�]Kl��)h�[�c�D���Z��ڽ��v�� ��a�̵ @�4}�#���:d���f�v��

��Y�U�պ�'��
���L��x��}�Ӟ�&psM*���[p��!��} �PD�H:�J��#�X�  ]�F��:�� >����F>
d����(
�KT
A��Yq����X�Vw-��-)��r٧�f���/�C�L���F�*ג��Hu�oR)@��\KV�@y8Wª.�*a/�M��‰ �'g���'q,V��L��`����%L
�yi(������@%&Ⱦ҂�f��>�f��
+mb���dq
3I4.�c�e@�8D3��0�Ò|�tÚD'A��p�Zpg~	
+��1�i�
��6�;q��ŀA6
`V�U1^$�XV�Z$�X�!`xp�-ܱ;P=\���}����> ��c�Yk
�Z~�]apWP�>+s:L�A6��a$M)�+�s k�L�3���@��Wp�tێR�g\Als��L.�`
+�~�Hz�:�ua9o�._•�du+�
�H!��
Q��ߊ��`����
�p$
a
!0�b
r(�_M���1�.+�Q�{*�>�6@���;�
9�ނ��#Ol�k��0�s���0B�%!��~t(���S��^~I�e
��e�	*�Cܳ�9��
+�,f�u��V��3jn 28�
�NAтP�8�L��Z|��p�ۂ� ;h���#���7�=튠��ˠz�mhé��c�N�4/諢�se����T��d�H������������
+��o,&�W��k�]I��b'֚fXL/̢U)|�V��Y놋��>+�b�u7�o�g�9>�=k����}�B���h
�
R8wUJ�a�
m,���{��YK]N��;R�g�v%},p��pS�@���ֶ��$GuO��i[G���'S�tB�$�
V�p"ͨ���y e����S�a�S�Sޒu�n�vHq�
b0�vQ*:
��a6�w,�ɪ8S�e��.��������p^۱�����
t���;,�شq9�8��0�^�� �^H0Xn������M�~t
+�
�U���܈�͑2�W� �qlA��̖䳺g���6�d���7�\��D7�#[��^�N�
Ys�yD@��8���A��ƿ������}
+endstream
endobj
26 0 obj
<</Length 65536>>stream
+���4ӟ���Li1�xգW�^*"
��AH!=OGQ� �>\��n�zeF��Gq��oq����3���7�G��	�F��i��)�<Gf��C���&��6Fˊr �n��#�,���cͰ��HƄj�!c�!�#��c�I���f��p��8�Šf�` vg��m*
M�DyM�l��S�天^�r���Ű|8?Un�{1�M/TH��C����6�g���E��ﮃ�[��LA��ǒޤ�b�����ANh�>�=Zo��Rk��k���
� ��q��Z<�*�^�!�We���T�s���E����`���g%s
æ2)r�jDr�o���h`���g_���
S��7B���+
+���Dpd�OTޭa���|��\T���\�fES�E����x��
Ɂ���i�s�O�
��L�~P�
%�E��)7�v=(DDO���
+��ͼ�+�%�j�Wb��!��+.s#3a\�
�To|T&hU
w�m�o,Bi���|���
+��=0
'��tJ?D���D����<P��
0t<U� ��!s㢐5��
�
zm.�G�MX� �P��*�
+@:;�`�ٖ�K�P���"=��}3A�dqC��V�%�e}
Q�7�o}��Jn�j9� 缶S8�N�'W�^�
ҕ}۸�,Án��� ��ޘB�e����"
�����ة��̹�p�uX"��)�
"�F($��~�(�I�7�z���gI��\-�J�4��n
9&I6��|���|�/e���@
���D�q#�>4�"�9%7�p��^��4���MD�%
��Z����)E7�y�
�j�٧+RC,;X��7��0�%��:
-)�
+|�2TѠ%�B<Iݔk
oZY���Б"�
+Po�L��B��\O����w�Z�yt��O�}�;a���$w�������2��X��@G���"��#
�J�#"�,ac��JL6�06��ͦ��h�!Pk~�J� 8i��a��4�$X4�t`p
+.y�
'��Ũ�Eò�`[t�a��y ��^7��x�C��)mT˱Olȵ-WG*Mn�j�3��Vt��f��nKK��&��ν��I��]`�r"q�W�y�����g����]�2����nD��i��N3�lu���9�S@	;��&�\GU
��A��o�%�C9P�j ��O�W�A�r��6X��
��
��d
���ڧ>�7�2���b��!�t�oe�m�1����)>��TQ���he�n�t�r�JT<�W�5�鎦[�.�`���Uu�n
�kPSu��1���9z7��Ul!���
�7�3�w�>K�'�0{b������2�Ue.�;�VaQ���.Ve\�pi��<6}��0|�DY��N�����%E���z�
.���Cg�J�z��2�
3a5	k��.������
��J�,����+,�"��Ž=�<+��A�u�mGC
+�ynW"#Z�	��Vq�F5���AՍM�Bn
.6 8״
��=4
��
K��U�>ۚ�C�E�t�3�[@����@���'�)r���b
2�I�8!����5���H0�zp{��p��ѡ�xe
#�>ں0	
�\�p��ZB�H�~ͽ���>s�
��/�}���Gʼn<�	r�o(��mTQ�H�bC���!'�a�"m|�x�4�熊�ŏ|�^�1!g�Ʉ;mG��o�4U����C�2����vm�QFA�^��/�>�6%M�'{
+�dL����v��u��$�S_#I�N��ݳ(�HR��Lx82�g�p���BPg:��a�@�c3�p	���8�3US�9L՜_ߐs�A DO��M�@�H���f\��m��x�#�Ɇ�x.>��r
:���e�z�2L |�W�J���y��w!�{m��
j���Y1t�0/||�����.eS�o�.��Sa�Ԗz���
�bO$�uC��,�\/�{�^4��&���hf�z�#�d?�"{i6����հ���nt���|jBTq;Vn���d�8Q�594�<눃����kPhK"��u���/a�x�6��d����RE����=)�e��1���!��hjYxB�L��K>�8�#OI	���TQ
�y��U8�����4lU�ރ������an����1��G;�_ȱ��x��|q����k�z�`w֕*>Tl�g1^b{S���1���~��ΦZ
�)I�
���m�F^=�
:�tĘқ.I�ۮ�*�I�UY��6�D�9��'�mq0VgF4&"����~�Lx
�� 	qs��|�W�p	~�� ,���9-��e���ν m�7���R;
����XG���kbt�����d���
+�T�֐����״F��
_1b[X���<����7
+
o���4�Q��5"ߦ����Ƈ9�uuEn}]�S}��?�Z~��ێf��$\�r��{~�"rv�ቸz#]t��u8��H���4�
�NJ"�;� 
;��R~
kbqK#
����
����D�S�7�F�M�WLD]mH�
+r#M�B�~�x������SR]m*�x��~
�
��j����u��BB��}S�C��
G�NkXZ�l>�2i�/Dsad�j�KV���m����
�����T�׷yk=�ip�/w0+&B;mG�N�����N�I#�C�r{�H慯�!��j�ml��R������/��nV��g�O$̓y���D����MS��f�㗛�M�5
dr
Ľ4�
�5^�����=ѧ�W<d�$H���
=c�t3dƝ
�3���8� =�Sڮ'
H�x
�T)�	��
�kd����&
�
Cȸ��S��\��(�Ցr�zj;i��-Z�pt�g6�D%��_RnQ�&��Hڤ�Ӕ
+n��2�x�+=@�-�,!1�L�Q�%oA�79*o�,cd���R��G�fT��H�\n>�Β_����u���<�6�>������U��/�Q?�.-7�n��m$
��X:�.�ͦ��b
m����؅�
+����^���J%��nÎOi|�Eo��>P�
:�R.nn�%Q����[��=�@��I��h_��]������hM���s�����"Y�I���&�n�����
.�ɹ��LJ,��
Ν��Z���ӧ'��a����"�<�y��##��}���IĐ0�k�'�����Y27�?�rÅ5��t�2�0-[}�qx����,B�����κ��o�5�Ѹ�4dk,ӥۺ�������jwh�Zh{� -+M!����ɴ�j�E��YҼ�����Ӻ0�G@'�j%yg텔�ض�f
9��Q�^�
$�";���r���N��p���
i�#9�ػ@؍qg�����}Fu#5���Pp⤤���s����?
$�B���B�C��9�
�Y�f:ȠB��t�%8.�&���nH>2G4�.��	�_ �	��V3��sV�ZP��8���TGK"�$��5yC#j�
+P�0�E��
+;L
�%Ϫ
��U
�<"�ge���P=+n��޳<��X��&=W�
+�f�(��q���3�d:o6����v(�7{��┑B
遾:N���t ��Z��,�L�I
V����R
��mi*��vy�{F��f���Q�vK>�H	:�x�Y�I���n���戥���p�ݕ���];b�5����
�ܾ�Q����L�`��ȳMA[ᎅ\�a��%7��;
+1 .����l�uxMj� cGFE�o�����
�Z�ӵ���ݼ�w �O7n
���b�u��
�� W����
X�C՟!^� �b6h�A�
?����qgW�Yz�� ���,oE~4`�X���f��32z�z�1d�<w��6 L}x�u�Hmd�=�%��3dDJ��^�����?��g�d{
�	�W�X����I�5�o1Waiݱ�p���{�js�6�{�
�Ò�Ҭ}!��%�6%�
s��I3k٪�7
+�Us7������e
�`�qJ�dh�G%
#���dph�s?��@�gҴ� ���{��4����5�:��w@�����@3_���	a���߹��@{
���
����f5<K�Wuh�a��"��$3U-����gW�.=؁=E����
+}��Bl�Xhx\�u�%n�9��nb�bũ��p.�˒��c���X�FA*'�nB���� �o�p�0Y8T&�r������߸�yK� ���,鰒H��g�Z�y��� Ғ'�ðn ��|V���g�d�Į.O��g�Rߡ](o#�YgM�4j�Һ�J�fT����
k�
B�k7.��Z��R�+ļ�R�خ,�
��+�,�&]aq9��©
+�!�������MN+��`c�=�g��VB���I�]l�+s��*3yA�����	���!��Y��u��i	4j���c%�n �?��(tÀ�
4!�AR�w77@�c��"��k�e�_����KI�=��7>�~w+e��{�F^�C�(�C�
�K!+ؤ~2��VUH�P����Fs(Y�R`��m���� �Kr��ɇ�̳%�l{�	j�E�l���O
Z�(��َ�~��)��gu�ȋ��z/I�
�M�OwfIJ3���
�PK;q�-��?��Kh���!���f���g� �a}�=a����@W�����(N����$��)@Sl�Ƶ^C����dU��X�j�x�#7
���
�v{-?����w�`���Z}�a��5r\�/y�D:n&<���"�J��u%�7��39�u�P-�˽�����͡Ӝ���[��y"
���
3<M�.?�7�w�\����ñ
��t	��!r�z/�ߤآ�l����,�����#r	�m��:�	
�4�{!ٌ�̎�ig�+�)�V�X6m@���󽇩
+n�> �1�ja��
��
�
�b���
�M�;�"�v����m���7����X�C--ݒ������m=(g�� Wb��j^R�{t�78n�Q)R�
���ɥs	��L���ܚ�i%D�gME�W�4��Ѕ��z
XK� <|�k��G�b�O�v����`���ȗ��=c��旒�_/ @ߎ�*
y{�{������Dw�_�q.'�'X8��DRI
'����Yg�l�N{h�Yy��ug������~�Z��Z�|����
z-o�Y� =��$���Z��

])MhC@��ɹj�U��;F�N�~3�hD��⵮�0�#����)���ka
���ӏ�V��@�6�LGU�6&�*@�F���IqU���y�i��L�~��*/�>v�
� iS1�φd-�
j��2s�[���0�x�^�_��7�\�������8
�����
�F���Ƹ���뤐��j�+�!�h�{�:=��ɯ!M� :����)��
�a�̡/����`�lԲ{[
+�m�[_T�՗
jEx�u��5�bV�5�+΄Ê&�n��8s���~���s���^��
d��1Ǟ�
���Z�]���� 9�v7L���U���Y��.�
+e���:����3��{E
��9cQSa���~�&��jF�u)�|�<�����Z�nULO ��`Y&�C-I*�?`1�$#TPI
4��L0"9��"5M�Ѧ�2[% ��ZHD%
�I� ���8ژ{a@)*TіX
�i0ߌG�=���e�.jQ1ru �m_�
��Pj@�P���=Y
��@�dpx���
+�gȫL��o.�C�
K�
�]}s��DvM{?�A���k����u/����V�
�
+�i��v
�YraH�P�T��,u&����¤�*��ɿY�-���k���d`m���Ʌ��ukr�<ԫ~VR����#u�f��q��Xߡ�WJn���c�7 j=˘��k��SU_�&��`of�`����3פo��KP�s,�$���C5�մưp�1!�FØ�{P=�̺݇�
���t�Mô������]y�ρn ����NF�K��	�
(k��ɓ�$���9�ޯ��{��&�~<�>��y��g�L��7��b��NfUѨ%�O�_�ə�-��l1K�~J�[m�j��m �����/g���ߛ~kF��A�/L�{)}P��:�z�e�!��᛹$
c�
�(_@��R`s�
+�j��1H��L����&�Oi17�����f�6$Įۇ]l`��Z~xܤ�a`��ƜoփdηH�|�6bs�lP.�ִ��ծޫ˳!�M{����#|��-�>�co��ؠ
xh�١��mbL��	:-)���P��`n
�U��^��,�wE0Y
hFC�N_��D�s�#�Zp�s
��:݇�a��͡��47�Z��/�t�FD���
+��}{v��G���_z��m�Ã����6��ѕ/�mx�VNg�0
{+d@��K���7������<]�N�z��n<��.�� ����61;�8������]nY���
�3ȳ7���l
�g���8��Z�97s�>ϵ�R��fހ�T7�*�_
+.�g=:z�g��ؙ/�߽
��8��U�3Q�V�M=�5�I^.���$'�,*7j��QsUB�0�%�#��C׺쥖L1�)DR\�B�T�4 5�)�eӾS6�W�^�K!
+�vi�R�
����)a[Uրԧe�����Ԯ��x�� �^�
�p�C��|���2����-֥��T6y)��&k�fXK��[-�cy��w�
Vӊ�H
RFC4+Q�^���WP�풛B[6�CV@*d�ޘB[�PB�߽C9_�k+d��<|C�G��-
پc�n���Q��ȏh��we��XS���39��ʹ�i���8ҍez)�
���4֗�g��W�)�4�0
��3O
aj.s�m�����
i�tc���lk��[�g�Uؙ��5����n��� ��h���W�(�$-�Ձ�����:�Z�u��l
c��:�'�az��1
�ҕ:),f3��������^�W\��Rj�B�k2IY��XK���lF�����RM��Z>r�eV��=w�͇e/d�Gy�5ܒ/7V��4��z5h��r�j�"�ϒ�1�PRʟ�(J����7 �γ
�������
+����GSۦ��3߂��ME㊩~	�0S�Pl�
��n�Z�� �AA��:�JaY�
u %����x�I�����譆�l93�j$_<�6��t�ӷ�ʰ�
Li
�����s4y���0L���v�D��[!r��9�WNz���Ӱ��ڭ峆w��}4��̀�q�ǐ*P�����0��_�Ww��c�ڞ<q�\���:J��gp�����L|��?NȑnE�B�ٖ�i�X�`O5�Z��'ek�"_�335
Y�h�j@>���}����?{�� �ǧz�Z*�su:
!��7�!
�o�� k�s�%�u�L����-�e����v����t��l!<6K꒯�@N�*������B��̟B�s��-3}�3�N�bT���x���F�B��)v��f�/B����L��ݧ��K���P���)��q;�f9
�
���v�ҏ��6��f�[�4ǸD�*����x٤}ȫ�ۇ��Z-J�N-�z/'Y�
�Z��Q��!9��2��K��rTj��3㜭��v�ՙ�΅���5# [...]
cX��V�
k������m׿�%��h~Ӽ^ -����ۚP��BY��}|�A��4��&�wu��4K߮\��Z�
����c�P�Y����7/]C���n���ho �o�Џ^ȀnMF1�-Y
��>{�s"�-�����kip���G����
�F���0i�<9�N^@���{����]��]s(9'}5 �����
>q
+b�5�5Z�޸0��I7�jƍ~[�DZ]%?NJ���-24�O��UHw1��Bg��V5�
�¬nK������@q{��B�R5 at W�*M���O�;��~3#}]Bo�ū=���� "�ygiW��U����
+
��F��J�ʬ�K(/]��
w��MV+��Q�y��c6Aw�=mu�4���
������ʯ�ѳ�rz{�zP�~Ւ���(*�<�ݠz����'IT2���ų�Cɳ�2}x4�M/d Mw`_�џ�:$�P`
2 �
�8��<�Y�V��.�UK&%����o������r�
6�W�l�����m׾A�T�RG�j�2h�87�� ���
���
q��Y �U.�%�')��ڈ�h����sVB2o�E�l at o �Q����-l��5b(W��&�x{/d!�E� 0����m�{�^>鹍f��S���Tc�
��o GгX(�n&Ms����EUQFl�����k4
+�t�M�c����N�_�˞
߀<����� H�jYrȇ[b�
��F��:T�A� �VJȏl��?�u��4O�B���A���
���
�
+,,�px��
����>�I9����)2�
1���^���k$��o��3 �QyE�R:<f�.�g�K*�����BU_#"�<��V1۷�%{`GV
��*Ez�p��^/
+w	|W��#����!W� �`�^@�Q�
G��0ų%�}��j�
�m��S��L�Q�̯�/`'j�։9p8�t�����fF�7^��7D�|Ԇ��
�9e,�U�zX@�uo�;��f
F�w-

Fk�P���n��cOj�n����g��` ��qK�{:j� �(=q��u,�Z�
�����4WۃIK�{wA����o���D&�mP^�V��F��}vR�
��|���M���
�
�},��[p��4"Px�E
���J�Rw$�	���� u%2��
���Z�TH�`W.R�صB��E����W-�կ���9�t���5g������70�iD��2\�Nѕ6@�*ג,�g�9�
�����îݬ��g%�}��� ?�f��M;�8C;�op.��*_1�
�W�V�wμҙTR�t�
Y/cM���
�t��/�Y� �ߏ�N�g�Z��ܯ:��:I*� �J���two͆�W��l�ż��]�/a3� �"����mX���X�_
�]u������#nn���`� ���^O�֋��?
��~��噵�5rx�tQ�(ċ�����=/�շ����ȟ'������NB��o@������e�HMV�c�r��M�+E�,Mq.�q�H������0�)& �pʖ_�)l��K��\�m7UcV�٭5����|R��8�e�����j%e:�X�ݔ�T�w7@�ح���f'{�jA�@b4�4�F����
=�v�y�EgZHhL(Y�6��Ol�yIq��L
���N
�sH"�y��
�	L�#������B�l���!���6��v��0ݫ\�A
t�1�״F�ʔ�-vQ_b�2��x����o��t�Bq�o4̧�>S Nr�0��X�_~1sw��#��}��
��&��xQjO�����}
���喒��W���
��[�1��NS��Hс~y�=4�lw�*�"�h��f�c��T�ָ�C���iP}�i�8.I��f:�ea�t��{u�����%	��y���F�]�]zb'���V���ܠ�(�k���ĤU�HX5����3=+yC���GU�|6���~ik/�29�~�F��:&T��QrF�Ca����7b
�2��
+,���ϗ��.�T�k�j����Ɛ���LH����b�*
B~��D�'Ǐ`8�n̻$
ܑb��fMϼy&�r��N�k��i�#ҴCa\�W�������\��^���'X5�!1��{E��d

�PTe�,O�^,�3u����! ��	z
+6dcy�ǭ?�;���C�_vC+���L`�_��:��'��`��M�#���<�Dgv��j_�H��W�b��)�b��q�XfбkF"R �w+���B&�I��~T/A��S��
72�Wd^ȹ¥�5�SW�$8 Y�iX�]�|h�g�O�?�	*gg=�8< P� Ӫ !kO2����,Ys3$h��+C��.�4F�LNqk�{����5D�RҫgS��K�JپfDk<�e�>�2��ʑ��Rϓ9�t���k�ZJfy�*��)_�pA[���d�.�
+�,�^\��uyǃb]ҽn:�x�X,+���!ؙp�\����)721_��V�>kn*���Y�"�'�}�23i*�	������!A�P
����YL���0Y���i��
+	e�5��j!YJ�� �yjh�3�-y�ؑg%����D�'�b�(YLC���]1[;B�
���bW
eT{-T�W�(
�p��P�r�B�� =�Z��
u�t{�@���6t#��U�;���TQ�w�2�O~���P�L`���q�HyTiQk��
��ا�T��˴�{N��K�
T��!��L����heː�Һ�J�X��7$�1�9��`v$+&�4�Ϸ'2c��ʽ�N��	����%w�<_���1�hN�XH�8y8�(y
�}�_)'�j���,2s�p�
��;%O�Ұ��L;�t���ϟ��2��o�vCGۭ[!
rf6DI��Y���-t	)r:�`	�=�`��=0��9S^~-�u��G���D���S�ﲰ�./�>�o���o)ܤ���li&�,qiL
S��P]�l��M���g�Ϧޞ��Q`fE���-K�ϗ8?�uu���=� �e��T�l�
p��޽JE���T
+e�ೈ5@�c���$[��5@���L5$��TV3�k�$@U(@o��O���S-�屩�19X-�P�rB��Qɚ�^�R�h2U�
�7��.��J���*�$f���)gs��p�?ںоL�U��I
j���n�~3V��Eſ�Ns�
�*4K�N�9cݬ�n�cӕ��iԫVxv��%�$s��Fק�A�cN�8�y=4�ki?�7O�i�
�
6P}J��@6e���o���nz(�>��k�Va�ߐ�
�RO�ȱ�m"�[@��2|\�A��$�Y/��|����[�D���z��2�R�;Ԏ�|@�
+�J_�R*���/����s
U�&m`��lr�S�8����l��UC	�~)7< w��@{���7���]f<��g�;T����ް=�
T=�
+L�Ʌ��KM�
=-_��VQ2�5��v����)����a����D�#vǾ![r�
��K��D��èf1�g}��9,�
�?Ż�4��Ι�qfj)�=�i�WW?�}kJ�_gxb�aC��w�}T?*�ٶ��ڞB㌴�
�����ڡA{՟)�9����ޮ��J'�u����2�&�>�n�E�	��s�(�V���?�VlSS�
ү���z�ϗΏ�

̑�o�w|�B���fE����2���f>�>3����E��\2��˜�w����u(X~�
m���6�|��<��OG�w�mw��><T'j��wL�{u
�C��d�+@�y��!|A����~�&&��چ?��{��7
ֳX5�2�v���?�*$S�wӰ O�	t�
����6�Z�U)��[-Z������PI�mS�M�Y���&�W���_�UKd#٠TX"�{	7��q��y^�V��/�/
yC� 
���fZ<��
+��Qi��QO�ށ��ᯮr_�����u��~�0q�&u�;n��\F��Wq��� �תB����zK(�+�KG��u J+��l�z]�G
�մT���n
/�^��\k`y�^C�M�8�Yi;_W�]6A\��Yi�P��$s��Q�с�fjs� _�^�����u-	���n9i�VL
N�뵯R�.-���ç\U�`�|����!;��4���]�5 �.~�s�\����<�7
+���_G�
֊�^�*Mg��u�Y��Eӫ
H�AӉ��Be
ȇx�M��¤Co����c�ԋ)q��^C�[-�T@��E�M���TQk��x���Hk���1!(n�bC�0h�C�~�kY�:pm����{N�K��g�eB7��vQ�8�.g{�_���C۴�R̴(#���[db�0�l
I��f�(L-��Pe���Jl����,�s�)x�L���H �0r����Z����I:� �<���
�0�
{�a�v���B�0�?#�
�j��
+	��-���эq�
L31��z!X�z3�����V�
h=��񣥪�9��s衰o�
+	7�ZJ
]M����g%�U� ,��.��X˅�f�h6�0a��B
`3�O���
+��V�������
�Y+7������丮�
�?�RϜ���̃x����m�!�k\
��Vs\�(�
��ɵ�����dU��H�}32##�c��v�J�06cwc���Ν�.���+e�b&�A�#d�o�Y�av:�zà�:m��3���{�p�;���֍SF�qV]��7�7]1����(P�,$c�~�Y�C4��7ڈ[�p��v~�ތ�s����y�d�-Q�=�VCF�`Lj�	^�*�l S(\�x��0�����B3nc�w�E��19��XV�����[?���PyL�V�8E]���UW�LI����L/�T9g
�*n�
<~��?
�կ�G~�E����� eӵ.�G���pC��]�(��O���H��L�0�I����j�����I 3��겅�~7"���W>�r��6�g�
,]��4�P�2�z+�
�=|`RI���V��L6�����(�¹��g�
,uhc��}\��M67��Gy��r�a%Ʋ�DO$�C�~�IЬ��$��7
��'�
 ���aֺ���:ŷ�� [...]
�T>R�a>q<7���T���k\�5�w����S���ӗ�D
�ԙ;�{8�w���e�j�\wڅ?�O�	��[8W�+?S�*W��|��!'$�M���Z�6*�JX�v*;7
�JGn
8W��,�oZ5�@��h�u��n*9E��dtAy�O�,䆛'�އq�9���2�V�'��)�����x�[剿zJ��n�Z�������N.�&�V���'_��?��œ�]��:q�� #)ŞI��������c
+/�ꩉ']OfJ>(#�V�tw)yj�}��<oݽi�l��47tl{���w5o���p��%�⨵ʎ��tmM����
1'����O?��&����Gl��R�ſ�O/�
}>�>I�t�_b�

3`_>%G
m~�Qw��
Kz�w�i�o9M{�G�K�o��OO�U�
�a4Ѯ0�M"�iN���~
�~>����:~{G��}z]]2^��i�og#��BB���Kz��:�"m?㷶'��`/��jH�oup��e�'���[��F|�u��������FE�~��J�{@�(�Or�_���(�1IH�3�F]���+@�cJu�%��~N��SL�yRM���|?���R)�x
�S܀�H��=g��zB���x��~��۞j�_��?�_��`��)]�j
�;&���v�Ȕ\�s��� r���[|LnC���W:Ӽ땮�����T:�}�帮4QIu��tD��\�2��W�u
�54���֡��
+�n����1�^���"�{��
�7mn8�%-����v�O�x����.[UM���b�����4g���"����3m��
�ebd��O"�2��-�I�Ć5VpgI���iA���Hd� IE��.n�$T�wNj(�����N��bH��F] ���C���E&ؕ�}<�Ee�i�:��0=k�V:^��d8ࡗ�V`AD$~�oᯖ�}�wY2l
"�yTh��$hN~6����f�/��\u�Ͳ
A�����,h�<��N
RD#<a�Y+äݞI����,#�ea�y�K��S��9�vY
EA�hY��h��;���~�=���.��`��>�Jt�M�6^d��؋�Y��}-D��(b@��#"!8��B�}�%R�_T�HGPt��}C�ӧ8���B����Oܟ
�L�ѽ�cu��~3
�r�#�E>�ˊ���lƽ������w�;Y���E��%A[Iܸb�1ȶ
ƭ��^a�_k��v��ƭ���k�Y��6�O����mDK����Zu�.h�,�
�}�
+����N}4`
�z8i�X�]���y�Ϛ�{���z~��C;L�5�V^�s�qk
ۗgA����8��c�VL�+�:�Ș���,`�w���}�>��
>
+��}�<��8��nB�m�>����p�fcԼU�BQQ�>_]p�z�J}tQ�`���VZ��E�6��ce�:��w�;��������thZ��D�z�
`�d�m8��d��6�2�N�L�����C�����b�%kJ�S�
�S��o-���%*z���6Ѳ���ܾL�,�w�B����:��Olk���95���5�#0~�
+�,��x�F4ߚ���G�v��Cf�1Z�C�$[쇤F�9t�ɢ3�>�6��PW�����Y0��pS�'s��k�
 =��'QY���]�����:�m�)�ˏ+�{a�����Z8M����ɶ麳�.��5
��9��tce��=��M�ڇ�>.2��u:]�O�.8��8�ǯ��o���?���������?|�ӟ��7�����?��/�'����\�l��ͥm����ӂ
�!�+U�ujG
<����
+�r��_���>P���	�
�
�8c5��X�,��#ծH���] ��I	�IV���-mӂ�~��3�I]�9�B[�ko��s�
��!
Cz�l�����%]1�g�c[���p�D!��?tm���> 7�E�����S;��%���-����p��؀�"��9����@�9��y�*$���C|
&tͣ
M{��
�nC�j��
�ڳ+Ԏe6�.,�x
f�P�~�������`u\��m]���
�cowYD��q-�X��}ui(�H�� �L����
+�z�튾
��`�on�SQ�����q�7[�FA)$����E��>���|f=�l/	�3hz�z�5�~�dډj���fӱD���ڢ���`�W���E�v�P��腂��R;V��vb��e��C �
o��z>HخK��.��J�;:�gi�{�}�c����@A�Z$ 
^��A�̵� �B����6	��S���cv�/t�nfN1�W �SM�B{;硊�ñ]Q]�s��Z�y����ZβiG�N�T���۴����͊�������C�T��h�F��ִ
��f��"�*��	`���oY�8�l�J��5^t�s�]*ٱ<;�;
 dk�&74���I�i�\���P�����d��e���&�&��b�1�Y���v!�K��0(!:�
,`,�0jo׌*�Լ���kn~#��K�����,קXր/�(,����;C
+�m%�2x@�͘�2�n{�VG���3�]ۋ}L����W��2
 ��x@�PC��dj�6�`��]v
"�d#7b��
���
 �/��cb��]�.��v��#�����'�7�>�d�f|@��CլEb���4�
eX��%㔪� �co� ��r�
�v[K6c���c��@�L%�i�R�`��M�Ԯ&��4^�4��핤���1��p��^0֦}�>��>�ec@�wv�1c��sI���O�A��G)F_}� 钫tMhB�S��%3�Q��W�\��.YX�T�5�dt}2�k�#��
d�
����㵗��yk��6kwJ�{=K/�r�����vǴ����f�<�K��%�P��'�/y��ϕ*v�q<'A^%uH^�)O��njL��S��%���i�.١���K�)�-�(�]�A��vS�B��]�D[i9o
+&�u%=�r�W��5�֚^3n�|L����Ps��:�yX��)ƛ<t��I
#�9���a�3[o�1`:I��̋�T")r��4*
�8��I�q1g>��;�	r���"��j��H�f�u���=�<�>gt��`����-��q?�6{KYr�y��dO.�H����Z������X$ɪU
���(�w��n��.�'�źP|�boQ��$�i *��w�U)u��~m����TquN<��ݮ�5
�%8��[o��t�8���EB�ͫoC5F��d"�Df
�H;mH]� �y��G�j?D��ZZ�¤C"��D=��D��Mm��ŚqB�S�^liF_����7�g��1�	�_�^��u�ePKvS��0��.
��,JbL�6�
�r�|5�*.í�Ԭ��� p����Rc�ܜ��!x7����]E�5���� IF�r|�fי�$y���,W2��$�˕f"�`�f�����)���R"�?�C�ÈONc�[�ⲑ��`Mͳ�/޵L���Q2~�Au"��6�yH�ht]Ɯ��̲K >vJs�Z�j�>M8x5�vjR�}-S��'�H:!rv�6Z=
W�\��F6_qPCPw"I�ɰ�T"�	I�.&�acv��
��#V�+s�`QM�L���O������xe��I��_`��X)O�jze��2a^3m7}Ĭye߼�t������y!E�+��#��
)�^YK1� [...]
+�k�H �4�����		�V��&N�J0�1I��&�O�Ռ6�x��S���:���]ܟ1I��%u(1�XN;DYK!ó��B� �PU�9���dq��I
ly�&�=c�tQ�k�gg��;��0T�]`n�}�VL�>&4�)Y�by%�iQW�k�#�T����
���qt�b��%�*(��b/��4����Ho�
c<f=+ �-��dQ�*`���e�" 	x�a��`h��M��3q@�<l�
+�F@)c��]9�|�Z�=��5�_J�����Cs@��
+
�|�F5
�B�`(YV��4��;��P�Z���l�N�Lݴ�2�cMW
ᄑ2�K �S�q��`3Np�M�C��L�.v/�&n �d�
G��5mA�kc��Z?����2 ��/U&bO�$$�NC�D+ ���4��
��SU`"��޳e3�Z�:�WK�'�~j��xR���T������~�86
s����1OCij��|�M��N70X;a
bJ�O�dT蔼���� �hRld��J����6�s��HN�� �L1&~WV�/_Y)q}^�Z�L�+��Q�,���
���1k�L�
�X.f��'B��B=Uwt1$�BY��_�#��;����
+*'a�)�*��4(�ۨ# �*�
�bM��6��0�~���+��=�ܲ�dr�ҺפK�5�h�w�
2Ы[��d����Ea��폖�ֿ���Ց{�t7b!��k�V��u��.���1r��D�i^�C�xD�.fU�}�h0���7]Dm��a ��D���z٨t��I�	�,������.��'kd�h
��6mvx����7�}�¤g�;"�m����Ƌ��\�P��a�/��iX�ȒS�T ��2+J���2�ӈ�	�gf7��(	�,�2�5E�-"a�!j��\X�F�s�k��~w��

Q�wO*�
+KI�C)I��%[�{��
���C����܆�Ժ
���4
+6H ��~)E=�f��Ğ��n1~�g}��g����7�ݘf���
B�^�5�ռ��
+*�����m$�@oץ���]`t񓠃$��v,�TH��U�oE�
'/+
�������4���x�D�e
JXY��%��
{�;<��^���j� g'B��祿��rY�93a1��!A�lvw��
1�d�j`�
+b3(i*� S����8��ۭ��W�%P�K�����]�r�4M�e?۟��w�m@���#4,�C���1�f���z?b������
�W�IA\���-��/�]�Z{�U�-���߉�ѻ�2�����<��_�)�}OY���L(n)Э<������
+]�:�EQ锔�
��. ؗ���X	^
�X&�Z/�aĨxy@��u��+��k��ȩPk`&��L��[2��Y*�vp�d�*0�Ѫtn�c�*�t��2��\�]�΍E�.
��
�%['�_dQ_`��R�L����*��.D����|���H��
m�]JATzvX��#���OFՑٯx .�Lv5��#����D��@�kX�����O|O6�3�3){;Nl��q7Ag����W�s,/��k
+�S(4IN�b,�y�>��`%����u���H�^�lb��ܙ���p9� 
,��|��
pc�4CO
��]� a���#��XB�j�w�!
�]�
F���_���
�C�v�w7���0G�S~�M$u`�O?=<��x��W&�%��Ae���i�%�J���#F�q�$�}�Ha A�4����5��+
2�
hA��%`un����љ�k���PT	b\}�MRaxp@���
+����C��z.�Ή%��k삻++<M���f�j�T��+ �Ƥw�|J?2��� eki<O�:�t�R�*|b
gIAP.�2���8C��\&}�0ΐ��5ΊR,i��m�Pׂ'��nM��xٜ埊p�pV�!q�9�R-)h�WX�d͖�tB�ގ�cLM!̰�e2_K����L�
[��f�r"s�y S���z�BoF|�3o�����);̃Ӄ�:f����mH	AW�!T��Qu�*%>o�ױ>�1u��^�h�ˌ��7��Óq��
S�t�`C��
�|��K�󡦥>��"���0Z&�
��|8�aġ#6�V��W(��ƌj�HPl�k��G�R�Y;zБ��%r!���/w`�V}ү���@�W�ʀaVޱ��8�F���B&��y�-��YU�,�!���.��YmPƫKum��'��z]S����/{�
GZȔ,�&mYT��s����Dt�d*B�3۫�
W�G�\�K�>�o���9WzP��x�0�W�#ÆN�B���N�҃�Ƭ�1N18wJ�y:UH/��%
U�R2��j��=@{<7x<��ύW�[o�C�
X;UH�
c'C�麗�Ӆ��~����Yڶ�y�t��
*��yG��"�97U^o
5
�K�͢j�+[�F���	
��6��W�x6��(X�
+�8�G/Un+#��3e�)����
���
2�C�����
	OY�\���&�"7
��E��"�ػj�\į&f=b�a�G��UǶC� �Mk��qT�e@s�0�q1���ԛl��΂ę�r�A[��ް~�WW�
��*�+K�a�.�`I
	ٽ�`.=
.ZH
*�~o$�ˌ�`�l��V�A�{
D%�F�$���7-�-�;Hd��q����_M�j��8�����rJD
�K�i\���
+��X
�6M��C�Qo&�$�*��\-�/��*����~��VD��-Vp[��0@��ֻ��
+��|�@#��[�Ё�I����ا|�Eq$B����7��-
n �"n�e��D�
o�>�?5wJTPnM�T"�F9��Y(pe�
��/��,�#�Z
K�x��|�q'��g�f�Q� �?{�⯴�g�O�HĂ�
)X
T�פ�ve�
+Zgu2{�#܏qT"��D`�w���x�;��m
+U�h;C#,���9�
�EF�aw
)U�v4n]����%�
�(~w۪m$��xQ?R��Ńh�Fz��7ڸ��"�l���r`��A4�
}Q���Շ�1�0��l\z���2^ ��Ә�
��%h�V�@8)�
U��Xͧ
+[�şT��M9.���*!�o�\؄���EvkI�6.l�.B[�n��3���w5��5�7qm��EH��o�蕢������7}%M�6�Y+�ce��b�@3SH�^����s�PL�z�oa~��$B!H�gۼ;Or�qSc
+�2�I�Y�&�
+��j�o
��M9�4I���s���h��a^�׆)�=��֒c��'ָ
�dwN}��9"���Z�����s&��8+�^� >8���U��㘦�a��E"�
��Qx#b>\��%Ϳ1�N�p�J�*Fk[�H�X]<#�9�c֞�n�鷘�#a�fV�$�f�*z���ͺDj
+��R�ҳ���U�A"Ȅ���;�;Q�� y�?6
Ļ�+R��"
+�Z�E��Q�\&�
@
@����*=B���
'�~��ϩw�6n�ӭ���L�v�2�F̀�"�O�UZ;g���;`!l�wb

VM\�r�o��a%��Oڔ7���#x�v�|���H�0�K٨@q���9>�0��,���
+�
�I��tk(YI���"��`|M�B�FV]j��2
ὅa+ԅ�
���{�����(鬧�l(NhKe+3�q@
+������;@�5����3E?2�ƕl
j⚎p���B))��sb�24�� ����P�g�$$ml�д�*�
XEƸ�� �o��<6���ޕ�Hb��\_�5j�u#u�T.N�nda,rY0����
+'�	��TP�ߤr�ύv��)D����
�'8N&�Df�����E���C`�E�۳S�[��",4�A�DNj#=�?k��!�����;�7��N�$�٥�;U(�Lg���(8=����
+^�}���%�v���
�����T�z�k�loAL�k�Â}��g�Ӄ�ɒ�=��L�I�2~+P�=���߲_�]�c�������q"n�Xq�
��W�h}�sEt��$>%���6��x�x�z����`�yL(��[���5
0ȀY,��xG<�a‡
+'Oujz�+
���7lC
�w�<M(�x�L�����k��W($��a��h�isG����K
8����� hb�
/��(��f����>&16>���%g��zRSd���'S�A[��\��mX��K���B��ns�wZY���J7
��" %ҋdhz�q�2�˼�g��[`g��	A�,����υKH����=�(��txZe��`�^���	j��!���Y�E��vA�(
+3��<0�"N�a�Q�L���e%6��
<���P��σ��9<�6�V  �L9����lFR��9�h9,T4�p#�
r���ch��@
˱�
+p;����Q,���f��2���
+p�
=UZc#*q=
�oe j�C [�� �
2�
�:[�K��Բ
E�1W�#P�^.#�o�s;�:U��2m:d��{�A��~�$
���I�7��l��S��Q.
�=�\�`�l�#Tn�+�6O�譔� W�uCk�"���,Jz�f�Б��E4�3�x�����NhJ��]g�'�3�E����˕q��7 �D�Z�9c
�rP����
��������T�rʹ3/��
+�iQ
+�#:F��Y�f$C�R�v��t!M��+֎�-z$LxTF���H�HV�˂	�]�勵:4�X���q{37�%#!6
�L
��\�Y��;*Í�O90�:9������I�x���ɣS��eo���+���ն�L���jd0I��3�=���g9Xv�%F6)	��R
%��Qh�,d��G
�덗i����
��
�l{?짷.-V���sJ<�M�W�kZ��׆��	|���Yn��S JT��u��� Nmf�`�A���z��O��E�x;0J�|ui�-����|���v�ű�̇l���rapqFp�5�Ԇ��
�x��+2Mva'�#"�yr�Ñ*�,Uqt>.��H�ts~�����֥�H��H
+"J'f��@��ƺ��D������!(�4�`d�!�	��-<X��ҭ��1�g�B}�s
`o����\��,?t��mۄ��W#
�M=�bA�Y��"
Ud�
�a ��ڭ�q��
����
��6�C��L�4PM)�+�6�*c4�ۺu�S
�7C�nT��� �>O�ME滔u�c��nY7Y���=
'?�����<���M���ƿ���exsY�\��%.
�Iy��]4=�]��9xc���UU�N�b1��q4J�
����nU~�Q";��G��E���H�t�!���OD�va�/���w�Z��!22�1_��r

\
B
��{9�
+�X��u۶.S
l� ���!<V��=Z$��U���LK�d������J�q���GZ�����߽�b���L��.ɇ
�qsp6��\�N&?M��@�Do2(}&!i���)
+S:��c��_Lg��'
���r�2k"����&楔�ājl��ōV�Sy>?o>
&ҫf�V
"r�U' ���5r�oɒ|��H��#R6��CG�.%���R:
a7nf6���tH̞oN܆��Y@��i�e�5��y�u�e3W��!�Pļ�X+������է�t,�G.Ѣ�b�|HK�=S�4;S�U�4I�֍z�&��`ܪ�y

+
�
���OP��+���������??�������o��~������{z��������e�;����������߿����~��~����?|�w?�����?�ӱ�8��o�����?���$��|�����E��/?�����~��ӟ~������_�͂�py��C���_�
ʊ���?�O���_��Sx�����ߞ���wy�������W��6�4c9�@�fb��	
�W�x˙E�
 ?��B�[��z\��~�GO~��W�f�zzM�Cp�b$X|��a�!U>���%�BX蓉�
���>vگ�>v|>�^�}�{<�~��~do�o���������믿�������~��[\|�N�����
j�����̮��_�b�����IJ����Oc����]�:��v}�u��Tk�u�Σy�LtGa��e�;=|���<����������߾}���?�����n_�a��]l2�?����R%����ǭ��T���} �����J&���	\x��� �<����ۯ�9-m��8F��v��oD% u���(i�(���M�,R=o��έ_g b�b�H��zD骢��С�
�DM�(&������"J;&�0o*��]�a���sd�����EJ�2�
�Rp���4{ŀ�F~o'g_V�dv;3f�ǥ����7�tffD��M� 0�
�  [...]
+�t�RDҺ��~���42�gG���d@�6�8s�s]�lLU
#UDӓQ�Tb[
Dd!�Lb��w�_����2�M�"���YXz���2�(e�Q��-��y�廅�[�r	�����»�oˣ�նA�~c�欜.l�yޙ
"��� :7_`�
~:ԾX�f���Ň3��f����{ae�J@Th�Ѱ<�l�Q>=�ՙ>���zJR�9sT)h
�
��)�Ǭ�}�C���A���X�@x�53����4�H�U`3�e����� <Q&`d�
�����B0�p
�m�Y3;[�X�Q���VuJ>K�'��
^ q�-�r�!�`��~]`]�;QM����K�?O����[Uvw�u3�=ܴg >ԭ)oK��#���*���o��D��\�Uu��Q��� 4
Q��*�Z�:�c�+7
�gξ
�6���"�c�A�i�}&����>$���������jN,CѲ�|ސ�u�HĘ_PN��Q9�ĺyLU�'23�F�f�f>4%��ڸ
6_BPQ���K0�
�#�iY�E
-����چ��<�"�9Cۆ'‡G�7K����ub
u�<_V�ҷ8*c���V�G�@ӷL�G�(�*�
1��tY}
�x�6*
U�
�����|3����3D}���Ն�Gǧ	�e{�.<�˸>mɜ
:�.���\^Ukhs!'�|����$%K����4��F���	��i�!b�6*E�x�C!��)PmV����؏�tB#�25JaX��(�]��'6��2�
���29M5�^�iqP��2]��ZP
E�i�UÐu���1��Y�X�Z����N嗤�X�I=�'��7UsP�(䩙f�,��,X�+��7 ������ixЄ9�Ү1s��>�R-dP�'困����.�۬�Kq$��~
���ʮ�ݛIV��zV�D'�����aqp�q�9X&����̀�#��&�z�gS��)my�L
+�ɪ�]i'��6[ib�!'ba|2���
+d.��.4����9�e
â�l����c�T
+�0ao+����	��n5��v����c/��L�],��c��v�
�.΃�c'��싸]��G>����q;�Fn���f��3e_\2���F��3t��¬�4KW] �#MOZX��nO��)����������*&4Nѷ�a��+��H@׻��PDo�����{Q��9'y�2� 0�X����`&��f̾�g$��E�&m�^������ O]l&�H�qd���hu隞����ۢ#x�'/�,�F�],������آ��I$��;Om�����
��j
���Ę��ݭ=��Go�]
u�����I|?m�?߷Ӗx�>y��[���ƞ�>�]����.q�oG�Z����j�i:kܽ�����ޙR�6Q�HcwA3:<������b�{�vO
+�q(*9-1<47S��O�ҎN\Fċ������)�d��
kr��<��se۩�q]_�v ��1:�R|L� ��6Q�S!A]3ń:
n(bX�m�\tו"%�#Fq%	ݏžI�bI�I�����H
Dz
t��T�F5
շT����Ӎ
+f��kD!N�:�[o�No�A�A�
l�>�/�� }��"��!J�N
OU*���=L��
�ռ+�li�A��2
�9�x�\%�e�خ5àu����]
'��ˆ�������yl�O=h��}"�Z��	��7V5�w�|=V°H�FP�`y�}Ec��\�.��0Δy��0I�ZT7,i��:eI�*�$�E�Q�&
~t�,mU9�-�#�]Fې�7ӫ_�@�m}�_���T�D�
�i"K4�@�Ӯ�:^��.�B�ai<L'�$����t��
|�ae�=�s<����#^I�<-�
+�
G
& �S����>߸S!x���0�L�6��S�V�� ���I�
����
+�nҭ_›�zV$���d
���A_�7�c�4����v	w����o�E޾ӣ���h��c�����3!��p��s�N�[�\o1=g���S��;�̧`��i�@��
��-)tz
+evsE�ɩ��g��2�u�
���w?��
�MĢ���C
+�
y���+I
6�u���<��{��?;�I|�� �o�
j9l׫j�hSO�se�w�� �
ó�u2��&�7ڬ����p�����,�3eF��8xvΣE�
+'���A�á�)?s=v�g�G�G������@��
N;h/
ts
ǣr�y��*y���)�����QƒV�D��<��ʝ�$*�.M�u��k�
�<��
#u�ك��Z{����{<��tغ
�a݃���_�	<:�F�ǐ���0� �P�[(�k��,����C�)X
�M�����>
�w+�l�=��a�`<[��γuz�^Y�g3�l'?������ l�_���
`\Q�'�
+��o)Ȍ�1��'�@#k��d81�&bL���)���4�@��m<�(���~�!��%�'Mc��_����>�k�'ί���޷et��:f0���u|�x�kvc�$UM�L��d�oM���-��u��>_��Cs����^r�'����^5�ƚ�OE˃�]:ޅ)T�
�mZT�(�d+��ȝ�4�Uz�
��Q>�B.q.,��Z-�K/�#�>:C�U`��{��3V�V�>��
%R���
0v�X�
+�e��=�E�x`��1���H�V7����>����5{
tH^X��|�{�ʵ��
x5C��
�
+��,c&��b<[U;���J�g4���
+�E�]���
�ӥ��v`Wx�O��r��q�	��HQ������
<�@
���&�g��z��8-��RP������HY�6b�
+V���m��9�!S���8������}D� )N2v�|@>MJ��i�oRB������
�6���A\=���ч!���z#T��+'��h��u��T�Ԏ��)�D�I�2%�P}Z�bK�r�nNo zZ+�W���u�oӃ7 ��&�����z+VFN*��)�~PN=�-vc�T4
45��=��E�c��5�K?�+ at +������j����rT��o.#}Y��t�v���� 	�
n��t�f�
���$�KU��a��{��ec�͓���)��P����Ex��X�Ji���,O�ͫM��ج�4�
�Du��?
+�*�L���M�
+�

��±��}5�Sꑨ6�Y�N-�%r���̘�X0�c��� 
+�P_����
�E���
?A,F����CFFѥ��E�";�C����_���1�����
+W�������!ah)`���Έ
Yúc�Šf�u�;9�C����o@�p at x�
+z[ݧC_!�0���;AWP9�ûC�ZU�1;I6Ԏ2����-�(�GQ� 
�K"
+iQT�AMF�r�JlZL�M*���g%�,�65-�����}�a�g�)}��ey��F{xb�<�gV�4�3�S���+�s�G#8@�[�N�eIV�Mx�#��ݵGLH
r�^Ɣ�Kw/K]��衤�sm�3�-��fu���<�+�����ެ��i�k�m��g$I��K����T���N��#�Tz�m���S�'*��y�ՠ#���B�c1v�Mx��-٢`�{'��L��_�t���Z�8^�ӵ����P����w��b����m��GY�j�)cM�R)
�,ȝ�)�6��;m�r
�ʥ����hlo~�3&�2)��z�oU��M�����iQ�0[ �[
�g�,s%�J�]Ro$V���㛬f����b��W��n�# +���j�#�k 
�
+U|kRųU��� dtFNA�D Z^
	ԭ�
���~�{8�2L|�
+u��fQ�M����ʈ?�G�"s���V�ed��57&b(��lE���aC�43�
�� ���d��м|s�v�b&��E��,K�"[�R��iۆ+8B�2V��yV��l8��T�?2����v�7=v��2GO�ރk`1|��f�*
3��P�"�3�:p�诸
<)���J0�g+�wp>DC9=�
��9:`��X݌���m�/����
�;c�fߐ7=��n��7W�k�?������+>���.��ţv�Q�7n�mr��;O
��ёKB���8�]�����+vo�����NH�����r!�]٦/��ZK4U�#1@�ݗ
�f.:o#˥��Fp}���7�=����F��~>�p~�x�6T2Mc�m�`�G���yt�g�'w׿��"c2N]<�^J@����=+Х���kH
G��"��?��Ć�Ma���0�'0_�[��Ɵ�
�g"X�����8M"�9����&�|v0v�������د�����-�,����S8���E}���:v�x��ʨU|?F����
�R�/Q��!����3����
�ё�
r�l
���4�-��x�H��ê��t����c_]���/b�p4E����+����4�Qa|�su���ڳ'�D�\Id<a�Io����Ϣ]�����~>P�= �UL֣�aw�V&v�	�Ms	��
k��Jf�j��ֲ������Z��0��
�ة��+ \��@����0�
�K�F��*5���8L��
�*@vP�V�q�u<n�L�<��`x~��|����� ���uW�Z#�h#���f>�P�_�H�h"Nƞt)��]�1�Yz�j:�s���
ހ�'��\�	FTH*��]���6�29qQH�m�6��#��C#���C�?�y

!���,���*�͜�!����M��6�<�@&}����8_d\��U��`e��&��O�]CQ�KvЂ�}�e�(g�Z [...]

š������ۑ@q�(� ��H
a m癷�*겭�
��
Q���h��{�X�+���PUl��Nr'7�m;�{����9��Kk4��sY���s�zd��"
�	�|�ޡ�k
�0F�VNJ�<bx;�fщ�>����вX��;����9�r
w��͎46J��x�ԽC �1E?�=��
�mYUU��
�Q�
+�����\j骂�A'L	�NJQz#B� 4a�����F��=
+%3���G�;%.N� \>�c$U� ��WjV����5i����	c(�
��̤΢�X�C��KՂ��z������͢�Ĩ
`M!�Е�=��p*�-t<a�7˝6����O��M#�#��c�-�H�G��Ģc�'��ݪ�F��lAuzg��l���GF��r4#���ٚ{`��v��b7��d_���O�� l�M֋U����8�U��/�����{��������V��
+��7��s�hp�_�[*l��E�]�h!�8Y!l��d��F����
+��TJ��̊�f. �+?�N׮�$9;Q�c[�o��e+�pgVVfJx̢_G�ʌI23��T��%��̛�3�˂#9Zig��Wi�,g8U�����]�V���g���������y��yJ��V�r�V�b���t�ڋjq��
�bf����w=���Y�O#��
^���Q�hU,�9�,c%��0��
�-ID�"䆞Đ
+�sg��
�I~)��=���"�"�3G��RD���A
��V�^�����#	���9��X���\��Oӹ���ՙgu�7~
�^W.*U�J����˖?UO
��.��t��@$,/*��)F�,���U"���c�u�㌷.��$�\DE΃�sѸ�9���87x��>{��G~zf,`�hng��2z��-�qڢ���et�>���h����+�;��0���fe����s��HV8���̷`�|n�*n�H�o%��sg�(SYU
E��rP�%���/A@"p|�ż�U2U�V|�e�y���!�W��
%�X
>+׉E���Z 쐑����x�\>�^9��cH@�nL;C��	Ulv���Q=��E��䯐k��q���L#.��Q�f�
CLZ��}���
+*�T���M�

++c�w#��J,
%b	������U_���}z�
����,!�����
���w�׉��*02G#
ȓV��
u.|#��p����{;���:�q{�i��?��H����
�������d�2C�?�*n��3��bӎ�Bi�V�Y�����A����K�:K{z��
r���2�
+5���)C@��]A-㱕�Y�V�ӛ+G�YB1�Thn)Пq��B�v���1jC'�.J�
+D� )���|�	�q�����x�țJ���S���S�U
�1�W�Ґ�s�9�x߸y��Ż0^&+���G��GJU ��p�7\Q˗	/M
+����ɯA�w��kl�Z:p�j{PRф�ZS}�u�-v������ՠ�v��=���}ݲ����f��`�v�-�?ep��V���E/�r
�6U�.�q���Ǥ:�w���;�
�mV�BҶF�1%���������f#�B|�*�#Y�#檊{�'g
�A����<�GD.��do�O3���� T��ǹc���(³6B�L�B�xe�-G�7��@"���Pņ�q\�Bd���o]Ez��G/\�����2
+�QðO�"�Ro�">B�6��L�_�|:P{�Z
uF���V
K�`�_:L���S�
FJ~ٕ@_z]o��ڜ��DJ���
*�F�d�:4V�� kM�g�pח^ў��p� ԃNr~�UCw�rg��,��Hb�p5�����T
r�K�^�l��q�C��U�_

+�Q�f�J��/�Y*�u���#�²�(aOG�ޅ���ƻ8���*��d�fe �6�`�!\!�
I̎9X�v���Dg�1�Z��r
+�L��-�"�����ț���Yz�c%=����"��
~�ͲA(��m�S��s`I��
+�	sbd �
�$�,�X�$�6�!�{$�'$��
"�5�PKl�i�V
�����osZ�ll�	����
�)@n&�c�~kM|n���`
+
� * PW&�P�sy
�H^}0�
U��֋Z`�����=Q� ";p}���l���kV�����k#��
+�\��̲cK���Dj�eUE-�vfY^�,�D������^�@dv+���2^��Ř���j����b�E�sx�&��L^@
�C�E(��=",uNz!S7#o7�å�_8��ao���]Z��3����OekC&"ޢ����dag3E�}�T��򜷨M&��jS��6z�ƲT�տ�B��� ���.��
i�YǖA�J7.��8��݅��"�[�E5M�Z��|.B��w�!D��[��2f7}?xh�B����e�]DF���ְE�~�����Y��"f09����x�>X���3����}jZ*�B
X"1���-�O�Z�f�{�R^��|�yU��7%7_��<d�Un�T	��=��U,J�}:F�ˇ��Z"7���M�)o\]E��yq�Ŀ��g��:�z�)��uA�,ڲ��h��$2��z'PHbf:�����
^�U����
谍 D�h����b�/�\W!/?��ҪEL�ӫ��,ȍ0
"
+��� ���^����#_#c�b�9�k0�O�| ��!�p�1�-Ԟu���d�VÌBV�`�E3�%�
���G�x	������7�y�|!�(4zd��
�� jE��
+�F����_l�f-� y�RM6������}�,Ii�<7�U�`��ۣ�
 ;KsdiY�d���l#Q��r`���7��
�h�ږ�n��9^�{�u�,��j9�ɒ#��|�_�C�e.`8W�
iJP��J�r]�L�Y��ƂM��u�%�O˔a�e���n1�a��c����N_4Q����U�
D� ��I'̼Q'-D��g���5��"��
���tж#��� ;�c@9+�@���Y��f@�ˀi�=
�� 8��������8pa�Uk���*��`wip�c��@JZ
�Yp�̫
+UY���쯫
��췤�Z=��Q/o��K������~1��	i���D�/�EC*
5@�}���� 69��3'��U�`���yА뵉�(]�j\	P��Ʀ�}l*�<A� X��
+/7�G�E���h.t���Us�
+K2n�*��2�����V�)�{�����y�>���S�
OyT�������G��LV��`*[�kCpE�m

�R�b
+�3�{�&�7�*���&���������ݓ~ˮ�a�r�X
��Q
�f��|Ӑ1=	'g3[)�p\񴬶.lY*'
+o����k>�g��*�g3��d��̓r���J�"��k���Dr��8��-��܂6QY��Ն�a:����u&�(\�J�rPYA_|I:�)�6���C��xj;%b�/
+`7B1�M���6 L-ܧ:��<P俪D�%@�4�s
�
h}���k��
�}����UD9D~�5�R�ɐ���<�q���t�1%�KL���:) K��d
�h��/���@� ޚhU�"�U����
����f�2��j�d��	
��Q��������D]��Q�e8F�{n��]�R���9��v��%PƊ��x�%��(,'����\͑{��5f�,D���b�s��0+<
Q����(�M�5�t?25��<����b���<��;����JZjAn��J���
������j��Ũ���L�'X���"P^1�-�
�6
��j�Wa����@h��VV������#*��hL�Ԅ�^�`��(�	�4�{���4�����^y
Xa�77U"�?�b�T$�j�!Xp��hN����Z�
���c�b�~�����y��
+F�"L��Hu<l��܊�`���}�C�[�$,����'y�-����C�R�j�[��/�Ҡ��:�����%�(
��E�Ud�S����1����̸<.q��5�r���3׀̃�̓���
=� Pt
'i��]��*s���X��
�ˀ�#����3Q�U��r{����lΛ�y���U��
H@�ݘ9�hCq
�@t {��נ�]bo���9�g[�%�w�߼�l�S���F���T:����)��)~�(�u����f�����@Μ�:�K`?
�]_�q�V#��EƬ�a��C\�5J^�l��J.��L;���܍�GnV�{��ӡsM�Fn��h�<�
On��v����{��ļ��& #�iQ���X^": �Q5�^��y�y�Ա�ǚ�3��h�A�s
�

*�	q�	��^���z��
�y��!�iP
`ܴM/�G��W�B���<�^7t����<���B��L�����啋�$�&��`��
����9/��8|��g
�
+cG��A��Rk��^�h����`�/�ŋ~u�%� ,8�`���g�o��(�+�uW
8i�9�Q{�7OȾ�ϯ9 � �ï�9�@�XF*�g��	� 6�7��+/�� ͽ��yA{>��~��9zŖ��jvF�^����}�uP����&q�fR7���r�IZ�	߆JA�{�n� ѫ��I���ߋ�TA�����
Ox�8�
+1�Y�JP�a����.�4Lk' '�)8�,E��龫<v.
p�
��<V�Ǣ�b#UH�w�"��B�X�x����'�
62��ᅤ����Mۂ�[4�a�R���ܵ���8@���ӷ�����Q�S��0<�M�e�o5_��Pb�5Ȇ��D�ߤVO�?S���u5��hU�d��D���w�j[��w�r��V� �@����� ��u�W�`Ys��B�
���=�@��|J����)t�X�H=�~֘D��EقM��ق��VJ
}��P��pdT
i
�u�
x��[�x�"/�j掀�v�]�̰
��
nP
��b�
��e at u��7ǎ��l��?$\�|ZBI�$x�����i�	$�L�T)V�bD�J̚� ؝��}ڊ����q�aH�ЉN*
e�+7
�:�"�C��q�G5�"���$C7_j^i׭ڸ��|fV:s� ��*��C�l����	��ROTJ��#����d!��
�,��Y��
�x�9Oc�傻��i�/���o��Y]�
�?YFRw�2 <k�� �A��J_���H
V��X�%�	��"
S����
�"ck�_H]`��]e��E8����=�����!S�/
2Z7OƦ�Z �k
�iݸ[1��4e$
��J6p��*~�����vf=���a�X��`;�X
�m��:����wA���Vpz���®�R���b��3���
��"DX���q��Y.
�q@�D&Aa
A
�F��>q��x�JiO�JVxCL
.����+�t#Ï&O=��d��J�!ϋ!��l��Z0�p�y%w�
��X��g46��%�G��d�&U�]tW�z&*v�"�s^&k
+A�0[���&p��/
��G
+Fv��
�E��$s
��*�uN�B3���MQ_�"|ѥ���~O�pQ�dP�Ɔ��?�
� 2x�!�9�"��@Rf1
+#��
Zɏ���Yl>��ZA14����򂀴W_�c�e~�
�ERh��$�
ٞqVw!,�(v(�P낍�_O��e;W`_�}B{�jz�
4�!��"0:x��O���] ������ԩ��/I�3}E�Q���~aRH]�@L� 
+��OX6�.q��"C�bV(�V�u
�B?�*RT��M6��Lg]��B���	�	
�$�G�g[T�i�Z�BC���b�&'v
�)+����z�W>3
+&�oL̨���"��=Xc�e�)�{X�=���VCy��[������܌k�ޭ�mD3A_�ɤr�i&Ute����	�d�@,q��
	|� �8یb�;��CG1��
�T����ڬ�st0��HVx"��`Og<�!��PUI��U��P�o�[	~!U��
��X"�zyf�n�I���|πO,RB��w}E�(�����M�S����
�� �Mv�a���
2WZ��Њ��%Y����6��l
'�"B�1�]��B_�AzK�4/|r�
����b�J,�C�w�؃S��R3�?�B@�4�M���6�<�Vh²�z�$� �0p�'�D���ø�+T�V�׍�
�f25�w&�z
+�P���9�SY�
d�YO�<,,i"L����gcnjFUé
�`!�W��n*��½�{	�1V{0H�
+6>��w=>�����f�?t3[f~(�-LI�BuX5y.���Ƭ�X����iߣE5*N(
R�7�l���¤J.���
 
��tw�Řv�㓏��o"ćS��	�5�U���f�~Df
ޙ�m�jg��G���EH�M`�}#iKG0[�*Fa�d�#;���i��b���mB���TP�T/�?R���ª�&��o�
���b]�\�&�6�
RB/}��!�/�S`�He
A������-whUB7]��k��)~RN�Wj�)#W �%��n��
����n}oچ����ý��{�m^
�=���o�����w=
�=8B/�~g�y�>��y�Ό�Ì~}8�/��G�΃�G������rH�{x��
`�=�M7��6�N��v��pS;���T߆���-w~�o��S��}��
z���.:����߽{�^nmO<i�س*��ǣ��z�i�7�Q=/{j8�����r�	�=�.�7�O�É����9�M�
�a��������0�G^fJ?��l�Q>�ӌ �� [...]
+�}���ț��X
+�%>k��~��H�/�[3+�K<�_}�e�kcf�\ﵨ�?��w�<�_}�ȇ��7_���՘N.��.�\'����w�	I���;5�|^/�uu�z�K�6��|�
v�/t�����(�u�~����e�o
_��C����m��
���N��ǟ��ӟ�.����ޜ��w��(��
Y�y���aV���
��yì�
�9w�J
1�����*]��Ť�[ߌ�������Hu�I,Dmam	���q������)��ܲ�F��-T���#�(����
�Z
J��I�I�����whB�>Y"�ۧ�%
+�s�3�L�ڟ��Ū����Mf{��6��/q�y�Y�'�m�;�w�`�L�MK��xL��,r
�y��񹋗��P�`M�@��’���\�p|*IV�
T>-����X-�<��OwD�Gq
��+��V���	^�H8P���gmJ��[��_��l�HQ�f

�{��J��B��^p��{`�
+#j��.�	I?�Q�Z(\?̮Z��:�_X�A�8V��u-���j��v�dYZ���F��j����.�
�M�F1��R������͗m���
+
"r�v�q#k�Z#tN�y�比PR\mv�ӛ({�&^����ٴ��j�����h�o�V�|}e���Y+�l� :%��\	��O=TT�@�L�d3G�ë��l5O8�V9�A�-	��%ڒ��9h��0�Yl���<����YF���J�᜾И
��4��fY�:k�?������l�y��(���I�\�!�}�]X=o�������f��o'��ym}!l~����Tm ��T AKn��c��8"��P�2U<��
	ȍ�"X����B@>�l|�Mꁄ-D��Z��~;cj#f<��kqX�kѭ����#
AUݍþ}��k��M��EG���`�LȪ\ɰntз�&�
+���&�_�E��H�!+�S�r
�7Q��=*+4J�!�j�D�bgtET��lZЎ��O�C���n�׼��u��
��b���D�K���;�i�5��t�a�t��`��ƾ�xUy!o�5+�
������QR�a
Y�k`i[��p�W2њY��V
%d_���AGs^��Ҽb8�EI��uU�U4�f'P��
+�-�Y)WlM�����6�$P��%�o
+%���1v�'v�^#�K}Q��h�?�d�+4
�I�p�!5��<D�È2A�VQc�9�"V�b���> >��*�dLq/����!�R��^��OK/�\��[�x� ��j���2t�Xi�#�~���?�T�΃m<@���em-�I
v&��Hꯅ�g�?�#=�"���]L���e4�#7���:��mW;�
S��ϠT����W}6U�]��˕<Vqd��NY-Ւy���M*{fv6&
��63oc��+�W�TL
š��CYۖδ�?l�P:ΉE���"SV�ȍ�
@`�9�i����R��Pױݱ!La~�b%�3��ȸK���҄�
S�v̇��X
�g/Y�9XY,�t�D�N� ��a��
�\��3�Bb�X1��Hʯ��Yy��h&�U٢��6�^�n3
-�)��np���G3^+�I���
������O���_��o��_�~�����ڣ�M�\K�����D��Q���V�ϸ�i�$s
z=AU
�yJB�F��V�s�ێE磯�:���o��Ur�^�qY�D�H
P�1�����s��3����EDB��5���-���dU孛������
�&�B���=�Z��QV��9
<�W|�&�"����
��W	-C���Q�>����6����M�.C�裩����>>D
���ˌ���snVA����"E�j�b���a����v�	ǸT�++5��F�Iy4S�H@(����ۡJ�,N�Xt���i�F
�Y��n3r���z�X�*�)�����
n�!�%��D��`�s0z%*�xG��I��`�VⱤ,�UA?hsdd�zޭ�;�|�6�<QQ��ʹY��oL��Ŋ�W�������6����
���;$���M�jUB�F)��8[ [...]
+��\�D��dE.
<2a�V�,l�����&�+�V�pMQ�'G�4:��:�K:o��P.��b����V^���)a�YP��mF8��6AA=>��ř�"��j	M��}Zd���6K6)7���%�����}�&�O��Q6�����q���i�&k->�E��
δc�z��υ�p�P;�ݥ	Q��D1�HI��0�	�R��F
��)BL"��[�Aha�֒��g[sj�ny��ԁ3�#/�1��]����NV���61��i"��򊈴��2�����Q�(�Lv�,� �l{D�%i���v�f�
+��S W��x�L�.c���T������Ls;���ԩg[�;^t��=�6X]d۞�H���&��
��.�[g��@��o���b��Y�:8	�����������.��L�$%N�jߦZ�����h����4�5ѝ"�W-4e�	��H������㉀O��6�~���P�S�a C���g
l��&�b~{�, �ۓ\��:@FB,S�Bxt���+�����Lq�:X��g��`�
�0�����Uwu���sJ�`���,�(��Ίe,.�P?�
n*ݤ�L�ľ��	�p�h�?ߴ�m��v�*-�hI�Cpߏvl�~�YHV��;�kgc�YI��:&@���H�E�(E�9�,bBD��ZB(R>y�
+��|U�@'�n
�p�q�p�߁-t���:A55��Zq�������D"�
g�������b7�:�3�,�8M\(�`��v�Jm��UB�V�M!���$&�����^w�m�2Q���g��"coQ�l�hX
�o�\�Z
���J�G-v+�
�ݮ
F�WlO07
uv/���73��,
���Z�b����
��
�����B 3
+�һd��8���7��
kʞ�������F�5��4����3�������th=[od�fn�EG⟄ �ɂ��AW
e�ևg�i�l�2M�v4��pgm~YHBC�N[
�ɇ�pl,n��]z�Y�c3O�W�LZ�=Pj�
Dw�g�ҭIϭ�s�X3�K�
��;�|7Y|��<E��3>"y��&�4j�
��VθH=|��KSĸ�I��}3+>��yY8(�wd�D#�2�
u�v��-�n�Q��
>>�,=��
���7y)nѱ��.�����D5��u��Q�{w� &�֨�3	U�.Y��Y:�Ᵽ�N��5�p��U��p�)�d=�+	J��`{�	^�v�*M�ņ�(�XT2O�y��B�a7qK�*��_G)Et(���N=fvE�@��+�j/$��x�jA>�l��@�x"
P�[�pv/��xb��ܖ�F;F t{��D�W������G3M�"�Y���Q99�xf���!�C��7%�5s�AI)Ƒ�3a�Nb��.�U�¤K�aN���$\8�Thl��7n�ȳ4
�Cw#�e����Y�Q������
��N���O�~�7�E� ��'š��L�fXa�>7�Q跽?>���:Q<4�	
˼�V�7+.�ha�Q+N�I#f�xU�
+h!+�x��Z7�u��5q��MxR��^�{��X�v�ss��	<�A�4:�C�Դ���0p����ȄX��8�H�~#Y��,1��³[h��Oܴ�ܩ�a�������D���y6
&6�F,��ɪWBV1J���>pRT�G�
C������|��
�IIB
+��v#"nO�Vq$��
끗6i�x� H~�n8�O��s_U��j>��eòU�E�N��P]���`<5�
;3�m�5�7�
k�%��UG�,؋$�qK�+��41��
+�:�PXN����A�V �Y��f�O5�
+X�Ъ������Nn�$��y�<�[hH�E�BR��h��fՌߏ��|o���M
e|���ã��Q�8t��f��͛����	d�.�ɌA�k�=}������%
+Ys�[��%����6X
1C�1j@��Ĥ�-8�J�)Bn~3r��^F�z'�.Yn�]��K��FQ���b�?Z�U-VEX��H��o����oɌ�����
0������z����]Q�����l�IJ�d���Ot��0t
Ph
+з ��81}�ٱEcUf�-�
��|���q�~ 3h .҆R��d\2ܫz���� �фoT��K
�D>&�
�\�{ES���H��JR��U����7/ҼY�'y&����?��%�
xR�Z)���F����� �i�$�n! �Z���t��B��M�"�n(}��Z���(g�
�/�Q6�?nLՌ��@=�f�c����>KZSE�z�O ��K,K*����3�?P�o��7
#����XᘛjM��]�#��duxY��!"�>��Mp�C}���A2���rPT%IR�,A꓀�/�<B�!5 ��a�M�c��=�X^�d@���QL��N��_���'�|��bN{ iu�Ÿ��{��{a�H�ZTƋ��|��Q ���ue��7-Ŀ*�%[����>���b�51r�ŒV�Z��뙍�՟x�	�Tܙ �O�l,�TMe�f���b�BOx@�\[z*�q��\cc���5X>,�ɱ'�k�{���" ��d� 
V\F���!lVJy
=��:�є�\��Xb�f�P��yو�w	�>����IzA�J_��n*X[�=��(e
�2X�CC��O2�@# D0+j���*!#�)ǂ١w����R�e%f�1L�B�����Y@��{�/��W��M	8LgAb� 0����-�3�Ag[��h���C��*���y�^��2G�#��xDheBczs�R�*����T�m
�WM���
+�Bf��V�M���h-�`�ʝa��=�Q����*�bwqb����Sr�R�����3\���oi+�S�K�l�NJ&����j+,�E��u+Jl��V_(
2Z��'���%�&19.[�
V5�P��[���}kdg}CRi�e����
�uq��Y�
�NI�L��bYX6Db��K�e��GH!䖒��©/���*�E�rS���\T1�fD�� b��t�%�j�6�9,�t4+�M#�L�L��Ή�Yj��$WiL*�k'X
\b>wSH'*"X��B"���8�P��uZ`X!��+d
�y8�T�F&�k�*�G��%
�B�u�¾��(���m�,1�n�]�?M]0�b�W:'X�()'���.�� ` ���BZEM"0�j�'��{1&-�B��<
�9�nf�U�;�b-���
N�@v
�K�K�#��[T���J
R�� �~�����HP��A��~�b�Y�#
+],YΨM�,���Ϛ�
[�[�����*�\��Dc��2i���ꛭ�[(h0'3a1����v�:���Bh��XB:[PE7��"V�쵩���lA�J��P��I
)pBƖ�����e���Y�
6�W5��ЖE������xG/񡤽fI����r
�K	�F��I2�����۰�u�7fs��	&=��P�"Q
��4O��K3,S}��GN2r�U�
h�5q	���g��l3�
v�KI��ܚV 3��n���/�48X�� ,�e��a�
�.7W�Բ�4��}
V|R	-��Jd�Qn�@p��#]��Z�}˒UC�4�f�QL
Ԫ��d>��:�M]��
� �A%�MM���Ҙ3��}s��.�إo�7׆�ŕL��
+bT�#�	��!�a�-�BY�H{�
 
6�=��q��E�Eo�,S�7�2E#0��Y=7��e�8���?t�:x�#M��V�'z�U�cg�*�Za��ɕy_�)c?Oħ���M�a<{�&Eƨ����ob* 3���h��`�C�'������W��(v`�MB6㶍�8��
+f�ܭ�J�!q��@���`Rۼ(/]�X�a�ʽP�Z�������	�����'�*A�rX���0���J�T��g
���N�$.=��͒�\��Z��[?V���!�v��]d��?w~�1�d��8tzH��:r������MS�ѫ)Iۢ��?���I�����$�!�2��j��%8�
+
SK�,��l�ό���}�ż#ᢢ��O�x��h�ثл\}a��za��*[g�f�D�//ü
��ZtR��E�U���o�.�	���S�� 
''=�*��]��b��}$R�����*Ml5�N �⠲I�,��\��l�MZW��XC&�+���Y��U �dF|0�UBm��T}�����H�*K~��Yz��f�'z������2�E�m�qXDY,� �@لOQv�`SD��P��U�VCEm�@eQ\@P�%���<�snf��[%�[�191-�̼�7�r�9�y
ٻF�P�yL1�	����m�m���.�� '"�L4Z��0�������.��U�ҔZ$3��v��P�(7��d�;(�h��k	�T㎶�&��u|d�a
 ��-���A!&����/��.�ji�Lj��ʹ��~8����2-�6�e�2BT�F/>��]\�Zs at G� k����	uTr-�~��<��Xմwz��*�N����
k\T���&�|(C�C�lY�%� [...]
U46�����*�+��cnWDᤛ��&�MW��Qu1W@�5+�����D�0J��o�}(
+Bҩa�O�
�׊H��@
+a@|HT��|ŮI��G4�C�a��*[��xȌ%��C\K5��R�b��MĆ7�~��e�We��l��'͋��ͻd�\�#��9�D�J���H �S�)�fxdž�.+2I��z���"#y�Zi�;��/�Urb+�pMLN��
{�ؚc/
�l�;a$��tC�;a�e���jp��٧�!R�_���F0b-�
&(5�&��Tl��L��2WYz't�F�
N�/B�
HI/��A�<S�ue�
�lPe��,��K�]���{Hd�&O���,����N
� GW�����bKں��`��A#`��/�9�XW�c�n�ǒ�"�hI��
F^ZU@�^�)uT��R at p�$h�6
+�=
��[m�#KN@C\g��;]t����eOQ2��j3O�@�]	݅��
+ژ6��4{m 
.���O�*
nr���I����fݍ��n�
+�E,�'�E(�k8{��S�fƍk+��<�
UH-�
�'�MM,�l��d{(�"o�c`#zO�
v��6�UJ�����T���
m?-�K���P
+4�m;lX�/��P�����ۚyi�(2��gW�8���
" �x��E ���H:��q�nP^ch{8��'�
b��(��8n�e��
���H
�۠X���-��p�M�|C�x/�M)��؞�.����2��0�k7!�8��B��bq
�
#�y���� �6A��̙�A�R��,��J�m��9�8i-�] �<�"�B4��9<���	*��d�%=-6,
��!-
*�@6%a�m��8 lU�u���9�ʆ��3dX�O�զ�>Iw�Fښ��B��G�	1M�S��L)	-�'���a.j(��˻G�Zz
+M�tF̢�5Cc�(=:h�P�,
��y;��ގ>�1�mؾI�����0d��V�,L��d���YƱ	\r��)@��))�r�3 �
��6C�L8��uͥ}�")F�X�*H(&

;('�T�#�\*�d�����
+��U@�� e�j�P#v�B^�j�_;B��+`߰���dx�D�̫�S,ޑҢ�e����K�A�z���ƙ}��y�
�	"L������+�@���-�b�L;`Y��pwE K��9o�m��%0�vʢ,�c�DJՁ�B��m��.�|���o{�I��)F���=���s/�����/-_H6�iy�����L�x(���7���3�٩/��R�'�M 
�IH
+�1�3��
�q�Iq$��H�
����F"p4��'
�M��,u~�x��"ɕ���.IM�m�<f������ .!GM�[$�
+2�&#�9/�v7G��s��2M{�nO�e
BR_u��M���6���Y���l��
WL�qȈy�s��@�:�H�
4)���n��U����J����[M;V^IGY�Y�*��b�8N�6;���5��Aq��S����)���\R���@n��J��%]JT.<�m3�^�/W]�˵ͽ���C8>��7(�
�F�[ b�)�	�K�qb����;����
+�x�qH�M8e(�T?l *“���RF�"	Y$�1W�o^�ϫ���.�|��WmQd�#$����/���-?���ȭJ� �žC�����!ɂcC�)�C��������29zp�ʑ��� �,��
���*�e��Α�����T�8
eq;�m:��im}�
���c����ٙ�i)]]s���q�	��
˚m�n�����s #�-���B�5;�t��T���
�3�^"`�K=�]���s�ك)�M�Şj��f�f_�
�������b��9�.���vy1T\�3m!#�^��G�ݩH��j̥q�k9> ScO�lZ�2����K]�9�V��Lv2�waJK  Љ�������������>G�c���R�OHR��Vt�0�2R�wLim)U �Jݬ�e������H'.��|[��@+�N
+�AѕJg�22+��Uؖe�?�⠊Ow�Yq��W
�V9%_����Sqz�U�o�sL�?����n���M�=�LP\RB�'=�s��U s��ܤ H��U��heU�K��v�*`�b��b/k�XI����b$<D��1}lf+�-����s
E�`�c��s��n
�J
AS2�T	s�'D� ����
aX{�J�o��,���#2椝Fl8�m6��Y��FB���-H�h����%=�
�ۇ��5գ%9<������aJ�+�����OrT-��

Xù"{3�~��,�E@(/t�b�B@�m'��q0$�@���Q1Ίp���l��M
[����8��\��Tǜ
+�V�(g�$m�R~)E��V�\���ͬTx�ҕؠK�r$��|Lq�@$�V��	���2�z��`��Fb�
+MɁ�
g�k�6�'M vG~�M��?/VLT�k����p�Tw�@�R���S$�F
g6ʅH�=mx;PV
�Ihio�PJu��0Y� ���
05dSR
+D�� ,#�۬�#c�]�2�IbH73W:>IҨ�)�
�W��D�`�����T�R�
���A]I�@#ӇG�`c�G�1�Rʠ)���)
��(e�]�ND� ��&�
�MB�Lc�
+� ���vT?��������c��[e��qY
Ė�z`�W�(��|V�J���,�.�Q��g�A�ܽE/s:}&`Y吀.����yJ��in1�q�f���� @��,0�Yt����Qr�@��f��y���O�I;U��e�V��n�惣 ��\O6�LV:�J&��9�z }&�!�e3z
R���Ѓ�Am���Q\7\��̑ؓ�Xt���>���E����\�{�QE9
L͆����=�
(R� fC�aH�H�E�DR�\�
��k�y�[B\ *f�8_A^k&a�]��(�Z���rLm�pbYô4��"�aV��?&)b�[5���J��:
��hl7W*�
JC'W*�F�K�a�DL��to`��25F���kP
+��=
 &R��
+&���n0��]r�l��`�H�e�dI�
#�! �Ё GB����
#Rc��
+�UȅѨ:F` ��'�!2��@�.]�L?rL,��
(�x��
iGao �s&�`
+rZ�
!�U
���E>EASu.8va��§��B��$!lW �^i!bM%��� D姸kQ�v� J��,�1�'�}%K1�Ȳ-�gc�� c!� �/+�x>��0D�+a
���!�IP���# ���Q�o+����HHQs�
n�#X��sD=�KG|�)sq���X�K��‰O�6�!�}\��jBź���O(2&
�)�`�~ n"�+�tK���$E��YO-�m���v
tS:��dM��pD,��
p)�O��<�s۠����@�C>%�S>���t1�:Z[-�ω�
�i@�&���
���+�EB���i� �$
p��I׶
���ͭ�bF�c:�d$8�y.ٞ����)�
h7

+2q���y�ij���
`� ύ�X�l�sI�
�7��"�B��mZ�m�S�U�"'%x_��\�U!��V
A��ؚ�,��{����R�(
�i=�%2"�aO��,���q�&'#Y�l���p$�9���	7�U�ؿ&TGe0J�g�+C�S��P�4Ћt�@�h#����cs �"�W�*b�aZ$m�dR�d�x�'�
�J�#y7��YV��8ݼ���x=����Ô��&ѹ"�[����[3 ly[ig�8
o�v)���R���ܜY�
���{���P@�	Q x�.��f�jf&�<?cQi )zS*[�(1�^�
u���F�
,0����"�����L"�ͬ�'
�O��� ;��@�B�7r5{
��1Ӷ-.u�짬�
5#
��ߐ;��dAHdRv���L��.^�Y�f�,4R**mhrM�k �;
+�ULj�]�ږ9ݰ���EEh�l��� !���d�vA͂�5g��E�B����R��8>�@�3",��K�,Fs
h/6
Y jVC�F}�H����	ͪ���n�:q�5�yb��D�I��(0cG���)�K\c��5
!R�)qR�C�i*S��E�l*��I`D���[��{�v�"1A̺>q
͔�u�1�	�v��j��	H�
F��W=��k���/ 2os*�2�Sv9.��I���v.N�`� ��`
��!P6$;��aE��������`V�U�e/
�^KX�C#dB����F�*���.q�%F�)�0D���)��B��:������m�r-(?�&R�R�4�Q�s�� BF*AN���	��c�������\�+�
+HO���DjJ�i̘3Yl,i���f?�7ʅF
+��G.�>M����QqN��S��^��x�=}��T#%��R� EO�
+�FB�)�dƹB*�6���N���K��\���'���
��=��aoK(�S~a*Z�S�a��#��Ӥ�P>��:�ia�A:�"Ñ�'�j5��veU蹰9k��1o�Q�
+�}3xY�&�Ԯ�H�w'(���0}zH"z,��Ɇq
+���I���bzb,1��,�ђ
AO�oҋd4{ʒ��@�і��Eg:|���,lu�M�k��͕�� T򐺮�w�p��^����|L]C�;�`c#�DX[��b��^�Gf
m����*aL[� � ��"��y)fU3��l������m��e�!�@^
L�K�� ��
8�R�O���^��\��l
��gY�b�@�=!��X������5
u�����P�kM�,"�l���8��6� �A׍a0Ӯ�]��l�7���v�r���^���
+
��K�Ce�e����%x�'x�X�q�`�P��2��F*�U�N[R�=B�^,�l��k�*�����ž%�)�"�!��2�Y�^7ր�`�x�D/l�$�N�O�/���ّ�}4��1;h�`�"	����
�\�:
`�^
h�v����s1Oܑ�͓������#�ڎ�|�έ �]`f��d�t��[ו
�:
+Țʯˏ�ö	2W��\�V������B����q(����� ��$�k�/TW���$'	���'d�� M~�̙�Y�H�b�€��y�F�
�	��PX�|�DB�'�@��2����Ƕ���"1�0������JM0���O�2��|E�h���k֜)D�P
+]� �������V�4x[㉑�kKI��촓����b��ݾ�le�z���>�s0,P2P�
�.�
+��H��t=�ari)H!#/��e7��j1'�PK�J.#Yj��N��b[W�TuΡB�R��h*
�h�0|��q����b��a~lc�}n��%���V�nHpC�-i!�V���V��p`$w1����	1�@1(@�0�_�7Y����'%�Ci�����{o ͭObN1'i��%�Q�[yj��:"U�"�Q�j^d��O�wR�Ȏ����F幔߲���hj	��4d�����@`�u
+
>7��jHT��)H$dz~j#J� _�9���a�GB��r`�зG�p
+���$
+�����������V
U��|����5 at l���`�?�0�
��e��9_��
�k	�4���H�d��-�!�i�WV��<ȟO�����e����rSY�ɒ�
�q�f�j�[����a�@ L��
��	p��D�T�s����O^A�$P]7ꂒ�6���g
|}
�Ԗ���K=�G�ΐ
I��P
���Kv�O 
���QrS�C�8�p,#�����!����
�B�bR,�i�v n娀l�d���D�P�Z�
�K/��@��hlO	�yL�H��4�
#"�tpO�J
+
sK-��
O!��\���d:��<�"*��rĄ#��y��͊m<G��6+��V��������s�Ҥl�
+��>B~�X��~7h� �ZR�^h�<�QgL!|��a`	�F��vs@�d���?D�aϯ)�ȵ\�kd3�gU梀h
��m���"T������7�R����D����P���x�m�ٺn�1�p��I��օ"	u��3�);pl;kP�GQ��L�/��
oi�&T'`Z����ڴԁ�ޱ2D���`&g0��1����fNC��ZR�Nx�P:3Ɂ�+K�4�� 1�|c{�Nr@4
߮��"�5�u�
q��U �@�p%�#�F�/ ajK8�
��UJS!s��
�9�@
BU��~H���*�H4[e�:�^�)L�4e)���W%
l?EjfŴ�Y���̝�h�R� �,KB�"�7Pz�|�C�20�V^̶�ж-�3d��@�/�4Ez�+�L�h
DZM�T��o=�#� 
�wV�"2M%��
��῔
#�)U�mӊ���
��T�C�&�2��͊���\?e
c��7fN*J\dק`�Ж5�5�����Ex"M�r��d�Y
+
!�0$ږ��
�y-�n� 9p�tF,6��SF�`�Oq�/A��YHx}�� v
+�^r���w��X�&���[&w6��~A�d)%❶<��B�@]A֚^)BF��a�l�A7v at m�̪�U5y��8��˂��Ь0�M5zb;ˁ�[�nK����$��&�Z�Q�z�&O�˸T>�
��a�F�V=;�
+�p�AYc�%DFm��.U|�Ɛ�g�C銒I3�
���iRU2�Q�q���e��R��)'�Z�#�h��f\d)2-[o��س�76,()nӴ@�@V
��u�!r��w�@f+�M�>N��v�ľ"�Ie�BE1��?JM3��P�O�t��A�S�*�yF�(}���dz:7%%�H��ZZ��
��Z
�ؠ��#����4�D�aa�G_1Ĝ�?�
΂���f2���i�R	���j[ZJ5j)�K�Ie��4�xTe�\��NaA �p������C �n�E��+L�k[1s7em���~E�&�\�t
�q!�����
��D錠"R:(j� ��?WD�4`�����C�Ö�� ]nB�cv4fiJI,$wP��R��"�HN��3�!0�Д�sv�}6��H���R�T�@𪻿���ˀ�s��S���� �T��<`D�"���a�fkK�R*%V2��<e��9 9��\���^: �*c�� �̐<Zy
�)6�&5m%�'ѻ#�c_�ќ����Da;�[.���-��.;Dݡ
���EK�����	(
&|A�M�0��GڑR�,���`5��Y��
1ME�2V�Ms=ӹ�AD�s*�6G�3�����%������ҧ��b渚t�z�ly�`�
��D\,7�
+V3\Qʧ�r�g9s[�
,_.2�B.�b��Q�|�rX�M�%u�
+��i���
;O
K>��YĬZy_�6
U�a?�؈��ȌM�S^U41�R�~���.��n¶SL.Z|���2��$����l��8��
���?
]�Lo�A9
;���K��~+��;�
+�Y�{�`�TK�RS��l/����`�
+�+�fd#��ۉ8TK2 QS�l_)�%G�>D	�Q�2�G;%Nn㓻���X3�"�߲ D�i�G�Őt�5�B<�0OTkN�&1U)IKH�S�����1��]W� y�\2!b��njA�u��~3yx,|q�d)7�t�8H��~��nf�SMA�,��ǥ�Q<(�A���	%��]��M9*�
����F���:�B�䕙�b�ٙ�
9�`}����$E�CxUn��a!�İ&2fK�Z΍}�5��bfJk����O�Ҵ��p�0$h6,�,��"yɴV�R�
�
?K���CR�6�L ^Q����
�����K{����(yQ
}�C��mC��7�
u��!{�L�U��aKu�U�
"q����9��T�+,
+��2
��Q;��7�̆p�j*U�H��CeN�����W ����셰�^˞�&�R���E������XD�æd�{��JX�՞/F�쭶����*RSJ��6/bi^��B΋\�F^�쁫s��E��X=���!�V9.X)1�/-f�I�ŝ�K��js-���%�S��:�
���\�ጤ1D�fW��pe�*.~�F�U�I����1�0
+
	�E����C�
=r��J[�j!Ji!�ɦx�2�T�4mRa��;���y��K�Pr>IQ�S��8�Pq@�e��2���m�����D�Bgy�����]L���>"L�p����q
�����9��o�
K�̀$�\�B��9�/7t���S�� d�RHjO��q(��� ����$mD95��Xm��H�>��1U�e �T�ʴ�l�
+*J;Qy�C�& \.'�$)�
,
�}0��}ME-Cf$
�&��:��*!��Qn�
�SЕ9�v��#�%RFT��E} �'�ϙ������Kצ()3
�zeHu�2\��U�D 0�i�J����Wiv�$
+D,�U@�����c��FC}��E���H�բ���_��)0x
��ںaG/��,
�F��}߼`E�# '��2�)L�K��Ӱ����%�Q2B���H�T1���v$�k ^"�D� �9�&�\���(F�"�T�$2tA�0�ęWt9��X���w�Sas1�-�Y��P��%3�뾛�_̤#5��<�P�S�G�ebI�LKsߛ��P���\��d�5�>����

+��i!�Sl��o�
��
+��DB��_��
&��i����A��)|�;.�e����@j����q,�
+���֋ e
�@�1����*�
��$y�/ٷ�F@������
ݸ뀏Y�� �Z*�Dj��
��7P9&@�b��Ac�
w`�
+�_��L&H��Vf����T|��4o۰y�HUL|��j�� ���&
�
��yp�ɶ����Zd
̢�>�
�!^��L�_F�"�y �w�R:���/ �l�� ���!�S�4
+�w@~���;�`M>)"�	:�*\E���D(�*��W"�P*
S�#u�Kb88{B�MO�ޥ-�[��X��D͡|n�
T`��:M�������S�@���bi�Y�]n���ִwB���fB3n���zf�b4�o+$%�kJ��zc|�ףGx�������A��عl��NvL�"-�۬
+���ʕ=Y�SԵ$k `�G���,��駲6�i����
2ޒJ
+�	:&#
$dS���
+�A;�J��	1�wbƨ�
+;N�J�F)�@��R�Sp�gA�'nx�ѹF�^+f�X��ia�C;��
�"b�Lr��M
@~��>d�JV�W{	��u�Z����0�����(sc�b�N,y+%����>�CB��H0d����X:n��H��hLA^	�:�Crح
���"0�M�V�6Æ
W�~oѕ��y
���h���T7���
+Ѯ���;���x  0�ޒݼ]6��s�
�FC��(�+�
$�U%-D��u%p�#���D�B�)7�lԠy
���$a‡�D�vBjMa��O��F�'���U9Tp}��`�*�Y/�
q�ZQ�Mx��;ԓ\�m.2al�ia�E����5�E�'��$�xe�	�
�T���f<�
B8�"
N�����%��� �ik
+�E*���I��.���<���L�OQ�,#V�1�
�t�
(龜�P���R�;ٲ,$
Pi*��) /�6Fঘ��f��m��1��e�j>�IT�F�'�y<m�\�6����\n�`�+6��I��3��|g�$#z�p;��
w��!��q�m���=��.P���=����@pǦڮ��C�#�s�n

$ 6��b��#��P���dd٦��Iv�+���9L�V�
�$�/�5�|�i�Rx���! �m����0��jgƕ�$R�Z`���,)��-�
+QՏ����6i'#�u
�K1R�� �2DU���/�4�f���� F�͎��45hFq�Lm� 
�!������,�8�d�NI\R�?�=�y���` y�����^@�!���u��KL��o$$K)��:��.
4���*J�
Z�VSF)�*Gn��+1�>[H1O���t�~|����Q��5j��A�/)�{!Up5�pFA�w_ݝ�if_�g������y�*O�*�f�YZ�U�5MІ�5P
e�Ơ�?���T"������I�VJOC�p3�ŶB�r�fٌSf�{ꋔ��m��\���#��M|G�fv�M24ݬ?�5�R.6�� �%��&|���>�󻔁1=��.k'��0���R���EzV[�"!	�		43��
1�=T9�s�JP���X�LeF�C�&������f
t�(~T�<jM��>Ol�}���9G�F]�0s}�y
���  
h6��D$9�'
�t�ȄW�Ii�4&��
_����v�ي=�p�%�e9��6�)��Y�$@aeL�!Z�ρR�b$�s��f�jt�wn�rc�����$�A:�)���T�

+�):�W>�T�[{�K���40�@'���ln&
͔��8ȇ�d	q��+
���4�D�5
+2*�� $'�K�rY��rp���5�u-L4�a�t1���d�š�Š#�3C1.�FE�:�s��&�Zh�����z�C��H�e3���$M��T6	pKhG�G�(jؠ�=
+Nm6dX�5�

�{Ȩ��8���zа���Z�VE����ԧbh�ޗ���
ܧ��*N��N�������_�ow�=lX�!��>l�A}[
��!�G�
R|M�RGϳ��8����Y��l޷߀A��i����}+F�
2��ラ؁V�y�?��K埶��:J~�I�uIRvE�WѮ��EVE��%�����8t�%�87Ւׄ�:��C*
+�Pj$�
͞G�#h��P9��� ������m�"F7�M}g�MLT�U�YpX E�!���J�9raX��$��ܟJ[�/+%�X%l՗r��3��6+���`2��J
��\������N�S�i�"��h����|Ǯf�IC�
�2�.�@I���D��j
�v���X��,�NyI��gȊ1S�6'P1 ��
�7�*�f�b(���m�P�+�	�T�2_� :��E��57�sͶ�{�Z��lu=�P'B$�68�`�&�X�d�}�e%^�9r�'J
>=
$���C�R ��L4%��
+`3e�xR�S*i�<Sr�<X�|x�[�$W�v!�xv�x��������(S�SA��L5�F�pP9d at q�a���
[�=�g�g�yW�Cq2�8~�@��!o)�(۹�.![Jz&n��Hz��^�(����ɲ�?	�TT�uҫ*m���m:�8�e���*�6*8�]��E����r`�N�D|��7�[����� U��0A_C=�5sF�0kGSY�e���(�X�@��j�F��.�a �����c0 4�!_�	
���d7��*Jc
\�IЎJ��
��:��U�O��|��G�UQ�`���en�H��hҲ̺b�
+i2Hত�OH|u@�Bi<�H�!Ywݘ����.��(��3��<3�#�2�,�4�5�v6��J
��:��I2
��MY���#�=����d�=JX���D��j�Qf5�~)� ؂�Y<{B at 1���G��b���c��H�\5���Q�pԩ>�9�W�V�
h==�W�̩G�l�ЊrVHI�ށ$�&���`��
R�]N�P1eH�8v�u�p2oZG�'����zy��*aw$���"s)�h�K[��L�f�
+C0U�v�SZH�m� �*-��*U��!	5��=�,c��`
���26¾�e$",��YA���z9�ܳ��6�����":�  ��c*�t�iły��
�+�Ǘ�O��

@�{!�P5�FfQ�؄̇㲴-�N�)R&Hy��	�҂	2T���ix
�����!��.�S�°�!Y� V
�a�}��M6
�쏉^������*���e��qWm���P-/�|Qׯ�$Y�tף;P��u�ڕ\�kƷL7ɆF
T�I�S@��EsE�h.}�R"Xv�JI��u�{)���'�I�+
N��R���V�DU����|�m>H�)��Pu
nE�Y��2`4'��
Ҫ���VY � /�"���A�
�HA�!2��
+��̾��
(b�/Eʤ�NR�^1���,�8��T�{���Q
+�S4h����=���P�����̹	dM
��T ��gda at e�	D�X��'%,
N�,��"6�ӌ��������#�1rHhn#
�*C�\����o�Kbƒ�'�R!"�^D�h��(�u`�t'-�-||��K��4H3�S�C
"_Q�6$�ڦP�$��5�n3Dy��4€0ī�
!K5�N)���R��|Űd�To
�p�FΥ0�	�D�t}@	>�rmZ�>�d
+���~����S��3K	�*�е��匤�>
N[edR��Gr9�(mm'
��g
	�����v�2T/l(B�
+�CC������=֔��
~4fG�����C�+UC���
�<fI���ZE* �(�R�!A�GqU�̣��B�� �&rru	ꕞ����M]��5i��b�?\�����S�
[G�4���
,� �T�Q옺�E��E�D�E�^󱕒��C �m
G'h�gW�[#�+��N��R�C���
7%#�,�tD i�cˮ"
	��d0�75�m�m�6�7�i�KAF�ܫ1���[}����m���D�8�5��
�~J:!K(&�j&���
��D�8G(�	$�̫�ҍ�
����c ���+��4	$5R7 at .{����
�&2��`��Qj�����`#���

+	5�$�#pp�8 I���"m��x�e�AA����d�,�?~[��u�
��T�����X]�q��
7�2����{f�%
�
�e�n��-�3r�ܙ�/���Agc�����&��_�j
R��.���
$7� ���+�0bR�:� �,��

!��f‰�
q���J�MF`�s��G�q�M��q�x4�m��Qg|I��4v�qe�5{\��9�t���
�Q��/��?H�^<͔MD��V������w���uh/�S�WT�
E���<K!�Gfm%f +Z�>
�4�
�SĠ�U�B	�Ī�LD#/
���ROtnb�Gip� ��gP?�"h�䭅`.{(�TA<�g�B��8��5�N�Y,�X9�"ň��J�	�[�X�
��;ƨd��}&�C��|dh�
�/W)�O}�g��_r��5ǽ�i���m���:�-Q�[�@1��#7��(���Db�
d��
�M�K_����H�#M��-L�l|�N4�X;�����m�R۽
���Mk�F}�*�-�N+�Q#@�7���!�I
"Oy��	g�Vʥ
��R҈PM�
��y��J ̘~ 
�ٚ��z��zV )����%�ޕ��J%K~=fA=�C����e�HY�f���P�l��ھ���
>�2��Z��FG�lN�d�Ecd�
���&%¡$�sY_1�N��ۚx��E(E�����H��
��#�ΐ�}#iA�����������j;mԜLG�+YK21�B��V8�;.Ӯ�%�������T��a
�2'oɦ�- n-bՖ�M��,n
�h����Cw>͵�J���o�fR��v!X�(���As'���!���%F��v�:[v����J���~
��ƮrA��c�蠸
+S���j��
+)a�G����>a�ڠ��y�=�|� �z��Q��]������e�42B㠸�E��2C
.R
S at NF5ui4� ����G�R�D���w��K�LǷ5�M�8N��]�Fd
�X/3=?
�:/"$R
!�&U�^�]�����K�/^��nL��|*�,U��M��,�+aA�|^Hw�&�T�� G	��AXQ��vV��F��
LEϠ�$
BG:����

�]
��"�m*����(������-�
�a
����HFn1�V�Xn�l2̓'���f�@
����DJ]��A�[�����
GcW2%x�
S=['�&+�S�u�͉L��d��2��~|�.p���bQ�3T�T9���C���.��b(�ʽ:Ԙ�g#;��=6�H.��b�|��%�/����� {DJ����!�*T�D6E%�$*9}B�
g�o��,�:��&P�	sM~L�'�y֜$) �F��b5S� |�w��^�L�@�E>�˜�cr9#�,�`�K�Y�6h+�Z�(O��
���� ���4k>.� }����7Y��_�A^��O޸�i�A�z���S�oH�>�&f�
��;D������]�Ħ~0������a [!�
N��26!��X�jNEb�Լi^�!�����N�T��~���[3xH��9O�-[�_}{l�{ؐ#i!U7k�J߫��<��3�QbA�|qߞ�Z�=���8l���=���M(1|��)oB�K5�����!0Z�V��z�4��N۱��'1���-
�{Z�
6��
���R��>y [...]
ݦ�;Wt�����r��(m
'�!=�7ޡ	^�E�a�OK&�d0�_������
r��o��o�������������o�����~��o���4m��RU?H���������&�NU'6�ҽC��o�����m��=[��ۨ��.��
5�C�o���

;y��?��-���3cδ�]���~�~��7�<��'�uy5��ݶ��!m~��WuB�a3o���}�o��B�Ec��q��+���_2e�/����g�Ϻ��Y#�����д��9��w������u�
�g�8�[��pj�1��N
t�7Z�N�ݯ�>{€o���;��ɝ�O���>�7Z�?����V�^3qto���j�x=��fd�/��k�R�����v��=�o����	����Y�����
����l���o�HkڦW�^����3���Z���$�}�F
{�hW������X�/����O�c��
�������J���i��K'��[u���k�d���*������-��;�(�pA�V
Ͼ�����U9g�k��O
NjսW��_6t�?�������mա�q��?>�K�~ݛW4tſ��G������إCu��se�o������ih�����?��/SU�N];�����O�_<b̨Kڝ��E���?�r�qo���:w�|�[2OX�GN�~���
u���z��U?�2U��~RR����g,�e���O���?�y����2~�ө��
+�3/���eKn�<��?��-�t;/>��~`�l������g�_�d�.���&�{���)�����4?_��i=�U�ُ���ۯ-���?��C~ݦ���o�������֥�_���7��7?ڹ��
}~=����}����ۢ�/�C�m�����*9�L{rӞ��w������z�~����'
���
a�s.��������ׯ��@]����<0�Ӊ��
r�M����8#�gu��ն����g�
���ۻa��������{�͓.i����U�i at m�
�`�p��g?:����{Oͭ)_9��I��u۴�捩�s�_1�w�����ya�QԵbV���?ǃf-�wѴ
� w�=�
?�
6t
nZ�IRUݾ
�L<���g�����n�\�C�C�Ι2�O�v��=R׮uU~�o/�t���r]��
��
�,�id����al�<��Ї�ϯ�mٟ�x���.�w�m��e��{��5�}Co>��-��	�y���
RӋ&,Z���i��y���a
Y�譃���|��;��qx��������Fͻ����_ݱ�����;���g^}��Y���bT���}�k}��I���zz팻|��4�
u'£٘�Wmذ�q�w����OK
��;����5�e?��V���[Zͯ[�n���/.
Z_�=e�]k?M^���+��=LӮco]��Cw}������
��q���g�7���Kꩬ��'�ߟԵ�{��'���[�=�|��#�7h����vV��
z{ϑû7<qc�
��ū?Iz��
/�p^��~u��

\���'���{?��ܯ3�^�f2V�Z�ȴ�J�6S��,�uxۊk쒿�qȼ�>��s�rFVX�'���k�`��kv�Xݾ��Z��֝��y��Ֆ�r��e/�]����.�
�W�%���~�{������d�ؿ�ŗ��S�o�9��������/;����77����a�J˶?lrRޠk9�wq��6?=�w~��~�
��ת;��s3���`�•ony���f��w��H?jzJ~
N����uG?}���
�
�uu���qQ�+�[�v��mk�^S�
\
?>�9��~w��r���ǫ�
�ٜ'�����Y����������g6���Q2�s�?�m�~xJ����W-Y�U���MON���g�y��*�7�.�<7�&=j����Z�-w�.�!}�g���L���]�����,;��3*�@�7뙭���[��e`�s�x̓o�9zt窛;�^������c�V~ξ8{������[1����|��z|�陛�sQ�	�mJާ�v���/?���J��u��]�F�	~R���|�/v�5w�}ڄ��K��;���gn�F;]�)O~�����w�����O�u~�����Ի��Q��^��~��ƨhw�S���;�w�
߃}�մ�[I�y$�eN��?��~xZ��k��:P�ĶE�>�}խ�a���b
�ٛ}��ե�kP�9�?�-��ȎU���f���fN��]���aCz��-:��X����u{�^6�3��Uۏ�
�?\���>��%���OLi�5��;���d��a����G���l/�;��陰=����Uw`��̼8YZO [...]
j��>c\�9��x¹�O�7�U�3���K��L�zb"��M����n?XZ�盗Om]h>�Q���
��ҢZ�be��3o�qU�"���5v����v]��	�K�*T����;K+����S[�001�l���'�_K��#f̟;�_�&��N�w����F<{��d|&�k|
-��3��;K:�����ܲPh?c���8�c�=W�C�
t���3��/
+�����0�5f�Xy�Û�}����L��w�co~R\��͏�Ov5�]q��
�<9�"LC~��
o���-҉�]?o��������������QY�����o�*�?���褉~���g���8���w
ƈ��9~���..�����n�i����Ʃ��~~d��
�3p�~7,��|e�޼�VN�?�V:$>}��Q0�q���L�[l�����͹�Gڈ�Տp�ȧ�o�/��\uӊ
{�5�n��[��/
澘���o-���ٰY�̟Է��|��)��VD�_�q��W�_t�7ক�>�����M
�ٖo1/�����+�6���7��)�������w�Mw���%o�[�+�ܝ����a֊���Q7����w0}���i�F�N�;glO��
�6�.�����8�:�E�	>}���]B8��{��'
��������@ဉs�_��ҝc�	y���7u�MK���
�/9�p���v�_l����Q�}r����D\�
р�3&_֦`�y�c��~�ϓ�^Э�؅O��{}џJ�*
zl[:��{����|�+�������ؑ��9p�����:'N�l�K��n^���w�q��W�ߋG߿����
�0���֕SΒ����Mff>�e�Tξ'�:i�ޥ���S
߰���vm����
[v�sx���,9�z�K�
��:�l�g���4���>t5_��«�N��’��l�^�.����>۟�C{��7"��=��ES
۔[[���G��к
�E{��=��T�܌�#���4�L^��|��Mߪ�������V�
��(��3�޼���6�ʞ���p|��a��s�m[�5��Y��d9z�I5���ˮ�2��%+�|��h�G��d��\�'/����;���ԞQ�Z�ת�t������-Z�p�}�<�š
[?=P�yٱ�8��
�y�������zmG��%͸gۆ�׬Y�����w^f���{a|����
�2�wq�ͤ���
�?߻{���
:��9�#�^�~�
�w���]����~�W|��?��JO�k͌�<��ۯ*�ǵ��軟
�
�=�����89w�=O=�|�ȳ�U�����>>|�{4�8�ɚŽ����g׬Yy��"p������طh�q��W_{�__}��
�-������rK��������k��ٽ��[��}���+;��}
޷{���G~����u"���{�}��9�~������κ���_c/,:v���s��
�\�)�z�}o,�0_�ٓ��w�9�K
�7.�w
�=��Ж���n����莗��|9�Mz��u{߼oX�q����o�ϋ��rz۬���uՎ�y,���]k�<(�;�M��o�s��������ޫ����M�ؑ��-�<��Ts�[���l��f}���������G//
un�Oi�c����xd�ڥ�/ʼR��۟����W9~�z鴚(s���W?�F*;�g�sw]{������S���&*;���UKg^Z�7��zM[���}_s�?����Y[��=�������ƃ�nY��]���YT��>��g�������{��vɍWt�*�
MZ�����{��W;r`��7�_����ן!�����
�|���v�о���܃��ע�������U�����v8�oxm�7����p�MZ���W6|�{��� [...]
+�J\�r�����*$����T
!�j2�w&uYo�v��K���R˔�
�����.�l��~��-
�}������=��9ǒ|,�p���e$
+�2�!]g_	�jA�
BI�a��07
+��$
0�	(���\-d[B
#���-�
!յ��U��e��%�hA�ac^#;�)&�7(�k$�I�#���TY��PK4=�$��
+O�
���T~
��v��J�Lx+'�����;*H(��6��`vSbs�D��!��8�I
\h�m��ORYl0 P�
+w$�|�E#@oA��H���K
'���ؐ��V�̶�>!(Ý
+�G���B&��pݴ\D� Op!�
�W��D�n�v�?xP�*F�
��8��ՙ{ca�J�X��A%"_E��
�
�.j���"�w������DU1��s�;	�	؁|0���
��<�4& ��l��PV�:@z��̪�ɡ�z
+�Sl��r�s\��Q(��3�F[F� �����<_%�
��$_Tx{H���S���7����a�l\QD�@UA�(\�dF�Ps��&��B\���U�p�L��X<�)�p�r˴����{�L�XJ�,�-]!��;�Ɔ
tq"�
��d|�{ǁ"
+ޗ���ؙB�5 .�D�-Ȭ�Q)e

��tl&σ?�2'�b��
zl�>1��=ec/���,�?�
2_�`�O��}�
+����|	a1\K6U�:V�
+��Z�VYcaVJ�h��D�V��1��UBa9N����
+��ע�F
��Dž��CBl�q:w�YV(�L�5ltT#��e&��� OOJ���I�
+ӏ ͖�Fv:{@~E������–%�M�h�Q6G��
%+��1N�
Yxd�rUġ�
���
��I��0�'�D�T���Y��A�XQ��~uB�Ja�#eS�eapD��
+,��p.��B�����E� 
/����ŧ�A��4���F?��о|��L��4
Q�$
+<vu*.J�Z���)���-����P�$���߁��_��x�(G_
�8��?��>�]^�
Z
����8s�;�����g�
f-
]_Q�G�����ا�N��{�O�
�]}��^�uEᢙs�
�g��~�q�oωWדW�EG�1#Z
+�|
Wt��-��Xwy�s��
+�:I�r�ت
��
���уOȹ�����*Ni(�E�s�s�I�(h��#�繇v���@�]�J�_���>�r`�ά��)��i���+� P|j���L��:;C�s�͓wj}��v
\�w>?}ɳ�,Y:����K�O��{
��>�橫�ߧ

Y�.��f�5��ӒM;V�+
+m�
����4y��	Z�{���7�Nk�կ4�C��7��C���O��޺&����3wU
�e�r��;PW����].�X~E���w]�����uu����i��zFc���:]1��
���n�u�ߺNWO
W�]O,������n���o�o�]�Dt�K�꿇�z���9�߆�u;pa�#���˗�k���lw�g� �6
�Z2P��b����?��`�����
}y�����\���(����{n��{�X�4�4��y�m����&Yh ��'^��V�eŁ�O�����CkFɿN�<��)��}�����0�koݡU��
�쬫[�:�f#��2���c����w�g%�u
�X{���
H�9%�r�R<q��c'�SWW�u���ݒ
uu�>����!�~��:vݞ���?z<.�Ľˤ�}I��$ſo��Vw�[G�<�!i��[kxaPR8�ݺ�ϡq[v?�\дF��MuG_
�Ե���W��Lz�������
LGͻ�w㶺��<�h޷'
+��t���kx��G]n�.��rq��%��ރ�
�w�mgƼYW�s� ;���k��u�C�|�[8/C�|��������"g]8e����	�����X���-�Uw�%�ӧ_�pfw����i��v_�~���6�p�����Z*s]�9w��{�f_T(\��4~��=�
��p�n�t9k��w�S<��.��{��{>.��Ъ���{r��u���Μp��j�g�=�s���%���������M>d��2ϼƅs����ȵ8�݇����>¤�����
��
oһ.�sS�a�^/�}|k�v
�xoF�{��M���~��I;_���9wK���(3���ۺ���s�̮�.��v7W�;���it�7��W��m��\Cn��"��^;�zCҫ�F������v���+z��Ȅ�����%S����
���?���u�ֺ�ݯ��M���=�qZa����m}�_��˃�+�w
��H�v��W\05Y���4>��¬��������p
�ygݘ�?*�U�{l��73���%ᢛ�
�<�^Rwt���s?�
f����}
+��*���x�L���
^������uAݞ%�:�̓�*>�\��8�c�.���w���77��c�7�5lW\�����:���H���i�|��u��
j$���W�([��*>Kt��]�l���f/���'����j��.ZR:6p||��
6��F�2?{>�U�}}#�"��͌�.����X
\K:�I7��1�X��rA���q��O� ��[�J��c��<!����k\PzAr�7���R�*9�k��˳p���˞[����o�X�����.�~t�/�䵫
y��k�1f�����o���8뗎�v.W�h8
w�냦

�Z�  _+!G�j�vl!R���	D�D"¨��(S��q_�(�D�L��&��D+B
+\��D����PQ��"��Ѣ�j�7=�t��A�O�
Q@��:��(�X�DI�ȁ�)��hJC�Ϫ�E�Eb�x�E4��?Ȫ�*LJ��,by� ��[��
�$����8!���Oi
D	"X��%6 at G��� ^9���
���C_�!Ie"8 �D�
+�IZ5yf�
P�
�T�G{#�	��j����>0T�J6&B"����b���H���5R+�"� RZqlT"�~�����)E$BZ���ZHId[�)�W�Q�Pt�����D�Ho$_L�)�`Ry�y��#Od��
+�YE�'d�2D�PBL�R�&����vBX�����Л�U6 �X���*a��Y�Ԛ���� �1�8�%��VS=�1��sP�\��
�4�쉥=0��f��~�
��F(8�|�� ��c)���(� m
qZ
�	�wpUTT�F�em���x�G�?i�P�m-�Jk�Ȁ��
+��5*��t��T�,Dx�8pT垱7.P
s���踈`��ۧ!4
��AuI�
+ħ�
4ՠ�ʇ6T�@Q�I
�ÜB^D�P'�|NS�ㄬ��W.����0����Ȋ��'��g�|�L*�Cm4i��*��A�J�Ր���[�>Q��w���f��&]*�9 C�<��W�c��J9vvU29�.\�)
+D�邏B�U �hzj��ƌ�X�8ң�&�s at T8P�����	"W�`>wU�Qo��ǂ��έ��a"�NU�j*�B�9�Su�X��e@ߥ$4Dd�`:�"�IL@����BwO�}�(
+� 
���J����@�1&g��l�THm��՛,
�}��a:9��Zn�t0Ǡw�锼�4�KDM2��|X?�BG��)F,ϣ�
$W���������RG*9�SzДeSVH��������h5BHƘL�2��c(/AUʿ5
F�Imbkڃ!ž�B�c�9
�R�|Ǵ�Jo3�-�E>G

(/�.�8!�Cߒ�H��DJ�R��T0\1U�m�@����+I��A���� Ml�i"�����"�4f��h
�
h�P�Y���0�� r��A��d�s����
&�y��
��ဗ߀H9m��%����*�(2d������B�I��m�ԹH'F�X"����=E	�A*.
�z
�hӄ��7F�NDU�@7Q�B2K�)p �*~J�I���>	���@HO49#�0
+�
���-��^�%�mIJ�w�hM������4�d��ޒ4%
+endstream
endobj
27 0 obj
<</Length 65536>>stream
+G�HW�PKJLTʤ���g���BS
����h\�����U�b�7�e�� �%}O�Y$�D��c2?ڔ&W�rh@�
+���Kw�L�@
+.$ȭ�!�RE0L�s��F�dh����h��*@4��"�BdJT�`�Z���ԓ�� �+Nr�@��}#v/iy_
W-դGX5�����ރ�tK��NbA�T�C�5���m<�ˆTl�Y��E*J+�,�LQ�Ԑ� ��I/3�P�EC.�;��D�8�A�P|]Ē\
Ў���l)"�"�7MƋ�^hP�m(�J~�.n�SE�N�K����s
PWr��3�Rb"$�m��rI��&��Nr�(����&?!�Y���^R	z�hz� �J0G&���6]

�D����=Ni�,�92����(.S���s)
dQ��)�*��|n��˜<�M_�n��"���RaM�R����lA�T
RI.��[�l�|��9���e���
_ue���Hī{#�i�t��M/�prs_
AO�&����09�~g�*
U�)��T�`q
��q3�^�
�X�!VH�%L������UT �H}G���>��Y_��
 q�|R���*dB���U��5�(�

o2��_9@�-�ph�(�XC��"�vW��k^��"���+B�Y��ݰ|z�"3@\D�TO�6����='�(��ϳ�_���H�1�h�L&S��bW� bq���[p
@1�Į�����n��J)�.����L�v��M�"*WA0�#ڋ���Χ��+ҙ2v�9uOQlt�k,ed�m��\>����M1śf�U*b���ʺ >
+�/॑�ALI�*͍������ ��N�����Y�	��]
}�	sj�j\%���~h
�M�! At��;F����/O�K
�Q�ZN�g��z]�@e}�z�����:�1`��:O at _TfiLx����,�Qd�υ9
�6;�lD�ѽ�
p���5���X������L��́��O����3��qCE"W.��+y�U�*z��:H`�*�.A�.�a��	�a�YcW��G�T ��GS���P�Ŕ���`��C�
���K�� �w7��t�%S
�i
~�X7:�*�Nuߋ�3��7Q��ː�������6����
�oۢ�|b�E0-�R&;��
��A����M4�d����J,�L�u�_Тc��
����P�Y]G&~��!)� Ҧ.�b_=�.���)�^�!��#+���\m�y �]AMh
� �6Ҷ
+���wL����
�*3V�*,�|o2�)��+#�邾�OGn�B��o�ɗ�d��d
�� �oq�Q7�ϴ�O���d�(@֨Șz
�B��U!pv'&�ڑ�\VD3�8g�$Eq'��<2���	7�L�8�y>�ꢋ�1�C{r[Eu���
�+���c���r����dmr�GmL\���/��!"�bB�4����k|�XC�:,�b��a��ʡ��v�Vi��)�7"pؕ��k��v������
�\'9Y�7I���HC
3b�$'�9�iG�7�
�sXb�{@n';S�E~`qm�:�9��T�]�_ش�/@��}b� �-�_~���zΖ��
+�oc ۾
��
 �_�(�
�2Ǘ&)>�����i�5)<~X��
~�W�_��o
�=���ե��-���Z�����k���Q�.�Ǒ��G`7��]�����q���{�?���P(.�y�ˎ��e*NH:Y��W_�B��~yj�JM�Ǐ~������I�]��6
�?s�%�;Nh�$��U�P��և����)� ��5���䟸IsAG���%�
+?�U�/'�������κ�}��c�&}�'�
+'���O����'����
tȟrj�A�����Փ
+���G\^�
��/�-��o9b\�Ǽ�j���B���G���W(
�>������ϟ;'
+
&͟�'�4k����H�Χ�LY|��6E�8�.E�
'��M�ξg��V�`ڪ�—�ݼ��T{�{��%��*.����"ɄS����t���g~֔���澖���Z��Gz���[�~����
�=��{c?��4Fw��S���
��'ƞ�����d�.;_^Ā���y
G'c�j&}��Ӆ-/�}c�F���
�q�;�>�3���;�&ҋ���g��k.Y����.|p��c���xj�W��eb�.���d��7��k��uR�3+�;�=�K�p����6�j��.�u�m�/t�kժ;�h'��
,��eڵd��3�rK�
�����
��cd�9m���O,t���
�~����M�%�0���Z�A���c�RAx���V���OL'��ݸ�5w/}�Ѻ�/�ȷ�y]N/Lxy��n�;)�\�� �A�ca��b���莺�C�?�>�9p}��r�U���о�o<Lt{��>���.����
\3��b�
�~4�ٷݝ�8�KnXT��W�����o=y�F%����=���nuwY���,��'��_���I��B�/��?z�j�[���{&ӥ����w~��jư^^��%%࿏����s�f�{��>O�t�Q��K|�Γ7%�y~	
p��~�Gsx���w�I����;��}x��
�`#?{���&���Ʒ3\��W���u����y`����W��r�-jW�}������n�Ƃt&<�c���ix]
+z�2�0�M~॑ɔ{�W�l
+H�l�mY�Xԭ3f�
9{h�C�INw-�P����Y���~��m9j��z�<�\�ŭZ�����
Ѧp���
|{Q~69g ��?U��
ߔ
��:f7y��<"��q��+G^}����G��+/)\q�����
�}�X��[�?����_��������sqa�K�Fn�^t�B��_���1�����C}
+��׏-���_}��c�B�c�ý
+m��[����
�nZ���O�<�
���-
�����W��q�u�<5;y���ոqj�%�=I�;֬�W���>��D��6�߯��ߤ�C[�~p_�¢cB��&��0�C�{Í�������/<��������鷾��������Qy�Íb�<�}�G���g/ϿN�;?l��%���eM�q'6�^t�?#�������<�/���^��N��Ss��/�

��
><���ܽ���
G�߱d�͙�S��K�ϑ]���A���ė�N��ܸ,s�����
�>sm.-r�3��J�#���7����K|���65�a�,~�4�^|l}rf�B��e���I����Qe�b]m8.:�
+F��"9.����3/�����j�
|��F�с]o=:�~ջxП_��Xsd��׽�ȼ�Ayt��W��>�0���mk��g�UCz}Q
|�>c?��kk׭[��
o��yǾ��
9|`χ��;���\o�V�.1r�9���k��y�s/�z��V<0�����ܷ�e�F�>����)��8�'G����&M��]ũ
�
I
��i���/��|`�A}:�
ֿӨ���4m��Y�[����KE����$��eP4�_�(��
�q��r��YD�U
+tI���-�Y�اkKbW��
g2�VE��@�5 �Q(Tk&�l� l �F�)011!&��pw�
+E�	�	b@^�(
+�<B���	􊀤�	�����
��Ux�4�+0K�	�$�\C�I4Y��r��	����4�-��)#���}

%p&�c����p�T)=��J �v	���a>�m�B 30�n	K�_���2Y�* ^�`@���-H	���
�)'�� �1	���5�D5�#h&�QC	�i0��谏�(<?c�B�1�Ӽ�c헦ͳ�E(3�!wF8R�$`C�����^�(8��
�T���4X׳,]�Nw�9�}���8@/E�����3�P���@A�1��H6�
�0#2SHdN���#"�P
aF�.� @�B�̃H!���^����^k'$m�=���f=|�����<�}��}]C�)�k��f���CN�d2"e�p�E�1�
�^zt��U�F���C"b&ŋD���<wro�f�u��?��O��)���	����d�%S��نd�A)��C}�D��0�ˈf�)Q{C�]�yR:%R���T]3jL����*z��P��p��<A [...]
+�$�
�DI��
�� LB.t
)h��f�ё�V�����ɑ<ŖG��Z��Kȋ�鹀����r��Kz�@8e�%Zq;zJ�.���A��B䲶G!g��Bk21�d�
�i5-����/B�Ei�XuĄ���ɉ\νu�Z'�~�.ź���<.�
N�͝�2i,{�`���1��Dp�$u;dH��|�;��n�ȹjK/`Rr�`+g�܃d�ݠ�-��P��_j����k�e2n��b
��
+h=�T��`�����=�
]�mYm��?#l�!������C%I
8v�8D5\OW-i�����3'�o&Z�粵�Rn5Hc9���w�Қ;�Y����
L�բ��G'�F0���-ch=[��Z5v�ymIt��2��T[��p<uo��9���9u+�KH����#�#�s'>��is?�6�k!�A�@��e��?�0�>M�
���{�4N�h�_+an߿�����O���
�]
}�'�ï\K~ֿ��������+��Į��u5
+�?�n�Un���s����y�?{�i��w�pf��Wc����Ž���
���wc��&}�?^
���g=�1���7(���_�7m4���q���<���685??ox��`<Ni���	]�n{ƙw?N�r�M<�ͷ�������V��o���+��M�|���4����
�u�S�u�?�n�����/
+���m��r����7;�Qg�����{����f��Ž�|í�����<t�c�
��9��g�Σo��u��z�i[[?����{8��^���n}J�^;���<���:�ٿ�{ϼ�ֹ�|%j�7���u�ʩ�YN�&�<5��o<�e�{-ɛ>�
z�/z�G>x�]���O
6����܌����O~�����<x������+���+���^����{5�m�w�S��"|��0�
Ͽ�O8���͟���|�;_���{�

q�[,��M���{�
��
�>�N�VG.x�����!�����_]��7��MϺ;o��K�k�ޝ
���{*^��ܗ'���O�oi���'�z�����.��q�������
+�弇�H���j=�%����'8�#����a�&g?���_�xݟw��x
�o
�����5
�����O;�����t)dGo��G=�/�
o��=�)�x���
�{�m�#�d�
���7��17����-/#g�N矏w���/o��	/�`�M�~���;��+1�[=��o}��K9�w�qٳo���{�9��V��m�陿�jޙ�a��
<��[{�ٻ�
o~澚�Yt�e�%>�EϾ��t��x���<����k_x����wҔ��S�����q
ǧ���W~@bi�����>���<r���ث��G�s筭��ݯ���޿���>��7/�/�������t��3�xٛ^y�+��z�I�sٟ��w�z�_�v^�I��[䅛<�u����l�
�>����
��N>���������~7���^��}���ʷ>�t����k�m���w�l�w��� 1������}�3�z֝�
����YwX
��?�}��߼�o�s9����K�5�/z�[�
�q���B�?}���������N�zߟ��9w\
��?������]u�W��ij�9�
�*����I�v��͒�_S��w}���M���}�����O,���^���7�u����2����k��ѿ�
+������\���܏����k�ɟ�ǫ�{��
��x����
>��/�˔�G_~
s����xҫ����}xy�g\���������7>�,h���^g=�����+�𽫾�>	Ş��+7�p�?}����������['?�E��~���S�r~ԫ���_��ݗ�C�{�>��7���S�r��u/��r��~������-U�����Z/י��Ok��[�p����*��/}�=O㌼��_�*
+���ѿ��7=��w')���
���w��g�S_{��}�}����s>�*�����
�u{M������⪫g�+�����O��i���������#o��K�=�5_>x������kp�%�y��2�O��Ͽ
+kK�
�n�rM�/=?��׽�5��x̟�>��4
��T����5pQ�{Y��κ�/.���[��h����[���<��h�>�:��ѿ��Ǟ���ȯ��Cw?�~�%o{�5�o���7?�
��.�����8��rˇ��zW;���Hx�ڟ���O��
�G�B|�}��[O���/x�'��^u�5
�|�o>�W_<����/|�����5��y�=d��ݧ�����Qa���golw��ϯ�������p�ԋ?}
�4?�¥Ǒ
�H�e��N�����}��v�u9����;�r�8r�ˮ����G���'^s։�'w���k�\��+��ğ���D��w�
?��\�����O��ҧ>�a��剏�<�
���/~�������
�����ܗ�>�o����G?��/��쓟�ʷ������_첗=��D��w뽳�=��G��#y�c�~����|��
���տ���Yg?����/��qf��t5�����J��le;u�a$�K���D
+� Q�z1͔�	~	EHJ���h�Q��\��}��/۩�J0&Z���2 ]bM�J�$�)�Ԧ�t(���Y��!�3K
���Ŕ�dF��B
�Қ}���T5���z�	�U;�\�
������zft��(ﺩ�C������H�ھ
Ѧ"�ik�B5Q.�
+�bG
E���y.���gF)T�d����g�@�UP����-�ͼ�c(+@ �ZrE�u�jg�]��f�e �&q(ʰ2�Җ!k�����]ٮ
�~��u
�,H�(P?+��C�
+|��U{x�H�]�.U2b8lf%�p�
i��w'��P��@.�eiƊ
kﲕ����N��T(�Y�=�w5(<С��ܷ� � J���Mh\���PL�T�ai�rh���"v
�y�X�<�Yd��̓O����ã�\-n�1G�()������
��L�P�T
I�� Y�(�j���7 � =W<�g�'
C�^ʜY�۳5[���l�p��⊿�R��S��.ޤJ������O���2΃�9�h���Y5}Ju�����s�7@�D!J1I���/�Sy0N�����[2FQ���_Jmj�⍲W�
T)
()��8*T6�凩�@��1���
+����/���G��%@�Ӊh>�\��*�V�a���R:�Y��<󉚤��k
+٭Nri��������������P��Mg<�,�
��W�܊��Ѡv�fЂ�~�I˩aU9Y�&�(qv��Q����8�r1�w
����A�
+� �Zo��~��a�u��b
�@	GLY�5�X��s��
b?��UMNV�Q

�;���TR_�SĤN�Z{*rT`�&�Β^+ �HI4K���,q��b�i��tܲR��
%Kc��#I��+����;7:�\3K��7ɣ�ѱ��0���� ����e�>���1�zI�w� ���ʣ�xj�E��.–��zV��&x }�
+��+�Bs
s#\I���ce�Kc��j�7'R�ZQ�%�HSw���(˻��Q<�8���Z~G,A��\F|zِ�6\cݗ�Ԩ�/^S���
	&pW�
������W}�=����[����(�B��j��?͢/���{m��%��E����I�����w]�*N��gO\�����]\������q��s���k����[��oxM����f��i��u>�O�Ԧu��o����:~�g��n�n��O���}�&��?�K�qk+��
+���;�l��Oj����?�8����D�/���h��(���T����
w����?�{~�7{�9��j��O�g4���V����n����Wھ��
���'���_=�^7�o���
w޻�����
�t���+�\?�i�o��ݖ#�$��F��'wz��w]~�f7�T4��x��_�x�7}������%��w�F7k��G�}��}k�
��F�<��W�~v���?�Ye��w���:)��~���U�ں���~���˷���������_� �n���o�\8���'G���7�ه��r�N>�8l�~����I�y�/:��Ƿ��薛?n/�t$����������{=�Tٺ�=R7�ۃ�x�%�^�X]�Ig����<p��՜
�[�O��~�ٗ�^{��
���ɏ<�w��������E�>��o\�O~�������y�s
u��
w{�7���oG���=��n=������_��K��
_��_��w�x*�c���g>�>z�o���������?�����x��(
p�g��ҧH]���0�!�z
��~ƅ/|ڃ�v��~t����^�����Nj������.~�� ���]�ե�ٺ�ß�'>�u��^�9�����<�Y���%�x��h��{�
-q}���
�{�o=��w�����Ԛ���om
}�b������j����9.��������>��;�
���W���o���?���x���8���_��>��@�?��������7�֌<�W���/�W����S�ϳ���j#��d ڟA��?�iu���Ͽ�q7�?��_�ܛ}���^���]�g��ϴ#<i��W�
�i����k�Y����~�;^�����7�D~Y����?w��f'����6K^������M��?��o������<mm����Nߺ�o�k�m^�i(��������o����^���o4����y޳ιE\��|���;���z���w>vы����O�ݧ���s����
�C��������@�ǯ~e_�����պ�%Ǜ���W����,_z�c7��g���
&����>cS���պ~��?��8٦�S.�N%��|��g
���;���T=��?|�/?�6[�����w�͵�����|���p�����C_��?^��ޏ���O����]m���.~�/���>q��?}�˟xϫ�p����<��}�o������Z{6����_�ڕ���{^��3Ox�N��� [...]
+)�r����0�B����ł�C�=����p�+�U�rj�k��`o�Fo
�۵cSe-��n	B$< �vc��忡��B �(YUKx��xθ}��M@-U��8rm����\����͆�qa�4�;9�� IošRaiu�?U
����-EY�W�O1f#��,��ƾ�4��87�1�<��g�NO�b�o���*D�X�S��T5ⵞX2��O�~b4� ������R����
+
+pf}i�;3�qu���
�y���SS��,s��v�r��.o�[hRA�H� >-�軁j�@�<����d`g��iE=}pP���
���ٙT�t��wN8�h��2��s�u%�u^t��r���^S['T���kӲ���&�[�a�,-7�3���0�oM
U�����̟�Ƅ��
�P�
+?�ϐ����Am�.M�)�*z����0OZ!���-W���T}�R�
�h���ؐ|"=|m���~#���-�b���	\�Z�{
x
���_�c�i�nP�� *���i�b��h� ����5�T����P�Ў�^�[6تm����<Z�GC��Ђ��c��;\�bه�.i9��N
���Lh��)U�e<OTO���"������l�C-�!�$;�
�i�Z�D4@}V�~V���C
���z�XqV�s�
�f����c!7^&�1u��%9���
LE�쨛�i��k�6`@U��be��NT��,S�S�ͯ���N��
�#
:���<���w��D��4�����ŝ{z�M*���
+g2��ɕQ�1�M�sk?��ޙ������h �'�_o\;Th��
W�"���ohuWG?�n��B���8YJ`+�ܸ�%�cBQ�^ְl��u��
A'ﻝY�3���� b�����leȡ�'�^
�c� �&.�#�����]^�$b�4h�I�؁�U�^x���W��,���=��e����0��\@X:o
8��,#r��BJ�p��2�֮T��
��w4!����oX�����z>^.�;!�@כZ��9t�c�jNod�
x�a��+}��84=C�v������\��-��%X�*W�
�4G�Rܾ�����BA9 �{b����{�m`�}n1�d���{��3B�Q1H�$N|q{�U#��ifY:�P��a��t����n��a��y`���*��tM�
C���^*��(�ōg�	���[M�x�s:���)�l�~� �$f����`�
�z���ﺞn�4)�v�p�4m�h;��\��Ո���g�>}�#�叞����(�
+�i����c{�yc|�Iܟd��ֱ��ȅ�֬�+\G�A�>ӧ�v��X�2��Щ���i�U���$�
J�,?�� 3��`��K臙.K��E�48,��
�� :�*'�坢�	0'��ҽ�g�u���ٗNs�&�jdZG�H��#\P�9��\*u_�%� -�~v�l͉�U5��I�hU�����'�R�� !�H��K�K)O��ui�i��Bd�4p�F�^zg�Q}2ʱ�ѿ����@
�$�U&���\x�&(�&In� _[&8G���P���=P�Mp
M@;GG����/��dH��K�����K�A�n
X�/0D
m��B�R����fyՀ��΅[��g@�y(Ӓ%�k�:S����
�z90�H�A�����%��bK��4|Pdi�
C�
+����{�l%�I���� �)��&A���ACL�����u��K11Y�x���v
�p�)ص{��vY�_j���y�U-��
ʹ�=��IXi�K�>�Zx;I�������v
��b�]:�v��xd�
�9���A0�w���n�EkK�Q�I���	�n+�����}�����3�#�
��"@��H�X!�}ҸzW-,u��c�����\�9B
�X�-��׾3�Z�����:a['��].{���F��l���s���{B�\C����Y���ut"���F����}6�P��s�̥���	qw��[��<�P�R�-��(ʑ�� G~ !7e%�y����]=
�	3
���v�lˎ��9�Z�6�NTJ��͙ߣ3�n�~KPN�BS
��4�����a�7���kQ@�I��tb��S��6.�} ��h /8���
�<%�<����uI?7�q"��
��0��״z�
&a'y�"�M�Z��m�6�څu�<����it*5[
����.�2�m���
�w���OLbG f��ܽ'�#��ej_�3�0�[#���E���� R�NSn�k�79f1���
3%���v�%� ���B3�Q�E�wi
��;@Wn��Q3^�8 V+�
B�����:��D磯 %���~e�(yN�5�jOAE�)D����k at d�J��QW�a�1���2���{�'��lb������CR#�nՁ3]/b��4��E�~
�.�,r� ٩����D;�T�
�
+��ݡx�cQ�Dof���_�suOu32��4����R&�aش���u�	g���x܏�-�})�2�]�
�č�5t�/	��	�����'H9>��AζD�fd�<LN�{�Ҳ��, !�Ar�
�2)s�o��	��of��JB!9���x�Č�ԡ�
�A�v�(�
wM�K�XV�PI��Q�N9eaF�b�t:	�&< 
+8"F-��x!�G��,0A�k
�aSr_�����SN���x0+X���%�N ��{=�@���P�3[�b`���y��NW��Zb
�/g�rO��g�E3�z]�,Q\��#�E�������>p777�^! ���G��Nk� �V�F�hr����o�!7��JlZ\ݴtB�^Gm������������d��-_5  �8z{�R�ʞ�{�j
��l���JJ�#�XQ�X�&}։����8Х���

ާ!�Oh�H
��) ��n�d�1�d{L���m�ʦ%Y�y�
��/!�;
�]�j�$��)v~^�˚��s�Q��m?��U��գ
e��c�Y
��I�����xéЖOX�]K�7�ZbB��k�{ȹ K�n{�G�z�yy��9���>�������x
�K�N�;����~���{�
r��z�]�:�~�<��㿳��X&wy���?�L
Tq�c�F�8��٧E/�N�>�g��?=��r�n'9B���-yX��34��ޱ�"�{�b�Qh�@���ۇ�l��0�G^���b;>��夞�Ѳ��Q�Q����#��
��ew�Q�ʂL���o$�����FɆ����pT<F��g_�i"�8��v��pC
�����O��=���D/;5`f
�ᨶ�*8�Z���M
|�?A�lj�L�S7����1!sP�f;$����Qyc}$E��*S_�}ї��E��@F'���x�&��dr�*�a<:�����X�

�,Oc�%~hy楕��!�ak�Q�}�'+���g��#�SB�.�#���.��F��%�X�+�*:t�X.3a���ى��'�هt;�v
��E�V0�z�r
��%%���*�!s�,���1
��L�����#���U�<���ڋ��g��k���

���"�3���R�8��W'�Yj�c��a�-7��T�*y�6]<�N^�&Q
��4�hؽU�⮨�h痷F�M^�zsQ�+�~�]�����CB�n�u:3Ta١M�+��?��
�;��O��Ɖ��},�4,����IȺ
g�꼎g{��(TL�_e֣ &>W9M(ʘײ6p�%���.�I�`D`3G�<�`
+���NĿ��˽.*'�B���ĺ�
+��#�U`Y;>wTD���l�
6&�w3�{��&vY�YY	���r��f�ko�}�`r���3^�2�b��lktUV�!N�d��6 at X�^q�h�BBy|S��lE���{����lï*��F�uP���L���i,�dd��i��=M��L��l�D̃-,z2T�ќ���B� �ee
+�FH�B�9u�c��z+�(
`	�=K�we����b,o���+ Gm��
�5fy�,�.��6k��9�*�"��B�
�EH5����v<�0;-��]^��ƛJbBG������K��~o9��
��P=�ZL"�3���*�$�O
k	{{΁��sOl�D8�
?��8bC �Y�������Y�wf��e�e~f���~2�
&Me�w�WIcU5��S���|`@>�2?V�%gg����D���#;�
*��{o=�4�*j��&,Ob�J  v�.T5����" (R�#i��
����Q��Xy�ؓ��E�!�%yG���g3����UFP��~��0C�yªt�`p��ui
����ϱt
G�#�ZĬ�=��=���Od�oD�i��ɴ
�̳bs
ѕ��pD�,5M�I�V'1Ð@�c���
�Y1F��wL� 
X~�֭�yR��㢍���
�P�
�k
hd
�a�\\�8a���ǀv�����ѡ��T�/�2A�_!Z��K����2z�!Ȩ
��H
"�T9��?w�Ϣ8}�7Fz������Gb�ÝA����
?�:E6')@j��aT�UD�ĄE��g����

�d����Z/Q�����b���Ϗ�2�#lB�g����ko��@Y%��Q<1j��]���*�Q
R���fbu��C6�3ds�|l�d��	$�U,�ߜn���3��'��:	7���=��B��c�����v��.2o�f!
�
(ڙ�G2�%e���'�<cl
:�io��T�|��W{�5b�K�����c
H��,�Ի���cp �β-��"��)�~?�9�A
�q~u
��o�);}�Ld�8}�ծ��1�FM1l�Q��arr3$���]m4��9��lxGuY�Y
M+��1���	7Ϝ�2~��7�jv\
��l<c(ʓ,���
�x�r�9�:���=Pw�<��
+��\�i�1����d-#<(0��(!k �Ca	��[—��&����}+��cH ���O��vܑxd*
L��[�
4
����%�Y��e{�B{�;Y']"�̷��������*�&�_�zw�:��P&O�~�w!e
�i՗ 7�fr�O Y��}�<�A��!Ώ��U�[�!��씢崶`��
�K��`��
H
Ɍ#nE�aFFd�/���@0�(J�-
���	cn��;�!�6|�&�
�qX9���e��Ո
���x�@(���r˨�؆Yn
�Gsv�;ϡ}O��D�b�QR'R�}h�{޷Y�AoC�?�&����S��u�c�A؁1
�G��#�H��9L��BF)R:�)���-f�7+q�h֦��ɺ"I�j8B�6N&&���
�l�_X):Uo3�u
��gK��&c��ǀ��2�zs���k1��fn���J���h�v���Q���&���������Zm&'
3.�c�h
C�9����y
j�iDg����
+_��
�_�(av��-�,�(f�9�u�� �zHD�]>�yu��	�d���X�
B�"k�V'4S�mI�A"K"êM�.�:�+q0��\��IV5���G��:v	{u%���t`�[	0��	RuJ���
�'b6�E�_�+6�� W�Qwi�W��v	
�%0��.�/����G
v!t���9�n8���o�h�ʢ��+'=B ɀ2p��
Z�r�X9��1����͞4��Q�$^���O!���,�G��eGOV	LtK��^e��l}p���F��MB�žB��J��U�����T�b�خ63���&���l��9�����M�,Fv1y
�� �3XɁ�F5X�,��[��'`3��xJE�B&� ��f��j�� 돳����
+L����t�ܣi`f���&��!		"�c�(�F
�`p�cp�^��\
+�,�0�W�]��d�2�c�U4�2���]F\��.���6*�x��M�e��42���
�����Y;s�l��x-&���r*��,E�C�T�9���9�F��Ʋ���p�0,��chgF7�$�yG�rI�v���8
p��A�y98�{��vH�Ubk�#i/��:��y�}� M���
ɞOA� k��5�
j�@ņ�!)
)5YL��-�Z�$�E�#h��U��k��bV-�:tl�`'O����O�"�(RP�Ef\Ȏ�[G�r���@���Ak�j�B"�0������=���#�:$�4�%�ܻ�`D:
i�u���ރl���7^�T���ЛEr�+Q��.��<x���ȧ"�e!�QS1-
+0�$��|�
ū�.ViB�W '���
a40�+p^�6���p=
���&w�O&6Exc��K\B?��h	���N���1��HW�œ<AIWe���a�VW�8�����)FUK�@R
c$��\
+�
�D��KM~��1��=[�#�Ȅ|]U��\�ǘ��	�+��X �����}	f
G�c�Ue�u���A7 �mX ���:>���чqv���(�B�lc�
�l��!Q0�/N
����Bs��̞�
��b��UFv
&�g�4K�H�
�)"j�gw:�nV�՛8Gp�k�*�`0s��2�Zآ澶�Z�;�ӓ���D�R�P�m{����Nٶ�\����vQw�:���]�!��hDۘ��]��[X�3
+�
�)E)[����9���k�3}��Z�$���֊q�)ty�{3ZL�gز�d���>�����u�(�.S�j��E[���`w��:����x_&V���&�
&*�j�0^��Gn��؏I)g�a��X�(�'w��a���ZU�J����TL6A�5�� ��LKх@��Cܢ(R=���p�d�s���^\H,Mzn@�#�7�"�[�(�H�5~荕�h�������#�6�
���C�<y�ǘ�������D9�P��0gWE���xt/L4a�ڞ�%�0J�r�@����pO��GA
�?�S�9��l�[kä�ޠ���������g��爬�DF����
d|4�֖4���o�M���Fn�9���k[!
�����8�R�,.�0�o�Ġ��
��#ڼ	�@	A���:;�1��=
�*���d�c���� 
,P�a4y���s�l��
�@9
��:Gz���̺����N�	-h
��~7�o�+Dha�9^A�d[ͫ~���=
�;�.�Ub�Ŷ�I���:��c�KU�d��o!6�����Q�ᏮRoV�&3�f_0��r@�I8�-��
̼s(�u�Ɣ��,�k\�
u���
#r�r:�<��
���G�C�Ax����Ɖ�N�!^�N'�v�iC�b7{���Q�	~���ܛ1F���E!	O�n�z�jy��k#ւ�>�R��]=#ط[O%:�i}R�,���$�
�a��qOׄ%k�<���G���� 
�Q#In:��E�9
ts\�r�t�^e;Fo`�/wc���q���@��EͩR�z�(��^��W1�˃�Z���Ja��R�
��c##'�s�Pb�@�����G�ܦFį��U
V��Q������5A���kӸ`�#btDȄ��e���@
)�0��3�2~h��+�RP��
˧�5�Z�� �l���\���iΎ�����@�G��1	J-H�Co	 ���T�!]�A�G�5�V��q.|��,#� +e��)��T���Pr
+d���@R�y�,6�fHy
��}ZS ����p��������1 �)	=��Dc+�����:{�ڴ�A	�С���>y��F�ӒU� �_8��̗H�[��������i@ʼIn���/K�Uw��뉈��*�d��HM�u�4����~C�ls�q���.5�>��s�JD &�d1
:�_aIL���s$ ���k���Y�E�������������0�v�^!n*H�#qW�M��
�@�A�+‰TN���l��~c�!�
+�oC�N�9� ��VR�bKn �("?�E,m"fi��hX@�N�qZ�8�LSݓ*1���g
+S�u�ȱ�g�Nqh�ܲl"\s���)Π
+G��!j�
����䵁#� w&�t��Zf�XR٣:su���%O|'���pW9�J~(#��(�(� 7u6��,r
"�K��-U�� ��
e��h�VO��eQe�'���
+��d�A�։�&���e���D�X�r!��\�s��wa��3o�2�$_C�T�Qם��iE�/Nj���@
d
%���i+OA�a`H�޶�YWa}A�
+����+����^ᰰfh\
EUU}�qU�PC[�18�������
��DJ�z���Н
+ s����}P2���x�OZ���4h�����T<l��c5
��C�$ۜk�
s�

��<vI��G�
��\k�����3�Y7��XF��q0)d4�3	�݉�

$�%��^�ME
�2��+�+�4�[4r�9n��y2��S2��F
�>���
����s����!�J�LԐ�s 3d'A�v�jR����N�}�g�(�$�$�.��/�O�� �� o
�� 
��&�B5fGZ�Y�(�T]�À-Rr
�
r31�-��t15ԅ��N��򺁄&kX��,]5 Q�qk�> ^P������-g>�ή�:C�̆���>���.�2�ݱ
+ԅz�pW5��BW���C��Ukb��lH`�[U�@�j��)�����%�
���)��S�$����<���5�T*f�|7�u��2Nj�0u�V\OX�9�)K��Kh�,ΦN�K
$QzbExh����Nt�3��
Hj&�,}�C��JHEBP
b�iD���0�tO�:7z�j|y��x�g��!�3�(&��
�(��ae�
�
q��m2��:8��A%�v�;L���r
+%�"�6�CE�!0w�Ǝ `IH����6C �<2�2�ìj
d��`�"� ����F3x���Gw`���^ޠپy
�Di���.)
%1�]��RG2�E+=�ʇ�� 'C
Je}i�•��Lal��1o/�aprpD���ٸPD@��7�����a&+�6��֍7�_8��)��y,�a��Q
����tX�
�V�"ITd��H$����:`t��N���eTg�����}$5P
��P���8F��>^[42��֛�㌁�F[
@I�s�)��i�B��@i4�ր[FcX
�M�	F��J-	�e6
�9�n�S
�2�9��p@��^=U���^���cD����f�I��4TJ���������o߀���"�+��է�l2�{
�J
j�!u��#����\R������42I�\�Oz
w	S���!`R��
���@͌d|O��q6b�䞑`һ�*7d��%d(��S�]�Bt��{#�FH	�O�V�:=��Bq��RX ������g�/b��Q�
��9��=�+��\�D&-G$���=T���砩��G{e��Y"��ɤ8��ܫ��\�0p�
K�H:�1����[�,X9�z���N�cD�	��"���ѥ:8F�<yH�+�eBG��=����&�;�3h��|�
+E]/����t �4��9��IM�
���8f��x�ংO*BWX�%/`
+ZK�**��K*�}
+��5�y�{�Z�?�4��sh&f�{s`��(L�B�r��z&��N�
�=F9Ru=Vpm��s �iZ�eX��	J�uG�V#�j5���Ն�)c�b��3��;ڻ�*�,���
dgM�O�,��If�Q�� D�0�wT{]��7��7[��!��0H�9�c��<�l�{$�r*�w���`:$��ͤ�N��*a�6ۉ��D
+��A͋��S�p7
7i4��ުy Ҍ'��T� |�eu�X�i���4B�M�Xa�H�_[i�R���c�̖�+{�`���7l�1��r���
2��
��
��C��\ \�d��l"7�����8��q�&�����ї�D�.��Q��P�E��}Y+qv�uߚ���IV��Q*����Jh�����sԏ
�1�c���F��Lc!�7y�H����R�e��W��_!LH�x�
�K�r����,�	b}�[ K
��TV�� D!�
+�h�LF���r�I�ơ��
�h���g�~
 f�)���eu�C݋�sF\F!L"��[�E(���`���w��o
+�MiP>�8%y�b��$Y�{fϿ8�W��F���"�
J
��P3������3#���ZTn��{a���w�u�V�$��À�S
�0�V�P(7���V��+��t�h.)�VhzW�"cx�`T����͔��7�7Θ
+���IJ�
!���V��.<R0H;������7ܵ�Q�M ��-����E
��{�7nܑ�*�R!xAٳC#�>�H����t#�l��a ��f�S/�k���C��!��e��\���h�*� 3�W�
0w�q�80��2��C���U즘�6ʀ\� � ��)D$trYj�}�$���FҜ%��@h7ͻ!v������NX��qHk"�˛��(1�E�PوT�N*��&�l9F|'˼uҀ~
t0Q��oQh�Q�H�*P�B� Fo2��g�.7Qp��w���
Q]���0��/v�,$�F�Dm|r;:$��S���
9����-ov_��N@��̆%����!P
�5z
+ ��t������
F���������})# ��
tGW�(����@0� 0��GbN�G}��$Da*Y�E�<��	
bIl�Ţ	����f1R�z���
+�l74,��l�� �9
���,'Q
a����C�U�f(tU
+\
Lr�Q�<"��!1=�!�7s$��,"6>�D�
 �#QL�XY��luPZ�P	>B��IjzH �zE$���~�+0Je�f4<��b�����a�������
+#$��~E"`�A��$�k��
�Qm�8�����cE�?�.�����6]W��Ǩ� ��~�`���_Kߪ�w�����_+3�I�$�
U��w��I�.Yj��3.�Њ��D���:���Ǧ"Ӈ$-��A�9{����d"ʺ�E�PJ�\+~"u3&c��䓟���jC��؇<
����{a��<���Q>- ţ�uǠ�+�X�V�
S��Q�-�H�7��F���}���@r�؁?�O#7��n��Ki��ŝ��C�C9SM�;������s�,��dð#�=���	�M
+��h�h�,�4�cG��7+BW�z�sE��sSR�3�g�O�k|1"@��Q�+(�E�
'�����E�C�FW���ֵ>����k�9��W�j�.��rQ����j�l��(b�J�fRձ�Qqx�6� {��Z?�X��	J�3\,�8dv~"�%�K|g��K��\�f���X	hw�O�B	us"��"�E����Q=zCt���7$N�`&1��Ϯ����

L&"��#L�
9�A��
%LQR�T���ﴎ�Ɍ�޺F��
ն�f��ck;艹cH9� ��]�ZAd�
Z�
��9R�U�3�±<���LH+�>,�T��.;(�S7�npi�P^%of �D�Į�	�*}
��mN���c0CFF���C����w�-[lv	��BL,�W�����Q9;���R�8�6`�6Ϋ
�B謮�.��$�)Tט��!��8y�Y]�Q�+�q��A��D�J�_��Xi$KE��q�H��F!�7� ���q(��Q�1ʣ�]e�庬��Z;�Y�x"<*�,��l���%iԲ�Cv�>8��!*����g٠�
H<��0�O�t4��#y�q��L��w�#��ƭ���{,Q�1s8�
t'(,�hY�:	S�ih�,��*�iw����S z�"VͲ`+
+]q
+�� ZA� 
+.�"�dX�rN�����6�)|�<����g�$_�Y���_
 n�3���5n�!�
rZ^�3t ��E�'�\��LR�H�;-����R�p2,rg3
áz5u�������!��]T�J�*�
���4|����z��yp
�I]��- �3OT� qM:����H��hN2y��`�W4-�&�/v�7eY�~�p���tA��uwL�}S
A��7�
"	���E�P��7��;nr�As/t���ɦ)�e92X�!x��d�hH!���.ؑ=c���D�ĦH�1|+�.�ND�l&��U�1��[�&�W�0�
+Du	y$ڣ(� ��
�m�bI<�H�g���r#��5�ݤD�����,<*
�n���e2۶�)P�hc��
�72����:�����
D�<H|'�26I$'�
���ۡ��4�
E����(�g��w ���T�O�c
+��}�

ķ���!y��rƶ/�[��v�K�Gt�>86�!҂���3�O����
v��F�p�C������s7�#����"I%��,B:C+�+�%ٸ�?D�a��ho囨�r�J|�m6h���	Q�@Ѥ&I�At=r���\3���
+F/�l��Gb��
+��f1Di�7;��^U�K$���6CF��#
6�4�&!q��h p�li��<I�5!	J��D��D��m)U�4��Iij�?��R�7��1pL"��C�4(�ݰ[1rUh��eo��J:��I�Kܚ�H9uT9���[#r.+}���-��EoU �TⅹǓQ��
�"����9ɵ�
��*(v�Y���>�pb�i�S��+�>R���5����a�=��
|!'
M�*6��֞�%�&�=Ji7oH^���=��N����� �/7�mܳ;%�{�k�
+<��f��c,j�܍3�	��'�0�����f
����d\Wǵ�(W
+G>l���7��m�n��<Q)�ڬ���5ޕQ+a���s<��]�-��<�C
 ʙ���ǫ�Y�ZS�,`�#�:+����q�^DL�f�.�k�
�|T�H�ފ��A
��*$������F �tf��<�ԥ
��oO4�8��i�7*v�5)
+o��� -}�7�CU��φn F�O�]�eP��T��� #��[A�����
�4��q#�`���د�C�
@���]�Y��|�
���x�PB:���.�
��
�_
��e$6��C3�Z�/�R��>�H�����|��e-�ЍU�0+
�z���aD��-��l�G
$9n�T4�l
�h�ʛ3de����~�6�
�"�/�O"�∑,�`�
�K�W?���Q�
�*�T$���Э��K�F%��''�əp6�e��\e#*{��Zrdw�I�
�>��PW�FΞ䰇�&��
+�3��^$E��A�wb���FJ����H��v��,��
 D&k� ��d
�1��"S�Kg�P-�4yct䦠���,��I�
+���l�O��7�,5׫wa���bo��"t`/���ѵ�
~�At�#o+c�':�
�>HyS=�b�4�F�먑`Rrː:�lK��\����ad�G=�ti��
��.(��;�C��^0��ѳVÓ:�E��S�Hٿ�^�
��uD���͏"o����=��ĥ�ш�����87���_��Ӓؐ�J+r��	^����/%�����j�b�
j�8V�D�OM
��9hE�+R�ɑ��Â|� ա�T��+�wn�
�u���q�M�=���
Ӛ�n≶�д=�k�]�(o3۔|璽<R��hYu��Lo�=

�.�*]�!��5������yW�TZ���tѶ%����
+��5�t��ȯ��U�9��R��߉����-����)�%��������n?����
~��h�����g��'�?�RH�� �oa3�C� <�p���< �܇M�
Ӭ����N|�	�=M/$����O{�i
r1�� *OQ�W㢝�
�5����M�$���ln	���n+FY����;Yq�����c�!����8��r��L!�8���*\�
�ƨx�;��P�m��*;�f(C"u�4aH���̴Ɯ�ٛ����_Ngf5	J�6��X�Ǥ;�9&��d=�Ձ(j1GtMZ�-�5N�Ŕ-���ջ��e�y��!��xox��
���z.\Y�*M��ym�_4�a��z!y�	{q�=7
��j�Vϰ!\ٓX5$�XF#'˞�Y�ڀ
��%�������Vc<Փ4����l�fTk �8�
��a�bD5"�z(���|@ѕ�Wr��$�
E��@sy�v�l�R�άA�B
gr��b���T�e��l7ס��:����)N�u4�!�AJy@[�)�d��]�FZM�1+��H�hG�
�\��>����i��N!�5�ZN��:՜q!�3��˹�
%ky�Hh����\�'ѩ���2j
C85�
vV��t��0��Q�\}3"���Q>+���o�BH"�7w!�4���8�٢����84{@�Z��I_�IS
7]��V
	��.s3����|E��H�nB�o*"�f&��W�k�rK-����Q�?�{Ϩ	��\��#�Lo�-���)J�Qm����C�
P�
+
��+��C,�4
Y�t�7��,E�u��A��f� בB���sXH��:�<���~��wr��w
Ai:H�[z�r��C(�ݏ�*;�b�C8�ӫ99�� ��|z:�%A�.��J�9h !A��zFz�{�"�
4��K�oR�Pu�Sa/cA��H��<*���AX�I�8̱��'��sЎ�+�qV1�C�X࣍�py��
�D�J7�� 6/b�
+� �� pZ�~����2M
��+�9�V�q�-|����0�C� r�)8ݻ�ct�s*�4�vo�
��NJBOk�`�.�öA
�e��F�݉򔷙Xwk��?C��b./��F�~��dl*�&Eq�G�a���gP5G��A
T܏p[e�Ŵ
� �e<�A���H
2�Wk(���!Yo� ��`3.��:�]m�
sSV�m
�W�rS�*�̂Z=�SG��9�f׼��;��m���>��

+�
��C�9�iA�J(�q<7[s-��R
�j[M���ƪ��Z�29yVD�q�M�\��
��:�iV�7��h�0�C
+
�]�d�ҐY� �GT
W��ti��b�9ʱI�Ӓ�٦
��
�u�@�hQ�
?�����[
���6)�OP'�_�f�m��a21�
+���m���II�Т��S���O�(��l�d!ג�V�{�B�I��wdA]�
���8���m
�199k�@���[c�m{���J1nFk�O*�����sp�3�����
x5J��X}�:r{ܵl
ԉ�MW��=�X�
+�ܧeT��@2��X��FJM��@���0�����}6|�����
�*b*�W�

+}�� �T-K�M���=���\*��/����<���7Q�_�F0�&�0���Z��Ʋ���� S
_��;
_ �� L�oUK�U{	5^�#�O_ �S�0��IR���3V
+D�
���$-W�w��?uz�(O��0i?��˼B@�h��?D���q��ݛ:�3�Y~[����թ�S�2��yN�lC�����h�W�V
u1�:2
+3aĎF�Wa�/�SW#\��&����]�Vˤ=А7�RGx�d'
��!�'�h�l=A����AlOc�� 2ﳭ���L!lA����긩I!��@,v�
�@�=Y��
�����r�����9P�����L�`i����
eh�`u�;F/4�4C����y�z�bI� Uq�H
��D�,�T�c.O4�����9����P��S^0�TV
K�P�1Pq���F$o�mV�ׁb'�4@��#M@}

� ��wR�Ӌ�I�����
+�,H�C�$
G���syWaZ�3�d
fuz��$,�hѨ%3
�0���

���j.AHXm�%�c� �F��&I�J�qgi�M{�/�-d�0��A�b�6�=*&��U�r�$�.<����N�ѩztahj������Ф::�Ҥ�?��e�D#�h�e�*S�j���N(��uIM@S��0(?H��4
	=��F�@������J�1�
"�~�XZ��
��_4�͖�مwN�ݸ�; >�:&
%h��o���Z*ն՛�6��C��
~��7�bYuvj P\m�=�P4��>
@K[�,®�
&ֹ�f�'0�8IF���i�AH]��i45���q�U�7\�hN��[m� ��\��Чe�u (&*tx�
#B
�1��I	� ڎ��U����
mS��g�)��b�h���u�7
�!��)Q�y(8��/(�v�a��2q���zFY�oe�l���1�32��0�#u�� z��nvA�F�޻�7��qD�O����E���v� �{`��?w�����f�8"��͜t4e��l�p� J��T�Z��I��(�ն��*D'��+4�A֣��$J�doZٙ�m'�*�1���O�= ��ԛ!�:��i�����@.	�>��
c�k�%�
V=�Y�p����
 ��F��x�ɚ(�c�#.����e�'�;ؿ�,��Ի��t
��W2"��9��8 �_��Io��.��#�JJ�V/�NV���
=;YbJr���]�#/���Xpo)f�X�����eKd}��0����9+ [...]
4��y��Q
���=� \F<��O��I��{�O�-�ƣ�
�p��"8���]@Ap�
��^,(��ݎrL~E �Q�i�>I)�v3�����
�����Oҗ��4S�N��됧 ����:A�l�>�g�����6o�~>��K���Y�V������|�̇u����
&\"���bPCj�X�
ɿ)ß��^��ǢR�z�M�ޣ�O'e�w_3�z=|,C�"=|���$vY
��O�۽:�t
+ah�t��-�h�ӭ�m����0�� ;�ww
�ܖ2�{F����=͛\�%��Śý�f��P�D.6��z�Ɍ��Q���ÿ��v�d~F�iB�
�=@H�Bҿg���f�^��
�=���q(��ӫ�����q�"���=;.ӾGmg�#��A�
����
Fr:��IX
+1�D�
;
�d�=PI2�	��х�5͞
�
�-�47�Ząg� k��X�.�Q�]
+���p�aV��
�ʒ8Sl�
�
���R�?0v���{��I�*��{�TeQ�p0�C���q�<¼g��1��
Z��3��p�a��p�j$�G�����m^
+�N��y��=�V�>
cI����wF�������������
6�
��j�yV�Y$�G�-"0���-�3��=���a�g�D�!�+�b6�1�<�8��t�jC��n-&ұ�B��x�hIϤ�9�
���цE����9$w1+�>�x��$�����X�+�z�V��hs^J��PP
[cu�uJ�<�>�,5��;f�����Q�$�^V�Kg�dOXRx�L�"7K)��� ��o�Wv�2.-3
���P���D3�@�im��>=�!�ąO����+l��]!aC�d�C�3��1��w�Q�դ���o$6H�[�:Xͦ���I��I��
5\��;���Q�q�@Nܾ�F,+���!X²N�XZ��a�`ssU���0�
��`�ۓe^�V�_~���A�,a�|zf'��:�R�
6޹!�L�=R��{�,([	O����)�nT��CO(r.)�
�)I(��M���ds�5��=M��RD�k��ʤ�uo~�D��7Ԧ��ͱ��|��Os�l��8��
���IRn�l6�&(� �΁���t��X*ڊ4Ag9�D�/+�gl�@c��P���`���i>�0���.6�>
��,`��$(�mߘY-V��[�xUq+�A��Qt+�{+x���6��T�l<�>���}�x���;�̸&�߯��m`w��W3@���P@���3]�`Ϣ&q3� [...]
W3ܙ%�����ާ)�ږ�.7(^I��FIv4�
��
�
E��f�3�x,8�N;�
F;���A��A��2t��a��沣E�橞���̢�1O��p3ى.�b�o�_��O���)*�Տ~�9���'q�
+�B�����Q:5�C
W�Z'���,��x�
+��(�8l���i���7+l,+��	�
+��l��$
�F�V/��x	]u
c#�sb�:�����h����
+�6
uLl�
@?��T`C��ӱ�k{�M����R3
��bl����cgX這����,�ػ�3v~T�ɍ�6)���N��.���Ѭ̿y��
b�rX� 

S�A��l�A�9�rB�j6�F����gι��̤2�#�6��2h�9�9ɰ�uN
+g�p��=�
+�h�b�B�w4}���`�
�A�%!ǚ��-	���k]l.9X�@8	;
�
��]�Q���8��FP�%ȸk)�����GbWZy
�

r���f�YT��|[^��p��Bw�A�W�]>�^���
�j�c�N:�Xz;����RDAa�J_���DHR�4��U�>
Kb�d��D��
l��$� `Ʈ8�,�n�8��CY�Y���S�&4ĩBo��g �x�n8����0
�^��(�3n�״‘���v}7D�P�]C�htݲ�
��4�!y���N��(���f8Y�Y�V̴�'���U{�#��
�I�h��+�p�\+ѱE�FU
�
�4
 8t�q�N:�ph?n�!-�IX�	+
rJ	̤��e+
Z��"Y��
k���
�2\�u�G��D@(�i܉���Wg�u��|�+"�����B�%:� �`!"�p����	G��!��	�Y���f��l;ᐉS$��gqV�Y.�hTH�堇�����*TS����V��H�HPa��2U�&�L�\)�p��P*�
�p��Q&�
�8�Pn8�ѫ�W�
G�A���h��Did�U�I�H�
+;
5e�1�
�~d3���&��>r�oD�>޺��RfY�I@%
q:&���$�̶>zZ�P.Ȩ�&��4;;��%N')�b�l\Ö́��jn��A��>��l(x���Q���5N:0ױ߳!J}���,�r��&�I�o��ج�Jh�!˻y�4���v[�����Vi�S�N���
�Z�9 
W
�p�+nW
R?fI�G�V��$.��B(��𢭩�2dd��JXe�8-��V�
+K
j�M�X�ݦF
�n�@M!D�8�:<qO�Ɲ�`�P�a��H̒)�Novsf�����L����{!_���M�}d�[�'�aV��0���4ˣ^)�h&sJ�]��P�I�P�\�]�V��8U�9z	���
��f'��˰ř������[��'���U
�".��SZ�H*R

q�F�h�#��V��w3�n8�Lif8`��
u���p!ѬuG��$� �6����Wۛ
F��j9��c��O�M��)�tb +�BQc(�7

Q��5B��`ö��(����o���4=b0��w���1�U5��٘d�E�(>c/�f}�<�R6E'�f|��ث�٨Tq2	���8�e�+�1݌U���K��ͬXl
2Q(K�
�f��So$2l����bDM��i��fB WUm	�	a��
�ҥ
jhu�����Jz����7��"�O����-�|LAq=��*�k�ORn����@+
���<m�7n
����6� 
��kT#/�Sl�c�^�Jq=��m������T��r�A_
�c��2��
�LsX�b�4[��f6W�4�W�6(��i�6 tͪ�5Kތ�@K�:�rPA��h�D�4���E��L�pC�n�
q P[D��U_��ܠ�/�V��Y�jdM�^��䴓e�fcCR��Ы0F�-���d5-�m�n�@�8�_��(��0�+5�"z��g�-�����^�)�4�.����q����A*�Zw$K@��x0��¸��3���!ˡOc(Nң�����Lk8�-��5��.V�ճfV�L����!��:c^Zg��-Y��f�5ؤ���`��X��.'��1���p�b7c
�3�eM��®��XC8�5�Ɏ.x} �Ѱ&[��
��G)�GiB�!�}�cC=:�`�ɪ:�ܙH�f�&���H�
+��Ue��Z'wB�KM1xU�-
�$x[JC��t����1��Гf(�Y�>�
if�*s��l	���v����v��V��E��0[��>4�k���BS�H0d�r�L�o����@��<�Z���cv�F�q��o�����F����A�ƆZF��L;�x�fћ1�ٙ���Czj5�vF�&3]�r�Q���p���"�<������ei�q�p$]��]gdl)\@І�����p�A���5\g ~dg�t�ч��p�- 
nh�!IK��uJ���Q�t��0�(��?�ԛ�%��7#Lgp>L\h:#艹�;�u�щ�`|h6�����)�1��iT��(Lgv&3��8�C5Y��
3z�
+�3
��w���q�-�3�ޛ��;:�/��5X<<gy����Ƈ9�èuK� ��$	�C���`�r��\IFga9�'h떰�Aڶ
v3L
+E��-bHK|�=	�
Ei
|w��_R��@��r�����
�m�X
+����&'�f؇����Ql�J��"Y$vO���cL`h6#�H�T�;��
f|fns����� &���tJa�
����d	vg3��k��lxE�}Q8�݊"�KQ_��A�kf'�'E��lL�m���
��A~����
���Nf3`�8��ӌ]6����
{�� C[)���!�f�jE6Fi]
��
+��SX"��-	V�H����P��FH4V��Iy����k�cz�A���İ�X����`�n3\txzͨ'��f��D�1�
S-'=	
B������uf�I�oW��,�Z��|8� ����+��%	13wҘ��p�i�4��&ʽ�
b��|�|��YVi4�Il�)S�i�&����ifsm%
K���AZ���P�mv���k���nG�
�=�"alMX�����{��+|&��L�
����+3��
4�⍕~�lԨ̤N�{BA��Y�o�2���>�x���^#��t��i��2�&:wKs�ԛ���e:�t.�u�Q����x�%�צ��
�>0sF����B��J�L|�_�Bl˷����Ʀ8����
+��-5b�$�
epZ*�q](B|��77
P���k�n�J�`
��!�	`dOQ��p�0�b
i$��)�����,��~%P�5�SF�
�>�IC[��j��,dH
y]��+��+�
�˽Z�8��>����F�)�#�l�1��R�`��H��ZJ`�J�_9)�1���e
+6{
�ՠ3���R97����|Ww�����$�U�o�1���,c��j͠?Lt�qB�aL�
+;�b���
+�/Ǝ��UXy!U��RՍ��h��}bf�ۮ׋tN-r�a���3�
�~7�<lz��>T)^
?��c3�#�9Kk��$EP��>u�<�&�
HV��2#��Q�`�IV��E�-�"~�PD��$ �L�"?���qN����Ua7x"YެF�f
�
!�'���aG8�%�f
+�
.6O�
+-�����0��
!�U��%gI?�*�GMY��)�mtD\,�Z+lf0�$5/�xs�
_�.�5{
�C��`"ڦ
�$�Fv�]`b��P2L��n
0�97��ӐrWX��ǩ�^͛�O(ٳ ���C<+d���*>k	��Kv�
+i5��ϊZ5�!��
��6������Z
�(�
+���HZ"�J!���dF�2P;�tZ�V��S  ��t��A��A�d%���M�ty[BB3zB�x�����f
���e�0e�MbP@�����lw2q9�]� ��u	�����.�,Gq�i�-�oK�CYc
+�[��[8t8���%OC&�s��A����d�)�(z�u�V0�1�g�L����"
E���<5�
�	�>H
�̒�䮣��;,]��
+�1�6�fq�F����R˞2�\vF{V	_�B�����:Dvj?+6,���8
+�A�J���0Dz���븁<��V�!��U=%������f�pf���<��F43��������e�xzPb*
�E�)�a���
�\�$��K; �`�.bO�׺,L}2�
+c������֤��}H�rQ`e#P
SL�	;�,���υ�q��%��ѧ��R�gT�xXX��h��s����.�Ds������G��%�����t�V>\ׇD�L[G 0����!��
^K��"@7
+c�A�@�t��i�
+,F"��>��
��\�@�q
,FG�Zb8��i#?U�x��
+:��YqW.#�*�tX�7����pt�ѓ
z�1F��z�𦋂#��w�~.̓2�5iZ�D3���&5[i�ju] "8��J�1d��V[�
�
Wl��Bw0�Yu�䣫ð
�Z�$�s���Fq�R�*"n�u�$ɷ�u��cO?�d5����si7�v.�(
��/��4�G�2�CP�4	#�
�^.�<����Xo7��ri�K�:-�a��U?e3�����oi1���[?�&��Qio0qE����`
:�\�zJ3}KݢJ���x{�@�
�f.��t5j�6GbE<�:"Gv�f
��XI
���S���>��eg
��f.M�Z����QKMx�PU3���N��Q楈u��--=���2&I��U�f��H��l������N.�}\����e�osiJ��:�-�lW]�A5�f�9-u�� �ktuܨ5���$
�B�Y��98s)�T|���	���4l�x ўt=Ҍ��oF�Ɏ?+�a�j	.�S���3��e`m:'{�xReӌ�W%˳v�NX
Zl�9�2v��f�g�H�,�XN��=K'�M��
�R~+G�7�(}�B|�А՛%�HѬYRS	^�Y��\�U�O� ��)t-����&�5����4����2k�6�� [...]
�’����o���`�
,��%AI�~k
+y�dA�)�6�-+� �V^�C�e%I�ru_Y*h�2� �^��7��P�(�i7l��+qY9"?��mWp>T���B�k�z���5�,W��T1b�5pfV�$��iv+����+��4:z�t~��$�ӊ/J�R��8�ԧm$�N��zZ���[~\��
���B��4����M�J�
� u��?�YR�S����r�~�!�`�?�*d�s�\��H������k��
��
+�<��a������
+X�&.=U̟�
!E����*�p��4T��js�b�Ш{��l�m_��vѲ�m��t�!uRJ��6�^*n,) �t(�s餒��i�@#��� 
��GDV�a'�Ik�--wԽU
+�{J��CEY����_��mK�������C�[���y��J
7H��@��\]]�
+UW�����=���b��������Iv�9��:vw	$X��a*:��s��
�g��ܬ0c�S9!4<Ӥ͍sO$�=G�%�%T2�A�HI�.	]zgJ
ju.�S�K�u�TTP�X����rg��n<����MI�
+٦t
+�cI�a�I�	f���4��E�R��D���$�RU������'cRXfV��:��R��d*�
\��R'e��{�h���1�r��=�رC�*�L��q1N��
`��*�ާ�!����C�Z1��c%-h��Ub�fu�T��0�Tx�A��?�	,f�a��_�ށ,�U�B�!P-Q
���/{��D��
R.���>;�԰e!Q
��"��­�{��(jo�p�"x/P�@�>Y8��0�W���U	��)q"
����6���+nk�ޝ|�P�[�%$H2I�dp�@�@�q*w$��3�� Ч}����]
�T
)�qҖ��sF��N�o*lٜ0pi��I�B���U#Dw�u )�~���ZL�
�
Q��x(�0.�Ixξ�H�j,���g�x6o<e�5�~�1d�
fk��/�{f��R
+��-
�)•Jq�)z���JPc�` ʴ,E!�-JԢ��b�3c���m�.��U
�� �����y�-R���b��1[z�� %@�9P>����c?�&�(�mk/I` z<2q�
5���b$0�������tu��KoDUz@�4��O��;j
e��M�*Y�ʱ� ߸Oq�{��g�)6v��
��ǂ�� �P��=�9�
��0�o�O�f�8o�+I Y��FT$�\4[ωebO*�.iL�

�LD_Ԭh7ܮ���#]T{ �
��)��
�{��5��U7� ��S�� R
+#<��F�,�[�D#S��p8�U���ꗀ
���!9b&�
H�ܾ�<e��(d��1f}��
+��4ʖ��i[�D;����CF�����5�o�L�p����NC��osn!��$�yf64x�zV�&d��1J#�&0_3�d3>�ZO%������.�ОKB���� �W$�#�8��JX���R��	�p3�񡳔�Gf�7�@�,
+4C
�
9}:p1�_��,�(A`i`�]�޽I�����wT	SM���S&~0��%�R��KR��3��u!ΧT�!��P����#�oa�i7-���
z/�>���^A�
K$��Av����V ��mѩ��2�]|
{&�~5�9�L:�%�e�nXš�Sߋg��Ҷ�( Q��������J`� u%	$�
+���xK�%�ǔ�İt��
��nO
+EkA���WDF����J�/+P��,��(Y�T֌���g'dT 0�lG��t`f��V��H�)���56�0���`� -
�A�f.�R)� E�D��L5wK�\�
����);�
"�ߐHUi�-8��ה�B~�/Rn����<S��}��%�q�٭"��rlŲ
@�u/�\��j֛�^rw�^�2�
ݞ��{D/C&%K)�"�
!c��H5��fV?+lLC�SJ&|�.+�lb-�+�#l�,��ĶO����=Cv�cI$��_G!c�<��
�d��e�o!�c����"YsJ+����}OS,���;�
pS�Pv}�<��r�s�YX�H��@���G�e*ẹ��CU
'�Y�Ů[a�A��RC?kJ%mW*
���b����=&E�Ê�(�E�^p�ܰR�1}�=��tkF��V-�_0�_1
��*s'|H�U��2�(f�ZkZJYt(2�
4%肊,�@)"t��i��hEr��:�
+DWiI,h���D�������pϓ
�Q�Pf0��Y�q,��P�K*$[�V���d�KM�xxp�")^��"�6d�D��Fk ��@�

�%���O$oȎa�Y��I@'��C�`	\�$g狥)R
�����=��%!P8�4�nB7!���D��L�0����eEϡ�]�� E���k&nL��-P�RN$�䯙
U�R���Z.�&��!�B�+Xy\
+�`
;%X7Ỳ0q�;�l�ao��]�6a>�������
�j�đN�Հ3-��:)
�J�=�d��*~��u���ES��rP4<]0�s'Rʰt�b�@t(0��zCūhTU��X17���)�)��
,H�A��p���)���0�!�X
 �@�R��%
02b��
�v�!
.�%��+H�=��팋%Vs��d
Y�O�	B;��bx+�R�n�R�RC%�^��0DUѥ��  :���Za\�Pr6
4�L���� 6Z�a�
p��᫲!��PI^��@�#l�@)�����V���8I�%�EZ��J�|����F2�9���D�Kd�����[�y���9z�GǪ%����rE����S��Ks��G�
���R�4IL)�WJ8m�
B�f:��� 9�k��U*D����k�`�`��ZR~=Ysnڢ�
�f���fvq�" �lZG�V�M48	S-�o�R��Y����,#�7��@l�z�ȶ�����T1YE����\*cbdtt�5�K���R��
�Tʆ
������ �g��A�t��\A-�
+�6�c�
��c��%g�W�cfz5S��ր�m5�}Dgq�)�0��
u���WSH?M
+'���i�#I�@M˶���-20kE���j� �k5:iN�e��J�z�XmM�#P�'�=�fG�a��\4f�G-R�A[&
�`I�To�SA�gTN�hkTE� |�b�A�5�:�!�m�]�&J��~
Rcx[��=�
+K��QfG��/K�G��2�<t~�DOv	k�FrA`ʢ�g1�jڶ��8(pP+�mc��p�ʓ-u��@5X���kA��w�"�,��&��*�3�(ľJ�6
+Wԁ�u3����l���Z�wɈ�IS��5�0��Ӏ� �ע�k�~(ÇJ�8�eE��Gʘ�$ɣ�S�%N�V-�YK�tU���R������y��m����Z�+
+���� 2�C#�5��A!����{��f����ӡH�+���˪�R�(�1���F����S 
̻�$��[�W�񭘜*J�,_g.H�4A��ch�k!ǫw)e2`�˶� �J�#��z�E��q��(#�M(ko�b��@P�1���7�%��
�Y�O�ךP϶3o
�xX�Rs��a�Þ�JH�)�������oۄ�"����"mi�kBS��k�b�%=+X
�nR�EV:�E����8Ź���C,ˁ��2&
ɘws8
+ ̑J<�	�7a|�'n�HŜ�u��F��s�١�˭s�X���@b�>"��$m�(��6="���Y��C�;��VDF!T���)��@a��)�Ȉl�k��@��\���,����DyǓ �a��!e 8��
ˆ��`c��!�Q��D(1T�)����:�D4U�J��,F�%E�֧II�Bq�L��7��E������`��G��0�f��JoF8R|�A��+`�C�m$奓��!%��3x���V��2�f����b�
|MM�}-�W���[0���=(Y"�
+"�$"�NvI���5���`l
+v��]	$����J{V͢	
jR(eC����9�Y�e���MAJ`Nk��[M�Y��ཅ��\侌�rr�@g2`�8"�`3 '$M
����d쀐#��f##V��~������d�$C���ɬ�18�E�
]kq���y�{8�Bv���z�`�m
�1�BSa3
�>b�#�
�LSʗ	��ݔ����d��"S��ҷ�DilW�B�*t���T4t���eӭ�|	"���e�2��o����P!'�v'0U�7�C�Y�Q��|A���\�Ѯ)�m�Rq�#�
ب�pjV��3�a
+�8=0�)�dq)[��w�Z&sDd���Ɉ @|r�1�f��v�����P���1��ΪcQbd�
:ЊƐ��@��3�U�\҉p�QL���6;�
�
��sF[z�"�mK˸�AnĬ
+BYG�v�!��� ��4*�&��}{�&X��^�T"u���c�6�1L��♳-���*�b�b+E�J>��+z�ĉ�8�@I�t�4�6� z-�oT$�k���4D8�#\#	��$�R�#aC�e}͟"|,1H�o� �
H�A�D����J�3�K�X�Y�
+Ht-�� �%V�B|RJ� 0\59����{�'m;��� 1j� �1s���B
+�\{75
#͈�Ql�  
+��F8�$	���"]�7����'E�ăh�0�/��)��o� �Y�	��x4^�.h��m`
�����F!V�|q�[S��B�H� ;��fcY��_ ?�-�
���Ҫp
f/Y�]�h9�/�"bh��F][S��d%a��p���7�����K�1�
��f[k#u��A*� &4AV-��[CA�p5`6��5�
�%��)���d0|1j1
�Ŷ����J�9ad�UܦӮ�
���У%�������0Z�p�&U�Q�ڶ/O�/d�(D]��)X��;WIX���-�h�
o2L'SN�@+��� 花̈́�tJ�BHϒ)���
1�*'�81��S���Z�dW*+)(W��$�V*Tf���gb��f���M��A+�,
�/%���F�@���f2W��Z�7�DX�c�xg�s<E�R�ǵo�A-Y-�g�h
F����[Ģ�& �DmKU�I�ߥ�2���e�(R*��3���3gŬ�����_����|�R�@C$
-�&�]i��7^�tВc��̑E�lW��`� �����kKMI~���4��ٙ�KF7q�_�u�M��U3
`"H6���d�D�<��
.8��[,����)~����k"�os�&��/��5�""�E�J�*�ΐD����-��m/��|���W{I�
]Fp0`A	�@%�1f��+Ŧ��aOx�
e�cS3�
+���G&^|(�ٙ�r(DvK*�
-U}`��=���V�Wڦ"�����)�Gͱ��2�P�ڄڐS���Q
^�hf��X�K�!�ؠI��9��LahCg(����1n;i���0O�N����ΌNF�rXP�<E���v:4���+��H5a�-a��e��̔�U+�7�U�!�
n�8�A1D(&��TK��`QL��n��p�8(��/��=�~bHD�h��J�D<K�G
͜!�1�l���KP<�NQ#ᘄ�N�
���+�`=���
Rdi��Zb
/
&_��,$�����1V�LGk��p��T��(IC�vT��o6��l�'Ud1E.�e�}N%���b+
R���+��K	@� � ��qtZ?��%4cc�e�hPI�Sm	V�$k�B[�IkP�n�+aA�}	�"1��OD���D��) Ff��L�8��7��^[yy4��1I�<����f�o�
�0RCy#�2�D�D&�יs�O��/(���wB�ȺK��H�Q�(�*��U#NE�Tk	�W�h�Y�l�m��2��Rk�YbM����B.V���=}1�
+����D��
�t���//T�l���8B'�s_�" "�shc<Xef�JB����$
r!�P�����'H
��N A�:��D�i��]��u&}��$�\+Q�J
%�b�ar��� B-�<P� g˅�b�	�2c�xWͳglH�N�It
�@k��6<���9�����Z!P��`"#cظ8�
H�#Re�hg�����'�����Q�R@��Q0r
+����h������V��#��${P0�jӉ��ҍ��*-([3M���� f
��Ҝ�iE&�$�^*���$���hΘ��t�=v� �g���b�%
=�`�0�D9
w
����KhB�"	_"�J�|FM��vm�:o|�m�Z�%��jJD��ao��-0���X��x�u�\ �LE�V'a��"���R�A�E��, ��3���A�D
+���R��PecX�i
+
+�����-�ne#r|�Y���
�+��r�}��>����Q
qh
 |� �*T�f<��o�l��M&�(o���/u"���d��RT�b�bRD�(��či_�P*i�
e�Pc::i�5�Un!=�e�G'��s��9�b \�
N.�TB-i���Kr�y�J[�0+�dNDq�Jm..Q�J�8�W��Ƥ@�(�#X�\	����v@�~<y���r��a��s����Ƿ�IU�
=
+�����Z�
�b{
�
��
*]`/�{�AY�(�b��3E=h[�Y(��K{F�&:P=Q�/���}Gq�J@/+U�;.a�YT���Y2��7N���s�!�/Ug�d1��mZ(��p�@KD	L��zO�����( ��� ;J�ѳ�Mm�(
+|�Ȩ�*4A�%��;

���R�b!���
*/La�7?#����'1h��Le�(��rz���Ƥ�"W�Y,�i׭3�᷿
Ƽ��R� ��7�ϗќΙ�M\4VN7

j�K�GaC�,F��HN�j���4�
+��C6��
�#�݂G��"Q@�̶�19H���k�����!�q�\�&��o��H�	!I���œ��� 0 �=��u�� �C���۩��*q�v��%��X_�VjT4�T+�T�W�f_J8'���^j惐��# 	��� �K�x�TQ�;+�����Є,�݃�'�(��d9
+�O�1��<')�I��|d���V5a>u�ސ�;��YХ&�#9+��,�X<u]��S&��R_
o2 P��,e�
+�9]�J��	0��%%95,�f��)��M��s��y�\'�
�0c�G!�I�� . �����I9Iz
2݌�
+�g��t5�}�b/y�[
�a�j[�I
fGXh�D̃,4Y��6Ɍ��Ow�y�1��9������� г�d�Y[n�K����s���Yͪ�M��U�T P�ۣ�I�iL����)�Qh a�2e9 �1�

T��(�h
�5���S f��7��H:X)�WQ��f%�r'�j��Kq>%�R�#:����W�V�iA��T�b�	m��ȅ�
:-N�8����i8��e<�Ɠ$l�깡%�B̈́��a�)�h_���l-_
�q|p�)u�fb��L*��Q��R1<t����E�����఻�K��\�mY�ٞ�:�֖$zX��Y�Zfh6��Y��p5��B�])`p�[y���L"�ߡ���xJ�#U����P�`фL�7�l��m�]Z�
�,�M�3U˸��.JТ���5�F���D rڇN[^�uT�D��c۾#Sm��W� �e���a�>��� r��
���e�D�BK�°H�,�"���x���=��J
U�{��Iy	���-�e�V����ƓM�ґ8�v�҉�3AeK�v�Y�Y*L��TC`�Z����
�$!R6AL��g�5�*r���1~���p��\10�"ji��,��%BF�fG�2))gJ�K�_����������Y���EO��R�H�qG�
��� ��Ky�##)�޸
&��G�%ͭ
��>q24�:DU��1� b�����a��qʲ�ibk�wK�s/u%8�m��{�Y
�b�1J����o���V�ΰp��˹�a��Ysc��aT����l�VoM�[�"��_P����ܠ䬃��M�H�OΥL�i���F' 
���
�R��:�!$--��a�6��ӘQ��E�fM�y�}CpD�

+
1�`�@�5>�r&��KE�KbĢb��[�D�����T �D1�a��d�F����.�e�4Y��Gr��Gu��ep��^C���	<�l�A�
a*A���
�w`FP��5{���Z��AX�ZF*�k�=z�0
H��|�
�C��5��-
 fOc�g
y*�
~�'ѡO	?ӌ�
�t�P�M����F6�q9���4[��i��ZQT�*���
�ו�lQ��Q�1��Q�"��y�Q|�gl�X�갨��U(d+����g��ڻ�U9䟜ca�w����$�T��8{XH�>tU-�{=�������B�
+�\�-�A�߸��`���+[BB��\���eT��H��*�cCH�F�yy�z$�\��}�j�G��c�b6
m\L����!��7�[�=p_
ը�)K�JKW����
+�1��NB3QO�l|Q���JD5!z�)�h4@����,*�|�ۚ��P�E�\s�T
d�:`������� o�0��3ȈҰ���z��
߀T_� ��Ê��
+�k;q&FW2��0I
�y,��SYU�.�����JM
�ɉ��X�����w�`$Ba���x̵pċ��tABN]�Z�qA�
G�9C|R�����RI$"PY�Ŕ��xI>W,���$�;#t�9|��

=[�^	=+5�2ǂ)�B�>c�Pq���\�T���p�醣A�
){��`�a�
( �
Sn�
� �M@��8"�`
�&����E}���Cr9ꮨ
gF�E�<n��T��X�����Վ��p�
�ܖ�_
�2�mʜ��
GT�->u�c�oK
���~<
+�	�T��E�Iv	�LY��C�9Z���{�4!�%�e˂fÝ��piZ��֩8���
�"G) ��������D�j��'�Ԩ�Rͣ�p;I=� @����Ua�p�T�9l	�Z��L����ɀ�<��fl@�����ɲ�K������m	�.4mK�+�V�(�CVL�[��'�h3�Wܚh�|ǘ����
 mT�{22m*2�
@�>ʨ�\5<:Q�dG��=�� ]Jw2n����.w��"WE��	@��+V�l���#TK
�/����[X`���O�L�
H�,s�b�6��3q�xv
+��L����j�}��O��զJO��r%��
�+�J�!�&��'�B����Cd��b���Sx�3�2XDFL4?Gϣp�?��G�T:N2���<b��x�XC#�	v� �2';�B|���Mͨ�}G��J���T�K!̀���P
�vX�վ}���������J��Y"�
��q�6f�jB�Z� k�(�"��
+�c�� 
%ªmU|7�b
�w�w�{
R�C*��lEf� �]4Kw)CF�I��^�v�g��e�t���3r�SBUH�Wh��&�
)}�خh���	���i 
&Z��6C4][���bJ
{��g�"$Il�b8L˺�ݕ�r)�z��-
p�
+�s�ײ�� ��}����C��,
+�e�f
�#�B4
��Ų`�����\: �d9��)�,�7��gt߆
���
+	ϥ���<ȫ��~SM�<=�
�Y*$���0֓K�#�#@"kZ�
+���G����Cu:��T�^���~�2@�7ëq��c��D��e
8�<D��.�?,�r���- �YT��C���HrW���u)��
��b�R��L�k�WБ��	��K���P����e at Ef���^0U}Id=8�'ނyb-�
�6�?�)��^-�P.=&��fa�F1͂:��0.��������%.Yt*J�҇L�%�dL%b
fr��ls��.0Z	�`����H&W�8.Iۨ�=8�ޫ��0��G
+�ܵقYc��:򷧣h΢	�#��顥��[W�fw�y
+�z M���&�Be�7L��t����b��Y��t���c"r)�J
��Y�zR�T
	�>�gf���P!TUyގ�a��9�hy�p�11R��ꉋT
dP���/_��o�߸���B��r
.)��C�vEI��H1��q	ǂE��ʓ�ȩK��}X
 C��i�A&$�~�cQ��w(��S��X�2����-J Z��Ԣ���߂6Kt]��{%�7�K�]0�nTm�-z�O�*���Ă����o\d�lZJᗂ4鹿d�V�G*X�!.��mŖ!>J�3��%	&+U�YJ�֎
+ W@�y��_Y!��4�� }���FW��
+���VK���{V
Nh�����jWK:"���/!2"\H�J8u��0��@ϯ
+����љc
�h��j�L���
%8s}[��X��/���CF��o
�Mw�E�`�����<D6J��R�Aw ?H�Q���{Q��Y�4�?�*�g��W������	����woM��!o=�
/�,=Bk�ro�4+q��PK��>�e�)i�N�2� H����^" �z�_n����0Lb

벥��
�d��XYC�&0�.b͐r��zk��hmV��Z�8�����V�$���E�d�	ٻh��9���P�\�(c��W+���V�,��>!�S��f<Ri���Cr�̛�z݌a at t�����s�^��k
+
+��.*�O{��
��,�GN+�t�s2��)�V0��'rw܌GC��|@Dz5�*����g��������v�t3
�vBB���yJ9:��F�z�)#�
����3�$���f��\�'�U�0)S
+~��
DiEC Y�0�{�DZ�&��[2U��#l�L�8]���:3` \��8���sO�4�"�d�P��9L֚5�u3K1Zd�bN.�X��
��H�o��a�1�H�\��2X��^�߅�ZE�b��	b���HΉ	�k�2 �i����'�稟K��
t\Q�8f=!�U��~�r�3g*
+]�]G[�+���>�.���ȁ�D����ä8��`.:�b�(���JFQV���-��10����RP%�0k�UPI�A��ZI�QiO��L�"��a%KI`�/+s�V$��2R1�
�P�k�/�C�^Δ0�S|��6���b��
�Q�X�l�踚�kh�=�r(��k��Q�߫7 旐l�=��a���2u�u�r*��� 6�a�3=aa
��kZ]"ke�dp�،�
@z��x��
+
��%���!a7Ǵ���Z�{~��͂�- P
Yr+���5t\QԤ�m)��
�-�r��BR�� ��Ǽ���d:NfxV���i{
%&A��h/��� ;1E�@��ٸOK'�ױ �$�4�+`|KиK����໴$H�� ٭�|\m
5��o��K1�?
+�.��@˭$��o���Yv�󊗩�o ��'�4��]��;)#O�m1�hG��<^k �'�7�V!a��Iw
+�O*=,t�A�
+I��s�;�wr_WV�*ؑ�
�T�hW^a
E
gw��$W��a�>c����f���	Y
�m�O#4K��l��zB�(uS�X��`B�G������>�jB��
��+}���f
+o :
�H��:]�ge�SI��,�WxJ��h����iM�
�b����FKkE�+^���2R�r
]�4s�3���v�ZN'�,g8���߅	�&f��Ps9�:ad�?h� ������:�}��  �a�呔b����
�C�v(E��
�/�DK�ir9D��J�3G�K2����1'������ۮ����fe�(E����

'ȶC�7�TH�5(�
+�U�Ⱦ�L��W��)
�m�'t�i)G�*}�a)��i�~��hj��,8���.�k+S��5�<]|_a!'�C�_
\�s��
+�m�ܚ����G���ݻk�w�=�VBf�^3-pdb���k���V�1�����6WEmNԹ�@� �(����ĺ�
J��J�$��2�P˒
+���9�,rҶ�f�"�?[�	�抪gF��IWX~T  O
�s�;�O�d�w��~�m-N��n��b-m횢��\]�[�
Wj�4�,�ۘ�}@N	���\����������vJ*^l����⋇
�S�$ݕ��@���"�<
�$I����K�B
��W�C۟d0�����%����
�F��!���,�[��$Fz,��p�R���[ ~r뻭_���Vy��X��x�n��<hg"�o���
�lO�
;'��D�@dR3���
����
ݨ�5���۪��N��	%����W,Tj�3������#�
�!�T���K��IK=�vL�!n
��������*���ma�"�	���R�nq(w��V�}
d0&s����
%��	E��S�F���m�&���z�%eA��fA<�0z�0
+f8�O�
+�v=
+��s*�.�=D�
+f���v�+g|m�P�B\cz���%t,����9��"N�����P�D�#
��n�4R�G���q
o3َ
G�L�8�E4o<z���}���!��G���z���yB�B�_r)����  ��m��.h��_�)
+Z����:�\�$D��.��%eo�Bk��L�F��*t���W|U����8
� �\"�nkDZ#"Lɡn
@tP=��^
��X0�U�`�:G�W\�"4WƕA)�\R���#��\H4$l��E��
����@
���
#y� c��\�Z
�d;�=l�&"�v�5 �L~v\J��(�����%�\2Q������ Tk�
jT�s����Q`Ѯ� �3���T�&S
+C8�
���r�L,	]h`b"�o�h@�
i�4,R��-�	�5�V�Fw-`B
�n�5�
e���-�y�
%6����}�6v�$-E{R�
��C�lV^����Di!vn���
��C
�8PH���B<�,
PB���
�q�Τ
+"q��#��m3I%��^E-�xА���1� � )��V�(��d��H�BF��s���k�����l�L
+>JW𩈷̀���
��v/� ���/����9Ay����R
(��}��"�Y��I��$�%���Gⵔ��M<]SdUc}S�]o�@)u�mPl2!Q�؜��i��\�`Av��J2,�vlSM�F2VN '$On���"ayE-d��[�JK
b����.n
+���P)(�/j7ޤX���?t�0AA�B���0����lT�����ÎdNF^���)
-  �ȭ
�o.>������̳e&#X�&�j�\X���o[W�6�5=�{���vn��d7�����J[�$�5m��,�[�,cDкY���x!C�P%պ�!^��pj�6�P7�R�l+��kʫ��fW4Z���Tk�ϫ�S��q�u�̍��G<;�9���T-��A
+����r�@��

�v�_U�]�������}����q�t���K�ap0ɀ�99�ө�: �t�1�:����HuJNВa�f�&�~Q,�`�+ (�U���8𚂰����%�a�D&�� ��W��LQ�{,!p�02NԤ���
+Ӕ��6l�,-[Q�
76��V�{C2y��Ue�-��M7H*N$$�j
̔����r��)�j�&�(H
���%
+��"��HQɰ��)��j���!�q�j�@Ϗ�*!@`CATð'wY�ѻ$�'�
+��*�H���u*�P�@-�vܝ3�!n���Zu�"�~�5��uEm9wk��Z-�)��J
�Ԙ�%UH	NJ�/`��1��X-�
+2��ٖ��x�Vu �j�?*#�0����"����?����tjk�Mm
	�*g ^N��
�ńH�;�;Q�mv\Q���^S
!�j~n	��y"|P���	Ƞ������ݵe:7�J]��#

[�j�����/� �
+�4 �H�=P)��d�0[C�^'�C!� ��F�� �2xӋ�ago3%+
��=|n����"���`�(��AHJ�e�H��w1x�M����@�5Sݦ�
��.�đ�=Q,��e��36�:��� KY�B*[�PͶ)�k1-b+
`P*�09*T����{)3�kSQ�[�6R���w
P$�)YeW�_R[(
+�g�B���Uga�#?c�")�uD�Y�`�,	
%O�߰oa�6W1��[�tC*�-
陡fI;�⚥�)�̃H߇Ƅ�"H�OW�
+j�P1���
+"[��t#
�r$�Ƭ%�[����瑪Ă~R�gs��z�ݕN�	V���O]��F!B&�7τR4"�J!n���Rj��8���@�����e����	�)��J�`(|EF��s�
��0�+�*YQ	82Ue3\�Ǥ���'�Eu��{��4�Ȥ��R >k�#_D�\;E̠�
#1
(@ݢߎ�llt�2�Y�\��9��l7�e�/J4MMe$� W'Yd���#N�j�p!$�K�IUЂk�
K䑘|ӄ��y )��Pd�T�2���=�R��Q��T{Z�U�e (+U;��N�4lvY*�݂�B]�;Tc� *�
�ь���"	E�v"�S"��;���^ߑt
�Q��j.^�i=ˣ�2
0T9:n �
~a� ,%�A��:p1Kw���4[���$���Ś��,��p�u�k���k�Ѥ����()�-���AV������
+'�}+����%\Њl��ς7��9AN�=d�%,�']
+�v�W���� ��#o@�m��#Zuo�-iX�a#	rAI��rOJ�@L=�����s�Z @�>h�X���.1�:GI����Ҫ=j0֘pc�n#i��&�X
��‡����:
A�RO�Q�٥
+"3��g)��|�IH�vB���p/~GH�0��ӻ��Y��՘��]CP���눘��ؗ�xs��%�U���@�g��`R������hYp
*
+
lΤ{����d

�t
�
�-����˝��&�C��@6ͯ�=*�3�b�vRO�hB^�t�=}Vefv�kL5�
�O�J�2
+���)O(
+���	

��S sJ�V��F0�"A9
;���s�}aJ�"7�E�ő֘�E��jp
�`3,:�J��5�+Q1(�
a~Q�@�'�0ː�n*�)��k�WnwD��D�Rt�[jN�&p���-3����(�ےS���2h@�
�I����b��2 �"ja�G��3k�Ҝ��1!pTNz�����yu��Ŏ�TS�4�%k�r�����d�%��-(�'��"4�F���ՊjZBr׊��Sro�m}�9��\���S�0��F�^�
+�ٖw�/)��
vpV��Ŷ��NBĒ
����3p�2��dO��&���
(��Ve�G��Xh���A�?�q,�@v ��hǥ`J�R���
̓ҙ�,��s����a��V��R��-U�gɏ�01����x��~�����h%�P!�x͈�b+
����Q��L��XHր�h��J`�
+1}#K��dJ�!���D�E�l��(+��h��!�����ہ|p��C�
Y0����\�}
��DJ�2��6&Ę�ߕ�:Rs5fS�W����
z^���
$�.P%��bc�S�|'�0���ǜrxN�M��7 '-��&�,wF�3��s�dn�f
�[�
N,R�H�ZD�r{Ȭ"��VO�c�o"힁��)Z6���3�֐:���ݠ�0O
�}n�
+������� �;��|�@~�Ւ�u��Gں��l��Z%�x$܊%��
+�lcA�-Q�jȦ+Y{EL��*�j7�x-��@��YKߛR/0"VL�Y~�f"��Իa�+Qa� ��
`���ze"�a��'{��D
���kɳ�����+��H��u= � ��� �M�,��6�X)�i���ɖ���W9wB�]fȹ\�!a��|^=F6BmZG݅�$��I^o��j�8�
 2E�B�@�S�gd~������	W�Ԑ��%����
ʀ!�Z 0�[��Tx𬄙�HQ�,.~v@�Uс�h»?�����kߨMl֪g��Z���Zr�t���5�[0�^�`��lz��>��%�s�	�S�>1�	,���z뷵�c _ J����c�;�z��u��ہ\�"�i��66���� b
Y�L�O��`<��R�!�Xg׭9D׹��C�~d-a=����KǙ�+�`��b�U��]
;���H@� �$ � �"�Ӣ�aAF5�vA���—� �m27�I�
+�.�]�����Q�S*���=���X�ؾ�TG�R�� B�Xm���iH�>ʟY
3
��<��_��5p�5}��҂�	_��H���R��5s/C���ʫ���\���XIn �yF�����!��2]0Q	�"W#���"UE�!Xu\���IR*d�G,5�U,oJ��8%m�Cѽ�Ӕ�룲0d�]��{��R.i9�	U
�3z�$�76)�}F*�0Q0h+�=�4.�u��
~IBq

��՛Yܦ���,iӖ�3���ͥ ��[(�H���S��0
�E��b^A�
EvD�..x$�FyW R�ETv DV�raFAi��zJ$Ŗ��.����
a�
�cV�Byp�#��uP�B� W+�
+7S^mu��ڲ�X$W�x��y��Y�A	/q9�6J���/�R�`��Xk񊂒���
+�ԅ�M!`���\�ZB�  ��8ˀm�	�4~y�z
+�x ]��D�G5?;�>��#�"r�V
�"(����f}����l+&-���%d�o�@&�IAa[��m���N;Ad�ծ���`8W
�
j9�ZK*9�9S�c&^/�;��z�X��
Y4-D�ig*ށd��i�6
T�L���"!Tj���H��](�Γg�|�t�K���q�
:k6�1c��<
T֖���iAV�.E�C�)d���1#Ã~
� �o�XUU[ku�E��T..�Ȋ�ӕ�,���4e�
y�8�*Tړ3.�r��H�H!/�K�\kK�'�#g�Q!!
�9Qҝ�	����H@���L����������[�{.{��q{��	+7�D"��>��R��GB�S
�%��)c��5�%
+������Ps/�HS4��h�S ���<O���X����n�E1V��E[�q��_�ق����UY�=M����<_z�:I�C��I���y.�uM�nq�}X!g3�
L���%��
+�+2R���u:�n��;�F�]2�ދB
�r�b��La��
�+��5H��0�\9#
9eְ��A�r�F�E=��Б�h�c�]l�
�M�q��"�2ˇI('Cq�$�O�.ͤf�c�2:��'BwX�n)+�.���#˫X��o�
�e�|/�RE��B$k��J�D����ݜ�^���:�ag��4�*�"K�Rk��"zN�
'
�L�׮G])�†�X�̂��.?
+��e�����2,���aud3b�p .��.c�ФC��=�0�'���fV��*�Cm���<*��
)ʣ�*�0>
+V����
2�RNiE�B
�HKH%�`u���F(¯˥�!R��c��d�Ji�UҐ[��c��a]�)�
��;
�
��L�6�R)� ��J������
+�mm������'�/�v�Kc�~}�$&�,�Rƭ
s9�ݱ���Ѧ@z����x�=�'�\�19�\�r#$����xz:9�̍��s4=
�2���w��n�ON����ӓ�h2�>��9���
g���N��]��Ǔ�;ώ�c6�W��Fo�t�?;lN�y:������~��x~n������Y������߾iھ���g��|�t�h�vۈ���ǎ�G��dI3���'�$�n<����V�H Y!
K���@��j�Қ�0
��U��>=�X̘:�e��Z
�d�-�NU��\.��l,d�ߴYL���'�B�Kw��<�@v���L���eJrN(��WN){
^R+���
�D�
	���0"=��6
P��q�Q�5�8�
+�R+A�ڂ�oթ.�c/)�@�
ڼ��K�l�0�&��}�D��G���
���v���3��� Cj�� ��r\G�$*w! 
+�4b7�
k���ϡ�z�O��:�M�3?����\P��X�����- ��,��Ŏ�j�"O������B�u2�����wǡ�
+���m��6к��~�ݟ�d�,���h5�@F�`�<v����"��/P-b{�
j�~����p�mV��T2�]�ٕ1�b{\�T�`�Ph�>����E�VXkPS
Qڶ�OQ]S����b��
Ks �h�F��L�(
�1�=�+z[�����-��t�>�F7�e�̪	��85T
�
��80
Z
�D�b�
�m�ҁ�SՈ�A��eF
��,�
�6C`X��d�53S�i�!���\�
XZ�^�I����=Y�#�p
��^���L`�"�Uӟ�fE�$�;ɸHn��l�M���M��WĔ�*�m�l3��V]$63JfF�Y���R$B۔-O�XkSM���c.t��_����,�l��,D���At&�P���G<Î��� �[���t�
����7�gon�2l+�KL�~�Y���v�e=,�,A6:�B�F�A؛�Hg	\�(�$&BUeT��Fm)����s�D!�d �EZ��}	�,����
+2���BB�
X�a�8b�(Tힹ?f< (��t�,���2դ�	Ȯ��i"��(��Z
����̴���C�qE�'B	Hd�RY�>0�d�Tb����cn��@
�E�AEp�2{��4��*�?�Z�1�hIPy��^h.��Ә6�B�|XM.��+Mc�R����[��(T!'�]��݄<Хi��h�ڞd�*h�o2ՠ`"��QT<P�K{EG�����V��{=I��L2x?�� 
�> I����>3����P�G��
mQ�C�Q���"�Ab��1ZU|V��Kp!��n�`^�m:W�W
y|6�}w;Zj+�jEuː�c���7�
HU+���i������f��{
�R�����-�˺��n����n@�ti�B�~�:ZZ|�X����C~�
+-��+���DY���Œh|-�o�+#q�w�	WHW�6b �K�;�@p�f��tm'���)���`A�ŧ��`
P�!� j��<&AQ�$l�K�S#
H�
��zk�ӸZɥ?J4���@��~�ހY��/:�8�����K
+�
IKPZ���)�l!(�Q#�B۠�q��SV��0�t�m2z�\j��	�:?��׹����y���.�E�N�.�gjQl2��
8H
�@�M;�^t"q�6A%V�Z��g"�j�

+�{ ����u#5�I� #�gQ
�'&*� e�
oJb��
h�|�
R�h�@�BJ�����\�4�@A�^OyK+G
DԠZ�>�U�__�����w�g��f�/���z�ٓ���
+$Ϩ�
�T1��Wl�ڃֱT��������q��Q��)��I5�vm�`�@�
��3_}S�:�>��~��
�B�
��H���w�lق��<�1�o�G[>̹�u4s{��
������ަ97�8<.a9.K��{k!IKk(��e�c�՞��w��A
��ljq�|����ɮf��w��E�]lk��Q�j���P87��o�/�C���%��08���_jr&��t�7n���&���
+E}�D�G1�Z���.��Э%v����ė�O�<t	�gKUyK�,z��Cd
FF�z��e����7�J
l��%g;���-��y��.�t�A�G��
+�8��5Q��Z�}q	��nu{x(j
�A�R�
Dc-�ˮ��dE!� 
���0$��yF*�� n�Jx(�D�$��S�1����9#
B�ҡ�\�1
ڳ�
Dh��-�Q)Ș�r��ٌ�����擋���HY�4����e��K,�2�(���>;#
0
+�:��yq5y~ߋ�=��e���� v^�� W~^��<A��$%{?�]���wʗ�_�iVB��0�CpWY��B>��p6�&��ag�?:
M
!#���Oj��P)ؙپ^8Z4*�R��T}����
nG{�>d�l�Y�u���]�vjslk���
��ɻ��S�$mK��$��}�Pe�כ6νq��Q��p`��C	FA
h=,P-9�1��fy,�=��`�װ�i�H
+>z�i�ƺ�vR*�R��
�.�B%f3#c�:h�ep�����<�V���������N7����"������N��)�>o{�w�4�
6����z�T6���\^j��Z�����I-T���a���`<���YY��\�l����V-��8h,hw� j+��SVg�[W8�d���=�3g�(ݖ�sB��[D����fȥ���|����*}f(���u"Q~������J��
����h�Z�
�!���6���T���vk�A��?��J��?���h�nY,�T���̷6������
�����+Sy�[3"�����K�IR��pg�b*
F�ށ�s����T"�j
z�$#l������鵭��!ښ9��
Ȱ��\]kFCq��ؚ
��;�w4^��kI$�3�]�
I>B�0����

��U��?�� %�ѩ���[ҟ����
�s�A
����@E�(@Ұ� x<i�v�]�
�ţt7���>(=�`qY
�����n�6���ҥ}
�`
+X��m]�*ݍ���:�A�,]��D�*��>}!\Iv��nP�	�d�&V�
�6ǀf�qY�3�გ�Ԧ��������g��� �PЖ���J��(�k����P*	�p�ƒە���2�3Eޢ�U�o���ƙj+W)
A/Q���螖��Rxq%�tKy�V��}�A���9�-�g �F��r0�������J����~��trk6��4F~��vl��y�>?��*�������̓o���f�r8=v��N�;��'�G�Y��찹�����_{��x�h�?~<����t|�s�i<l������;ow�;���,�~�j�[��	�Ѹ��
�)6z�
[�ߞ6/4�tj�dK��issb�|+�{�����s0;]��sl��̍��_�$�k��
�G��/�3}<̆��6x��6<��맇�V��|
?��
>�NlR47��6ng��
��k�L~�����o����i6
������i�6S|u�����;���4����d�_�'�����<>^�����d/�
+m��sy|.���).m����'Qɗx�t��ۇ�����|�GJO�\~���'�/�?�~�˻z��x'o/]5��볿�e�jaw�����s��E�*

�1�.w�?6h�;���E������?���r���U��oZ��������{�1Z��
STf!��ư��O������W����ُ0�l��Ͽ���-U��q,���w�]>ښkn��ɳ�p���\��d����X�tuz��p���͝��y�Jc�>
�
.�d�^���4��h�a6����>�ZH���|t0�I����I��Nr�?
V�0�>>�)R�i|s�C���{3
ӓ����1c�Wv�ht�#�$1��׆;�w���Υ�S����kw��s�Vv��!{͊::����?�=�s
��C�
x����K_̇?
Nn

�0‹���^���,6f��(��+�`=�F�����y���3��8*�qCg��%��
7�
�Ҧ��?��G�׻��]�2�\�=�7Cy�?��

o�2y�G4ȧw�Uq>[���Y�o>
����� :�����c�a�!����Bw<����_7og��a�)ηpm6=��y�?�~{�;X�z�kX9߮o"�s�g�3gs�[t��.�@��L��&x�hL��=g�|0��K��X-3
|َ��y3h���y؟=y[�
[Ƨ�����j������<����
�J�/n}���=�ʻ4��3��@4�|�������)6��^sLӥ1>���z����/�ͽ2��r������o�^C�l�_���
�[=��^��.���ؤ�����_7��Bo���O��E����|ޜ��	�z���������Y���|c<>��4��t�7��p�|�>�<�q���v�pt:�q��[����ba���q�x�<S�o���u4�U�ʯy&�g�sB��:5e��c
�u��a������ك�x���6_�t��C��q
�c��|u��r�w�F�_k�z�#��E��|��7����7�]v�~�]���������~��=�ߋ�����
/������F��a������b�rg��7���ɋ�ٳ��%���
��FP
M��mp��ӿ�X
NX�4��󒷦d/}i���v=z���m@�<��h֘.�fB���
��Bg������W_/V��׋U�X�׋�sO�I%@	��i̪���^/G��r��Oj9*~���G~��Ǐ]|2�~"q���u0�v{z���p�B���\�~�m�xfO���os���f�W�66
�j�x�_p{���|:>=�'}�`�V��#�
sv����.��sG�����E [...]
͆����O�G�n��t<�ܚ�ty��ӣ��x�3�����S�e�V��ж�*6E��K�q^�X�+���{^�������~��{��N��^�^
s�����]�-f��dcOk@��u�~;쿘������d
W����6��<]�NOOV���:>�Ŧ��i��?�E����W'��
+�&������_^&~1��M쾶�^[m/�j��p���c���ٳP�ߡ�*]���d/���%�n�
%�������z	|�K`v���^K�+�zu~0���{���m��G��GGB��ى�t����%�B�B�/t���nK�8e�:"�C]�7��s
��O�(È�=�1������,��#r�ğ�p
D̓
� �9�A�c`
&g�A�z
:��s
�/�Z0g�A��
΃��/���s
`��E���9?uR��F��
}�����
"Z>��(�mA��9	D������Ž8r��TB�A�:o�+��%��������'�r��!��M~ܵ`ei�]��^0����h�C�B4-��؅=짋��
l�5��1�pc2y����鞗��ɳ�q�!��q
��2i�ʚ��;v����zc��{�����ܳ�
�m[���������1w�����O��)
Z�O��V��9ˈ���""��XeD���U�)�EF�{�
�r���ە/�k�'��`|��̴O�����?�\����j�Y��|�������b� �{T�tk�Q��7~��ͦP\��`�_��r�t������bx'n��4G��O���^�Ѕl�5
.c�t�`Q[�⍚�`�
�=�s��`���,�����W1�+��
��z¼�	S�@��&�Ϧ�q}��sm^o?/"YM��^�5G�[�KŰ�^O^o@�/(?7��+S�_ン��G�y46
��f���p4��j^*d�E�X�J��x!���)w�t~��Hn�!��l6C�q��!|�P����t�B~�%�"����K�N�^
^<�K��8��wY
'Z�������CPƾ��W��}m�^b~�KL�������c���]e�Ў��f�������]e��R0OB��l��q��<yQ;��i��K������+_���<�%nA��*�畮��+�6��CƢ*�IX4�����NY�%eV�����
JZ��JZ��
����𗦽:>�z�V�3::
/l��|�m�
��'S��V����c��t�����~��{�ʍ��Ǔ�+�\x��ܚ
|>�ܚ5�&��]�_
6�ŭ�i>n�ͭGB�Υ��

��߳����6�����.���?�+ռ���Yi�Хϧ�Y�
��5��������z�^ZB�����ӛ���͜^\����7�/t�
���u@ [...]
�h�t}��
c��'9��?�>
5k at 3
��'�ib��چ��fn
'퓆�?���'�����O�,�c'͆�xL
jFOP�p8]A�
�U{�[Ó�;��Y�'/���=�w�-w0�W�`��?mV�嗙.n��t>�
L'��Ì
��˸:���ti��-D+��k�0
����w��if���؋v���j������,��b���ꗴ�q�5z4\ܰ���;
���f��Bf��{������Y���+��=�&��ag8����.'�<f�Wf��p�m�0��d˽WN�U�3o���N'Z�����M��ht8��������V��|��
0Gl��s��8�/�W��ώ����<�μ���ӧ�q�A=
�6��p��o
r��7
Cs���.5���<�����
�gͺ�Xg��L�-�����G�W����t��;�mW
w���t6�wz���h��W�y>��������4kNg�x4�:��ٶ
�s~�tڟ�v����w|��Q����ygz|2j�g���8Jg�s�,m�
G�;��l���
U�USvJ��xz��Wn�x목�f㈕�u�D���Q��͍�cV��#˖���[��n����<�ޖCZ��_��1˭�ĥ�-h�9�K��,�
�a�g�ش3hdl9�ls�&�GS�ml_K��
>3ե��h&��	��]n�In]]��ᾰ嗭�7���c���;���ɊG��� �3
C���f�k|����ӑ}1���7��G�X-c��z�u�h�}�p�L.
'͌����
+�,�6�l:MO�/�n��b�g�h������`:�S�0I�Cن��G�������d:j6��S ��u�v����ь��
�1����q���w2�����q6�+����hx�xxj��%s�O�ΆV��0���g���{:�b
�͘�?�X�A����]�Sm�[c��G| >e34+�x�xi]�N�&��O�M����`��\
+*����?�:��~�s�G�Iӡۼ�����D1����A~�Ӽ��,�k6�qcO�˹������g�C��ү'��߾�T����i|���?���hՙ꧛���������0�ÝF�ݟ��OC�+����~﻽�wz��X�ʚ].�>ֳ�
��+�Xi�Ǫ�
�[���h߶��?���^�e��O�x8z��d�����p�3��`zr2=�><�9=���ϸy�s��/}��3=�
�W-����R���?��{���l��o�?�PM���.�d,)�Ý�ɻ��˥�Ѥ���]
��3w�'��ivx���?7�j4���ƨ���{Ow_��1��9��f�{���:Eߛ�-�k�o�
�ۨ7w�;�b?���t4<�c�{�L��o��C�Lv� �z��e�M��̆}�%�|��� ��$ws�/���WUu�N^7�~�83��6�S������״�,���	���|tt:^p�-^�u��N���ag`�mޡȪ���!�^�?oY��[���� 0��"G�g��Đ	�@^�B��I5��s}lAD#�5·'��ݳ��,?��:�s�xsK��\��K�ɤ�=��'�G�����}Gͽ�O��Y�����d7��p��s�??:�]��ПZ��iL��o<��Zs�®n��f�ʭ�<=9n
킛I����q��bϚ3�;����V����W�|�v^
GXy5�������?O:�N������ƣmN����ѩ�xoM��7���fm��x�>?���'�76?� [...]
ʟN�֩�?|:
o�<I�a��
�4�>
Ύ-t>���xt��N3&����Gͽ_t�TU8s@��[��m�O����u�y��
��th ��A��ó��ug8�C���8��AlK�|y8��
���qm�����a�n�vy��v_�ŋ�����–����`o`i���ڼ_�W���X|H
���8��O82:>h������ެ�����
d��<�
}-�	s�������C����v�4��Ӄ�����+
+˦�d��:�	f�t>:Y��
G�GK���>�v��뼽{�3A�}R=}R�W>�噏�\/�㔿�2�W�cv�DL�(N����	�j�||�ι�����{6�]���F�q��]ͮq�hlv^-��6j��������<l�����a�/Y��>��x�w�
��»\�3;ܛ�
�=ޥ���K��z7��۳]���y��^����s�	vL����z���xa�n�t����޼�{�өY؇�u4��9��pr�w8^};[;�SŸ-�v���xi�z?�����g2|�_����5h��?��4�)�_�Z���~�
����l�o
I�>��n�<�[���
{���s��1=
L/�1?o���t������V�s���
|���֌��d�ۦ���ɤ5̷����@�y���r����Ǵ��<��N��
�a������X<C������U�'�CB������`�逥���ALJ6P����u|������l�ʎg{��Ɗk։�'��<i׮��{u}~��Rf�3uu~���p��Ӈ��s��
���jL
�G�����y�$��D��}n���`tr�?o��4[7�����0W�r�w�ֵ�g;}p�����̞�Ew��|�,�m��“_��y�lg�8��"Q��ll�É�b;~Wܼ�a-��]j^މ�&���-�6�6_���˘�3o�<�Q�\��|pTR�����U:�������|a�
+�+����
���ř����'�;ߡ���w�|�;t_��m;�ꃞ·צ����o������tr� �m=�tF�fA]3�`�m3ufk
�m]����Um)�s�5��O�.�K�
�Vc�f�������îa�lp����t�sz�5:��|����_gu [...]
+��j���߹�=ψ�00�=l������|l���M�3c�Ϣ>맹0L�
+��R��0�w��n�ƞ#@{ƅ�[׮?�@R߸�Y����"
�o�=�&�λ,�F❜(�o#�r�3��ݓN;
��1�3o_�|c2hf���m_�mڡ�M'��c��w
���˧X
|�L�+�6�w��RF䏣�/�[�X?�&܀���Wf'�NgO�/���<��E���G^��49�л��qFh���O�H�0,�����3��I8��]̦�����ak^n7��Of�g�̶4=c�	�
+q�t;��3M	�����ȥ9z�����s>��H=׳ڡg>�yn[�
������	�q��/g�4w7ӧӟ
;��ԑy�i����;�>
Nk�]�?�,�y6G;��5K��������b�S·k'{6=�
7�P�Y��vW͙��<�#+A�\��Ns���Ic�wN�v���3B�������|ܬ�\�秃�v{7&��X��W�4+Dc�w���;��'�ұ���6�
�F����.긞�
ަ{�����kK��%4�;ם���?;�a^���r���ދ�<�;�n���܄���3l��K\�0�������J���իϺ�����wg�����ˋ�����
sw6;��fm�q~�ceM���8�o3��&v��y�ť[��ze棑�����m��%p������agZ[�7��7����
��nϱm�[�ιKIcG9<�7~�ˣا�?�}|zt0��m ������n;��
ܬ������[?bŬ?o�o�@|�w�s���rK����"{�c��F�%��9�g��,7��;���ϚM}Լ�+k���, �ơ�tzй��l�YP.6x^ς�S�[_,�bil������뿼�����������4����Տf�
=~����^�Ż�~����*����ś�}��'~���_��G��Ay�����I2��͵G�&����������=�4�cz���G���b�>=������8����������<ڸ�������o�W����k�|}5������ۓ��|X�yz�Z�՗W� [...]
+oͦ=ѴDO�G�������
��h*1�|j�^�(�\v�� -�t�Ȇ�K�S��8���2�k0��E�]C��=ȤS�=��grӞ.n��kMy�������y��b�2>w�Ԏ�u*\�ݗ�L��g5>spdC?��Dl�~
놔�=��8��=L�)��~~��ȮG�x͍

E�:m��5{�K���)����oi5q�]e1@�R{g���|�RQ%�xZa�ئ�fn�&��=���k�I�'�.P�������D|.0Ӆy���L,'�NS1r�8Z
�l�u�7��靹�
usq=5:l�U�z@�2c�Q�j�4I�/F]C������n�1l���D:�:�%[VO
����h �;
l��b�w[�`�UC?��$�
���$��V0�
d�)�#��r
� RZ.�������~Dz8��ը
���p5�<�ʠ���¿�N��6A�p)����	�ʬ�g�w�4�/R
�\7Jj�u��
���с��M���M��z·����85����j{L���iuȐv��MH������jt�e8�eO�n&�j�����T����ՠ4T�!ϩqi�øj�F0z#2-��\��3�G�
�<���rn�Q�R�b0^�Tc4^��d0��z
�+5
�*���8�H�P)C�
j� ����H��.�:eک%�E��a0����2�g�(��B%��
n3��Q� E�S��̾�#\!��0�i�;�
�i�=uLJ��@GH_�Q��s���8b��K$������D<�=�P��86<��k�ݛ������F��
�F7��k����p��13�̦�z�͙:�8�� '��DR9��@�s��cX��R�^��R���(�Ο�܏�\8�ɽ��Z&
�ɩ]��[��C���	�hk
�j|m��=�vM\���f�twgg�����zojd�ڮS�$�k͝��ڱq!=d�Z�n���9L�;�3]R[���T"��Ŷ�T���.W�N�QH��X>4�
_
�bn��8�Z�Ŋ*��5pcϤ��	�Hw/�/�;���˪%wT��a�����{Jޭ
{�X٫֝P�����Ul*Q<���ؔ�╯�a��\�l�dh��u�h+�
_�3��ϻ}�S}�|i�*��M�m%�
�~_`(k��/�
 �T��-ݠ�^�ҌLIp��8�����d*{ڱ�d��~��5}�������7\�<H
��H�M
'�V�����rK�
���#Ll��GSޥ��7�vN,NK\v�zNov�|c�;W��y�������$�;�&�%�,w�'�9\�M��w��t�
���F<�7�Qn(�Mzι���4Di�%��\O�ot�-�#��F���e2>��;���ؼ5J4^w�wu�~�O��:�
E��u�s����.\�$tUK�S_{��F���
'PAk]J
=��ug[&}q�舞G��#=�c#���T��|>A������tc�$�hkO�er8u��02��%����[�.Wza)'/�l1��ݺ��G��0�#���u�Ti5b�+��왤�����Nh� �7Q��AL�������Aa7[�9Oj$��2_�TKt*>p����l
���&�‡��SMt�#�]W.��=�3ʐ����]��
�<�s��؈-����s�)o&�%��
�.�Ʋ7�ݽ����?�m����T�3)w���X'2��"�������3s���V���NhɆ�o��޹j�z� O�s�QWzw�1 ֹm�^_�o�3���N��g����?���I�
A��\j�0��;��
�z���f�:t�{�
� CL��
�{�7H9[�G��bos4ߋ$�1T���l*�
;H�������+,�(T �s��Ͷ�
4����ZGnR]3{�X���)��`�­���d���\���ܦ��J��:�{��S~e��T���M��0yxx��Sh�_(�
�\(��?՝]�2x$�8�Z� �,���)ݨ���D���Z��JlJ�^
��1,���w��  H�D��w��S����h�/qE��,�nG�o}~�0i�e�<D�-S���u�/	�)�4����vz�sx���hWzc{v*>s`$�7{��|�"v؄��K��Dr����R�;N6���B��n{�S��!
��=֫Tv�t�--d��r��C�J�Q��A*��W��n�Nc��W)D��"�ݝ�{b�nkE�i�0�S�-f�G㡌�q�j�H�o)�?/�FVT�m5zO��{�3��9eO⣋���jd�Va��瓃�b}��?m)[H-	D|���a�7���Sy�r�����1"'�k��s��&�2��ъ;�Ʈ�v�5��n⑝�Cj����ɏ�#��lG���``4��^��K�*�x�v��mv���������Z�Ujt��47�
+�A��ǧV׀�����H2\xڗ��
�'�N�N�Y��g�b��d�0�
�ZE�ʾ*��֨V(4�.#I���h���ΡU0	��z;�'��3�h�@��ǖ�t�s�*���O��2�ˁ�x�p��iiuD2���\j3��h��EB��3�޶�$�뇙�P_�Z��t��>(Q�14�=���I޶Ĩ�� ����ż�b��{f;GR�4/6Jǫ�4ޝ[�O��N�֏��
���gC�YF���l[r$~�s^g�3��%�E?!����퉟awqh�7�5֟]�
f��~��h�
���|"�'�ȁ����=�(vN�(
+����R;hg�������ӻ ޅ6����.oJ�+m��
�b�L�p`I��+H�Y���+���49
�7��
� �
ù�x��i(��h~C�9kK���g��
ƃ�����
+�2�I�/DxR�#��?	��	���4�
�r�oO�L�E��!|���GhZ.}FU/.�=�̵���(]_�^j�� ɒ��$W1�Q�1,惜�zU�5��c��mR�D�L
�$��bۊ�
%sH�k%T`jew
x�Z|n��+5�jk��"^ �.��4�sb/�w
ukȯ
�v�j{��չ�"^
!��N{|�/��+�s
+�Z��VΛI��Ӓ�gd���ӭ���������3ַ6�Fsxx��ϴ� %�Œ-ۑqN#�fs'<}}�Z��!���<��UV�g=�._�}��~�r����U|�{��g�Л������t15b�g��z���v�+rzH��\.�Y\�db��9T�Ӏ�$mm��5�
[��\��ٕ��b���aw�q��hҩ*#
+"d2��'B�$Η���۝Ü���:��]��n.uR��@8|�Τv�ۧ)�w��?��O�

��~d�-��L�W�FT������$�ZQ'
��46�\�<��E|
�xG⴯�#�9]���3�{j��\�nGƛ��M!�f�_�K�6�&��4|�x���
����t��?�v�'���sՐ�ǫ�}�v�~�
I�,��$NNs���+�
�U��I��W&��~��H�̴�kt(u`�D#q���4m/f�������=Ll0���ۑ
+endstream
endobj
28 0 obj
<</Length 32476>>stream
+">=�N�X|��_��
�qBl:�zzY��d:W/R��.l�Pv�;0�ֆz����|.{�u�]qDT�!��޽i݈L�sѠ{�/��^��T��2�����Y��M)h
��Z���2�����u�k �
u"�] ;t���¸:
:�c@#rH�Lm#.��
�Lv�U��ӻ;�=�tIߝ�v��o��J��>�����܀j����^'bמ��e|?�6������$z.������� �
����#���I
��>�.�^���tfǮ԰�.kgt!

9>
�y�Wi�'�=���n�
.�Q{sp�GŸ<����.��u����V�nk���X8�n'
v��m�MJ��6�.����K�Ө
uGo@�!9����p|6�Ae
�����A�Ɏ��u���,�] �?�TnL+����\1�:�fO����myP�p
̄�����k���
�V�nW�ս��ju2�V{����]��(�W
�B�}׏qkЗ���EHt�~>q�v��-�p�n��[��E�� ���31o�ߛ����V2
�1o�w�

9G?�J��
9���,�H���	�N��X!���}ޥ�
��oT:�_�^
�>Dn\�Ykg�(��͊d7�[;�c�̷׹����+,��
�q�74k�{���D�t�
�z���
h�$U��|8Ŭ�{:x�gպ�_�.Ϋ��hM���Nxf�0��Y�jͅ�
�S�Z�[��X��_^u7���n�i�Y3���c�5�ֶ�2ѭ�
+��'oyŗI�'
�5si��M���
�昵�j:��qwC�{�l6�l<����@rn��,tY2���^��)�
�F;�������w�w�ک]ͯ���VG)�B�b׼ǨVTM~�*7�V��5<��kcպ�߈���k�H;ۮ�7�VT���B�U"ê57���r,����'�j���l
8��E�Qw}�hz�Qk��}v!�ǨuyݗY���Z1��*�u�zf
kͺo&����c�F�Bo��Vo�p5�;Ky:�
�Ya�{���$��Z�=v]��ٱ�\+�4��N3���|c��n�Z[sׅ�Ӷ�a�����Q��\q�t3'�-�u����/�:�Y��w
k��
�õb�V�݉��H�Ukҷ`[��:�v3{����
+������A��z�g�ZG}
W���!����V
\YF�]
�q2k�܌���|�s]�P
�xb��d)��4�u��5ͬ�|�չĪ5�ۜ��qw'c��j��4�5}�	3j�䬋�1R�vk1�k���c
��,���VW��l�slܜo�Z��Z��3�R��Q����N��D7��g۠=�ay֮|�p�
j����.�Z[8�j�J���e��:dO�q��i���̤�Ժ^�
���yW_n`j��r�y��g��՚��ך?
�&U�;ݥ�nn>��ُk
͏�i�ڶZ��YŜ�W����K��aTk�Q*r���yWG�_}����ؖ���F
��l[�}�k���]��m����T��h
2nkG�=w
H��E�'�%�i�
]�/l� Y�F\�{&�s݌��b�?��c|w���\LO�w�rZ�p�otx��`��Q�����}øޜ�
�،�::z0�۳�1�ydb�����]w)��+�Y
+��p���jzP4���
����n¹؞?N0��ܛ��ܚzW7h���ɀ#�0�����Ia3�b�]:9���x�&ί/=���/�O�r���u��һ��
�22m{)0������_��['���
�֏l'í�A�X��[�['��~��lNc�v;��*�H
ON'�ᮞ
a�&�y^���R��W��+JG�3͵�`RD4���9���XK=�P�h��Vwjf��^ؘ�s�j_u���)�w�&����nJ�
�<E͙��
+ժ��
��n����<�Wj��{<��@�[k���j	a�5`���� ���mX=�l�S��ҵ�
k�B�S��f6<�Z�
ĨI�H���i���78�f���ZARj
jj��] ԃ5���v���ZC���O�f�Z�:;��Z�n�֊��f�A7�2�5��̮�5s�c�
+��Fw�m��j��Ԛ��j�4m�X�`�
+��<k���Z1M�
w���FB���&c�fO�ɶ}�s8�������@������n@�5�#i����Nzл$w�xl�YU�~vr
�[�o�7���0�ӡB�=���:���&�vl�$PS{/��{sz2��Ox��S
�_�R���A^��9�)�3q��d��X�h��`����IU����k��S���#R���F�;:ph8�
���R�&�>�\�;�
5���g���NP.n�Fm�l6�Y~���m�n�Rb���ɨ�ݨ�N4Á�����A���cf=D�a5j{)ş����ܸ�
��%��G�CR
�d��?^�s���СT�u2NjSڂ0�5J��x�l�K�K
\iy^���m�jF_z����sS���ʢ�ʈ�F�/�T(����kP�ϥB��N;#iz��U��av�S�
�/�6Y�-ϒaR��Vi[k��AW
eq��t0එ����U�9bO[k3�N��X-��oo�3��{C�����2&���+�8*�Bl�k�.
����;��vjyz��k�F�.klz�+,�=� Ge�.
�}ɮ��K3^};�K,�i�v�a���3�#A�B�N�;�&�I�E\
���	�
+L�,
H$[�
��v븟Y����5Pڰ�k�,��$V�#Ƹu'��oZN#WxNT5
�|>ϥ��T(
�Q{M��ʩ̥Ij���Z[ʦ䁄A3����M�B�LP�w���
zM�m�qO�E�
��զ��x�9$jcMd����
�j�d=хz�+�K_TSCG��ٶ�e5L%���iLU���S
��1���M���4-u+���L��K�
�v��%��Zrv
	!��T�0^�9Q��DN��W�<�X�I���NϮ� 
u0I��=H\3,

I��9�:�%X�]`�u��#�D\
ԵDR�Ic��HK�R�ܒ��dX��Ny�	:T�F˳K���Tw����/�K�{�g�Ԑ=U,���c��,[�1�$���5C�o�&ٽ�iV-H�h�d�F� ���l� ��C���e�o%�ƠY�"S�0/C������Y-���WL��R͈���
����e�.�Z��W���3^��p����.��"^�tc�#��/���,�#���0�8:ec�1����|�RT���,
+f���!wD/�+�#T���s�
+
!�Iu��SW`$:��Nu]�=
eti�|�^)[
�G�C��f`6�f�A
Qp��cۡ�E�h��N҆�g�V�
Ջ٬(*����o�v�F1_�R}����Q-_��B+�����Z��Q=WdQ(�{��Zn�I�b����|G��.i�a%-
�繤�jT��4�����r>)�9��,�
P�� 	��D�t�]ڠԯ�ٲ G�E���P� ��
~�qȈ�Ҽ" 30іRh(�W-�I�!��ݫ@Ϝ8�9��i��J��|���d��PK��[�6���
􌐒piZGcY��
���
UUI'�ڌ~��ܠ(-����2�@{9^#���%Y,�	�&-�j��nyn9��m�j�F���e
�[�Ԑ
iT\q�V8e{���q�+[PZ�j�ԇ��P�y�&D櫦nD��U-h�Rj���m2�o1�~q�+I#Ќ@;o}>�]B�,1���RKlđ?��ŌUKa���l�Eu?�R���!��4��ϧ�:
+�J�:���Z�Ƌ+���k)WY䁅4T���'؜.�i�҂DDD�ƴ �
+2��5�\���Ҵv/�[�
%��X3��ڈ9���f�ь��j�,)MH�4Ѐ�Bz�mEp�n�o�[[��FA�z���
�dk�ҿQ)Mtʯ\P%��1i��
�|�Q�n
sTjTFP1\����,)����`j��
kZ4���L�
t	YSXFE���:�w���<h����X�%��s�y�
]�{�6�W+��QN�e��-��)�B39�N���	������~�h�,���ik�B{��kVC���J+V�e�A�CSr�ƫ��M]�/�r+�Ɛ;�]^N�/

/Elx���S+
+����$ݠB:u�>��{��B�ޘ��l�t>~.��6�|�\>��I:?�O�o*O����5iR�H����5iS+O����5�S+M����jj�����kҥ.V�����������|��^e:�����6������壭
� hvޕ�f���g'#�
��Dۤ��S�y�X�
�@��Q�N��Lu�į�a FC5UN�:s�l��1P�C�O��F-a�:�}��4WYC�U��@i��P��S�@I��h�ڄ��@��ޠ��${<��g��2M�#vh��n��y�f�	T6K�b�M�ŗ�t5�fM�<Tp)/
Τs�ė0���WF!&�IJf��
�iQ���F/H�ck��
+40��QT8Z
+*��%F<
��i��b�ui%�
_u/�Bo�.1-P&�qI�PF4��4�u;��B�BWn�p
�Ģb ñ5�J-*{Y�
&Q��i���@2Z�.�p�ȗ1�s
+5v���2��Lӗ�/5���f�F�S<ϑ�Q�ؑ���(4��v�9�(,���i:�M��BӜ
aD�)ݫ�b|1Rth�G9�q��+4㤝J��I)��ƻ5���^ܓ�G�C��iB���}�3M���=��i���(C-�I{�b����g�΋C���(a�WK,�
}�PD
$�[;u����X��jT��A�
+7kOt�

+l���lgFt�Q�{ˆ��l=��AeDx�L�|�6�U]+a�
;]Z	s�,SW'^r �^�(��a���p vZ�@ڴ����%�x�t�j�����&Ceӵ�48It��� 
x�.��W�I��&���L��d�)X&[�%��e�a�īz�
��z3�)��2l�^��}"֛!��~��J��Fʷް#��Gjd�A��� 8iD�z#�����Um�i����u���#|�M�$k�+X��F1��ؔ� ��B��X�E�$5�w�*�."H_��$Crh��A�CFU�ͦ,
�ը@�.Q���p����p�*o�3�46��g��a��WUF���VX���H`i�&0����<?��Z�e��:uဨ�6��'�����
9��~��:�uf
�GP��<����Ref�
v�KΫuf^����f����$wE��g
�V��<�fb�2��<imr^�3�d#d�
w��<�e��j��'SnHgE�y���/v��8�84�&�ER��2G�	�,	���
+�W���H4�R����7�wCA:��怄ώ�*� ��U��{��y��$�A4�z4pB:]�Q������7�M�v9Ƙo�o�-�
�k
+HGӘ�1���Z-3]��M��q��6[
��X��08(��J)ո
ٚyA����Ml�4�8feq���:�ou�b��;�&�vCTM�d׮k�$�J�a���u
�d�����J��8Q�]����j at DQ)�c���D�&�$Y�90�
��l��K@(��bT�鵛L��z4LʣhZ��B�$�)�-ˤX��<zЄ�?�%�i�4)�L��QR
^7l�[��<�� ��ZUR�jO���Z���l&�S��\T��v/��Cvu�1�uFH�3��ؓ��f���B�R�Υk�62-��+ ���t0,�C�Y����
+ŤJ؅d1�&G��Zs�z���A�|�zb,���
�K���	��b�md65�+���+�>d��dfi-��
���Vb��P� ��3�tG�-,Oi�a��h����eV��3�.������D'��2>�8��p[{όc��v�M��
+��D�����yf��ᝮCVF�C�֤;��;@ժME+�z:�#q�iwp�#���O�k�lw1k�eF�����:B�-N��&/�=̮5;ݶ¨�S�1y<��J���$6N�.�kM��3Z�=���� ���o�^-��>�sM��[�޸@����bZe����!���8�TK��KI^��i|�.8��v�.&IH�=�N.0
\+�x��������Ĉ�B�J�D�
+f
"�*:^ϠMrF~-��6���j2T�Z�/;X��z�f��O��a�|�hd�Y��OW
x�$�M���C����
��P$���S�J
�U'���l�J�3���F�}F��=�5L�c���&�U��Y�O�bҵJ�3b��U�f�}���T��W��"�O;�$�O��]fb��I���<�F�}FY}���J��$F���*��(a%���j��g��GtϚ&����75J�3���	P�H�3[Uq����P�lj��g$'V�,f'�%�&��
Z������43��lЪJ�3�°#�+N�
+PL�ʠ�]�)����ib#�։}FH���}Filx�j��g�b;tM�
�#���Ab��p4�7k�4��HXU�[h��r�:�=��鈁��aQ�Wq���?�Ҡ�d_	'X~h
+]�S�
��3��Ty��J%�=T�g s�J
'sk&m�� Ud
ثfE�5�
�@��@T�ͪU�6m�� �|�L���N��M�1����$G����C�6���Fjj%x�_��
_^���?�ذ��+�s���5�	eb9}�l}���6>���.�
��$��T���36B���+3���?@��:��kbeቹ��C�6D4����]��P�MdB�%rԹ^{��DW�B�
�(ո� �O��!�cK�JtO���r#���'�;�#C��3�r��� �Qє�&j78�ycS�)MS碜�̷ys]�!W�P�ٚ�Z͖���L�h�+\��dG��F��M��}�R$ݓSP-L��]�R��)�FT7	
å����a�g������3�2�7�Ғ��D?MQѓ�(f�
͓}'4չ��M^�6��
�
+��iU%
+;3j{^�\o�Ę��ڈ��
�p)�B����
+N��g8�}�9
Ud��!���U�`�$��U�s���f��6k͢PJY)��b�ɜ%)M�k��6�KG�U�p����Y�G�s�
is=V|�_�>���
��c$_�T�22Vq�����Wmr�����W�.
���A�s���o������ŒC at 4ap�پۭ�����R'3�w�uGĶ�Umq�T��Ap�
+l��d�G)�J�����j��
�0���ښyA��8�Tjb������K���
�z\�z=*�r>
Mc�R1Fs3�ϘQ�l�r��*���f�f{�CQH���֩
4��_��	��&R��4Hz\`���$FhSI�C���%�d��DbLvQ-f��5�e��0�}9���;bn'ar�����2ћ�w�BEu��x�m�K��`�MIPH��	:1f�y�pv`)��)/�v��M��W(&Uv��d�7��1�PNw�O��C��-87Գ�Z�,ϥV��X<�A�$]��d�;
+�W2/�8�6P�E鎦��:[5��뷮��[��C��8�;EJ����۝d�v9;���F��j o���Xh��y���2s�iF��65UM��6[m�Sk��j�M��*(�R9r�<ȡ���>F"b���#�����]�}皍��)��SC˫�,�s���&9=.s97g�]\k����
��}^>��t�S'V��Z#9͹��Z�K�xإ&�
+�{�
5x�O���
b�:��s�

���
+�ܜ���ŵ/nj"�yљ��
�:/ˈO���3ĆmLa� ]W�&}� jVY!6�/��T��4�)��9zZ�Ӕ�$�M`�����*/p��
g
���
�%�D��B���[$ r1ZF���
Q��P9JU�YfG�0ۤsE@�y�X���&�q!1ҢRUHK��.KHײ��)��>1ҵ���
���6��j-�ӑ�X�5
+���Z��P�֪��m���j{�x�w����5�H�e{Z�c#��f��@i���7&RI�.e'p�O��n
��Z���nj�I�l�M
̭�|�nT
���:�D��Q���O]�ʹ:x�
+MDB�|g!�Ҥ��
vY^B[��RJ�Qe�%n�b(/��,_c�e���T��[1��t�t&R�MDN+3/QK�ErK��i�TU�����!^;�H��K3t���d�'
����,�0M�}�X%��>騒A
1K+�bf��R>��ߔ���XZ%��F�<e�$���L�̔D�|D�Th��G�I�)�����9݌a?h�
 #��(��H#����22��#R޶5�|��4i�
����&-�̴N�����&�!u�:��L�]��65��fUzX�. f�E:��A�j}X����B"���/�a�Mt�׋wX!K��B]��Bk:�*
g2/��,x�6��ÒĘJ<�$ڮ��&�v��,������
xh
U���
*�J��ŮV�
x�&G�w����C~`$N%�Ł�|i�08���
֞vhl����C~�TS��
X��C~�P5�9�&���x���֪>�P���n�^������&�
�
+S��%�	���zS���FIv��3�O���C�5��l�,����"@U{�<�Ƨ
��4΁��e�W|�!��C����p2V�;�eF�dkq��a�v�DeW�
�9�P�QŁ�\���37�
xh`���-�Z
x�?�P��W�F������Vu�!�W�T��Z၇��ٮ�2<��4t�{�!��ѫO%�<�"�JRz�`ʅqhoU
�\P����Tu�!
#]z�a�CR,��̘�
x��]���6
�mAQ����r�)��z4>�BZu
�K1Ս<,�B}Q%� Uq�!���&N"fY
VOӄ<�
?Ҫ;�P�0��m�)����J��
x�*Et�	�M3Vjs�!�b�g���L�b�v�"����.��s���
xh$h�Zm<�&�&
*�fh��
�x�U遇e�:+=𐟿�d��f�W�y�i��(r<�K�4M���C��Xꐬ��C�hJ�
2
+�
x���`@���C~�U�����3�Qb'
�
@�������I�VZ遇Ƽb,ԅy����� [...]
+�E���
+�|��:��^OGogpq�;�
v����7۶�~$�
Zm_i�
�xf�ۺ��m�]lKu�^̎����<�ٱ�͞ӽ�������ft6�X�]/���Ff�������ͬþ��t9N��O&ϧ\}W��X1�1k����vk�������~��X�]pE]������1�^�E*�ꝲ:׳�k 1y���
�|�Р/3���e�.'|�ɉ�|�xȓ�9�l�
�U��
�N�"�0-V���K/�l�
�#m>��>5U�478�u�PL�d�c�����z@&9aі��1
�3h�h��:�OX'F]������lu�;;;���#}g�����mkvx �
��tU4UkiO�X�	†+Sh�
{���u/d�� V3��jkd��R�VǙ�"
2�d�M��S�=C=����������Z<<�j��+_��>��y��#1oa�/��;ҋ��t~��8�>^/�G�)��@bٕ&�
�P7�]�����J�;n2���?��۟<����ܿH�^G}ޥSO`3���y��= �C��~�����iph��
{~d��f�z���
r�h�b��c�
D�{�W�
�o�
�n�.��߿��t���6b���1k
�|�n��w���p�7�
;�
7���������{]��>ꆧ}�H�1��}�g�Z���\�� �d7�v�{
���U���J��{��S��\x, ����iyd��
���#��᨜�.��n8	M��n����$�(������
+�ϻ�qy�gO����
8½���u)��
�_�l�#�:6b}��v�J�(�GuʮNGE�z	y�����\U���V�w���Ã�x���
�4�x8Vf���W��˱B|tqqK�[�q�w*�â[��@*7 b�"�{ �2�'� �;�-�;�ߚ��fu��@ڱ�)�

vCݤ�͕�҅�f�gH�ǿݼ��
+�r,)�[	h����;Q�\酥
�fG��
+͐��RY�W
R(��
+qИIT(<�&S��!Dq�GR7�S��C*�;�X��%�b
�{D[G0�p�Kf�HW@ ѯ���*]_�"���v|
*>�}�q�>iT�lZصD�p2:H;+H�Xȓ��?��O���|瑱1��5	������
y��8h:-��z�E7��=�!
�"oj�����f����u�8k��`��׍B�`���HyV]>o6���$&$	K�$&�4�hl��@����x�Ս�=
=@��c���4�F"Ő|�!Sg�%u�/��5o%��L�_�$͓2
t�㴮
W�}�(o�L�=�
Te
�]k��P[���3p�eBr��3
j���n������xV.��NI����)�!���y��}�~4�)7�"���2��E�[/l1�3��x��,��O���!p8�
%
"�U�� v�
+���{ؔ.
9W��
yw��:~�
[����귝 R��MhyE���gR��x��!�t��Ϝ6�
�.�
+�J�֚�%�-�
FNr7p�
�$
+�E�c�dP�P5�
uC�آs
w �R��,=�;uJԘҖ�Z[��8���3ф73�O���ɐ���>*[Mxo;\�@@-þ�>��*�5��F�
�j;�n�Ǩ 27�etU8������1�h�r
��M

��[��|�Fzf
�,�>�s~v��Mx�>n��.wig�Ѥ�9��j�E�oJ��v�G���W�Q7Jڇ�)&����>�-��S�$�
+��9�k���������o�&0֣��N"�
b`�Nt��Z
S�
��+��҉�
�~����]X��%��
�ŮaW{ �9�!D����.i�Ǭ�҂NbAo
+Iv7����b�4h��cw�
S�`{_z��k
Z����?�1/	:�=U#@�ip���������ILv쐨vJ��F�>E{rɭ��
��*��"�z
��q<���E�T�����R��r[�J����&$�Q��K�߆�yO$�	��]�H4|�;ss����
_�q75�55x��~����e&��?��D1u�{s�Q��{��MG�S���{�����
JD$Z�d�
��}p at Q"u͞��f�S��A�5��
�5b=����~kǾ��>:���"\�Y�( z�M�ٖ��'nҮ����uVՒ��}���N�d����u�v 5�h5�5���
���]чu����i�b%�Ф�aU��iu
�
Z=�kVT�4�͊=fmOE&�##�_�Ճ4d���qoZݛ{s�q��<���l0��p0 �O�KfsC���ԥ�xf��9
$Z;�˧�]��>�E����%�����]zw��VTH�4���.-ٜG�f,$��4����5��m�RSu�G탼���Ӟ
@����
�^ �2?$����y�a\�1�WnlHJqv��~�V�Y
Rɩ{P���r�D'�װP�@k��ݘ�Å�+�8S
���%�
5�� �'�%�rD�cۭ�S�^(ȍj�nG���Gd��S�A���)h�o��TC�9b1c��lQ��U��Iy��;{/l��t�DY�v���]����FAT��(j�ERW(���re3.�1��F���m.5�7`����%�
�9�?
g�m2��)�M�mg`�D�w��:�Y��wƆ
��*� aH;���p M��vP~��eH3}:���`g
���~{���m���	؆�U����{��&�
+�Ư;po��A#7�L�ʠ�BDv3&D
+ZS��P����j�<bH��'Q!o'���B�������}'�,l�����;&bi
����6a׈� ���	o�/���s�v
��dO�
p+���&�w�.�jXR��QI���
�'� K�_���5���������+��^������bn��A����׽3:T"�_%}�)q ��K�+I6��?�~2H�}�����ڄ[��!��.
��1���x�u�
�Z��j��L�50�ޓ
m��-6G��*[��_rn'�3����r[
�2nv��i��J`Do��,�ӆ���dhy�ĸ
^=W
+��n�I�dL
p5�M[�q��ۑdu��;�ﶯ��w��.��xOcڇ5B
�%V.b�43t�Y��e`�Ss÷m����-�xW1�%lۑ��f�d�+㢶����c��-��I��5ڸ�w>#{�
�aq�M
��$�Җ�Z���wᙠ�8���Y�dذ+D��b�i��6d��AgY�(���h�o�-[����Hs#^����G��õ����U@<�vup�n���2�����9^i�o����R�;J]��
�����<�^
+I�Q>�en֋�#�0͏�����֮�V2٥Ie���a�#.

5H��J�o`9�~�~�~�-��$�\��!.����Pq�h����Pa�h���7�(A4� �N���
!`l���=�
���@_��o��#ݛ���㋱�'�р��>�����"w���C]c;M
�d||�qg
��Mo<_L
��//��O����-������ޑ
�cG��m�g��l�܄&n65���ῥ755 `���}R��O§��}��;�;�wV�}w��н����^�73ۅ"t��"�M
����w���ˣw�&�V���B�H(!��~W8����t��#�;�w��at�����~�GQ���7rJ
+���{�	nvj���{'���wK�
�^~�����W<t��_w���-kc�-gc��՘��4��y'꼷����su��ź�Ƶ:7��v;^��F߭�x�nw���K�u�=�c����u��q�VG��-[�P��1^�hL�93��
�u]�ck�k3u���u����퍺���u��{u�M�u���
6_��n�"�yo5���nw���K�uo�=���{%�a�[��[m���:��5�07xˮ`
h[VC�2m����Y������t\��|�𖯋5��.��$��Rmگ{m����׷���{
��؃�[���[�
�3��vtuJX�5�$��T��V�h ��UL�"�w0��:�x�n�+��B]���ڛ�Җ��g��Y����>my{��q����_����Wܾ���N$��
�t��P�Z
+xh��C�]
�oD<����5���5
!��!��mKZ��O6��0�i~W�����#�֏Y�]��o:�{��7��ay�U���
�+�e���

��5�n�o'0ր��G��%�6��E���C�M�&<��ᡒ�6��v���S��ֲ����[>���
k��|W��������AD{��n�˯*_�7	=��WkC�Zc�M�@Vs�p�k�Bל��0™V/8��{��4$�=t�pV�d��m{
�i�;��S�kFx�|@�m2ަ-�W?������B2�+���=l/��|�
�(�SwB����XSq�_Gt�;ݍ9
=��|�гu�1"��
�|�B�gC�o�d5�3�?߆p�,�e-�Fr�{1�F-�h�w�O5/��a�So��_j������y�n��/�W����zCc@�gaL�Z%��N�N�3{c����<HF�!9
l
Al�X��f��~��<�׍�{
KZު�2-�ޏq<T����'�&,��x��|?��\�!��X����s?�>�
��������F�"��XkoP�
��ig�T��p���I�$�
B�.%�L����$\ɼt��/�1�?�%
��q�5�ӖOb^J����
k����_��T���g��,�����W=�ڻ=�/���<2����4Z [���蜠o��Q�层���I�?��`K•���bz5���w+X�z@��W�����3�3��i���Rx)�6�۪���������߰�b=Ȓw{���_2M�q&�2��D��yn��q&�L"�_�C�1�tJ�]����`
�!X�D���x!����G��s���^�R�5�{�kh���`��Z>W�n���M�/�oY~����<���
�o��i�)ѴvY@|��qa-�uήF-΢�g��R�o��X�&
��Ø^��l�0A����u+�?��
\�IW�?�i�J�g1�Z�|F�[?�e����r�wc���>�~�Ӹ�u��c�m��m[~
ѻ�ՃM�n����
t�W?ئ�;i�F��;)]��8��3�G��1��o~��r���v
+�{D��<���uDc�|��Z�N�o�����C�����{-�]�k�m�������~����o�o��7-��i`f
����s���
�/��O���Z����e���%����\���׋���}}�Wř� ��>OYF�b��,��>
�2�a��d�
��A���B�⹇9�B�
s���;�-�_�����?�;o�"������@ח�.[�����@��u��gug-_�;��_u�-�~�{�����y
h��?��DEf���m=
���X�7�7�mhۊ��}��w{Z�)_��=���h����S�u޹�}�Ѧ	gOb���8��ݘ��9�@th�����?j�/�g-����]��U]����-_��M���߯տ��_�%.�|]�T_h���떿��j!8<C<n�#��C�?�Ɏ�0o��s���S4�s
+]üd��_�����o�]��Ö�\k�n��7��+�e�-M�C�nljͶa��;AFC�&�eA>#8� ��d �
�yzt���LjF}	a�/�
+�=��M˿lY�F�3�OX��S
��ߣ��3��4~���?16U�����B�I�����$�'aO�}���0/E��Z~
�7����a]
�6CY�-X�x��e�U�Y��F��f��8$�&�7B����	v���b]�����:��1�W.6�8�W�����c�p��'��F
+��}
a�i��'0����z
+�L�h�=!a~C�����嫨���B���/_�
t0�i
�~��~�\XW�
L��=��`�
(x�#\��C?^��/��V�²Z���gg
}
+��r����z�w"] ay�>��
l'#�� �O��
��R���!|�3ƈJ��`������(0{���/��+,��[�T|��
�<�$�
�;��7�%�
+D��O�G����5�sn�����_��X��_�/�ڝ����zKtOٯ�=��4B�Nql��;A�;�%@��2���e�����_���3
+����_���s2���
�L-��p�x���
9x-�_��h��M�LjF�x�
����^�r���W)�46��@�9�cl��A�4�w���G�w�2����
�ܜ[���떿�����i
�DqF_O���ݳ
+�n,
z��,�w�~
�;��.�g���;�=�=�����XW�2]
�w{:_�/��9�T|w�
��q
#8Nt�=��~�T�׏4���~v,���&`�"�·��S�
�&�g>ŠUf�{���{o,��?#����+Lフ�
�z�ё�;��~��RL��3֥5x{�/��s�������ݞ֗�
�F��6������v�?�NЈ��C�uq����>�I�}�А>s��̰Ήy�W42�y-�>�bh��������}c̪�VtZ�ybO
��y���]Y���sI��>
a���Q�~O�����4��台�p
+��xCz�,+x����^�<S�j�А�?=��	�)#~(�� �r�E���!�i07�
�oꊖ��&뜲^��/ٲ�g�b��4���M��W�d�+�j�;��
�POt�?��7�OoW-�����?H6�A�������x�o�]����Br���
d5?�kط>�|-�9>�u�
��Il
��e��@N[mA�i�>@�8-6 Oz�&�GY�=ep�X'm�eH���c}��o����v�N!�����K�O��8%����/Z�R}�=���oi�#>Na�O�:hY���Ո?���O�ۀ�
�	��-dY�$6����C��Et˧t81���Wi����
+��e;��/��r�0: �f*���{,�_$xk!x��$�[����5�–��<S�8�c-.�{�b�����	����A��{��
�Vp(�O$o��-�4�&�RJ���2fx4K��CeZ|�%�uH ܩ��?Ǽ�K�/`
��
l,�횖W�$٪�
\����o�j����إ<[C����^繭�?�]�S���bY�c���K���4��5��1��s#y^?�<��'����4�'��nW�l'X��;A>�z,��w�/������V�B�-B��:�j���0�7yY4XSs�
T^�엂�n�b����X/��F��"آ@^V|����
F���y�™�g����^��=��uX�P� sD���l'D�������9��<�Q]{�F���on��
0@�H,$ٟ��{juP��E:h��5��^ q��^@l
����_c�Z�y����
�t��+�2��Ac��=�T�Ld��%�}� j, �uW-��Y�+�M��,�^�ʒ�כ~��NC�݆ŋ�j��Q�?���S�
�8o��#iy���� ^��`�ֲ,�%������X:'
Cf6:I�N��И+�?�'�^��rLޗ)���c�/���y�_��A�݆GM_��s?�o��@�	�
W�w@^��5�w@�CB� �\C\�A[~O�|Y�K�m
�^��	X�	�{����(=���9
ݔ�*�
%�ݴ|]�%�o��0��6;l{�o�7��
�MD����{��7��ͱ��v�!HhZc�N����9��9RkW8��>0š���v5���L���x��kf���K
���z���ɺhZWTlu�n�:�������{,k�\+��')~��W>W�Vt
���7�`?5B�M���Rs�T�a
���:ࡥXS�
0�8vH���t���D�9m���A�_�W6�L
]�є
�؇�F�+�%`l��aM�i�
Eb����Too}�s�,"��n㥚��c�pf�tP��2,�
fu��7�X�|� ����%�2�n(�������
�z�ȣm"��^�gSq�-z��˾r�
���ZR̕�3�<��������y�
��۸������I�4:���*�@�h�?�%{�W{=�<�e��4�a��%
�f�,o
���ɏJ�5��_�|a��/��3�k�I���^��=o�\�ۙ��0�p�m����=�h��W�"M�x�4�w/e��9
�
+q4]�����x?���h�^��s�t��I��xX6j�>�@������{�?��v_b��p@������'��=�i��m	�@?�
*�g�������-��=� ��Ų}�е��>�
*�5����F4��k����,���R��ʭo*�n�8b��º�j
��*W�߀����Ǟ��
�}㞓G��
��{��`g
�f낷�h
�Cߍ}T����8�Fr
���Cy�S�e$��sl�g#��G��tP�lNS�6a:�D������������}{ǣo�z�7�y��^���L���p�5�~�%)����
C��
���7��J��!~���S�ЖR���<aAO������f�k3�(z����'����_0��cdN�q�� x{'��;���������|��r����4�!W����6�=&�krLчq��R�O)�P�QA
>�`�Tl
*�0�UF���Eˑ�x�Y�z�j��X<�O봸SbL$���M��$
O������[^��{_��Ko�M�7��3�3��P����U#X��XI�_��o�;�< Nb�H�j\�>/O����:#�Gwz�X.V�x��3���{U=��D�U/5��Y��*������>w�ޫ?������K��8#{E�j��
�^�'���O�"����i9��<��+J� +�[3��e����,����a�u�h
�?:~SɿV��xZ�S�x�$�}{7�����W�[�_|t=�0�nO�=p�D�w�.
+��C���G�rB��8����עy(O6��=k���7<��
�f2��e�m�~��
J�{���k�tTI_���{������W���۶�
7�w
�� k�� ]�c���쭀uQ�`]�`��X�C�'
+>f
o������x���
=_,
��Ż��X1�K�0I���9��\�כ(�A�S��b�A�o����
Ͼ��:|��{X�gc��+�
+�@�i��9C�~ {��~@���W$��@�����?)WF3�Of�8���`F�֊��F�
��si9E�,ýM�QA�{�k�Ǽ���;�����
<�wWl$�ֿ��N�
�%��0#�{K��CW8��W��"!�r� _
�=@? ���������f��3��b�
��`O�#�0�/�U��{��Ѿ~����S�o�������g�{w���v`8�04͋i�
�
�f�_��
��&�`�=�o��Y?��*�llO�7�=��d9��_��h1�f�d�W�q
+5�

/"�Ed�a�&�o2�>����K���S�
+{���I8�IX
��&�
�)���
Es�?��tU��/�<d�.j4�"6z6yx�ɀ�{�8�r�1o
����d��Ơ�v:YG}���
QuTE~�>s�w�=s?��;;�����3}r���e3x��C�fk�~ �ن�<Q���^X`�=k���&cM�D�o9�\OK�K�X��Ѷr�X���:�c��m./L�l�v8Ygx�O�a�ÝO?�����������n��$��@�˻��}Ur�;��x�d����5ࣖ�c;�
�W���7�W�a�EW�d+3)�'f<^3"���nc�Yc�@��~T�Q^�j#��o�?�@G�O� �/�
d5������d�R�U�(�}���'Jl�J޻A��_�͉�o�����4
��-~J�,O~`��Q=��DG�h��:��7��}a�cΧ<o}qi\�����_(�ٲdcے��N����>*ﷀ�U��B, 
[d�sP�V��:x���'=V�����r��Ƅu��\�u���G��W�Q?x��
���$�}�:�C/��\�u�����<$������t������a6�+W�W���I�������'y
��7�"��L��(n���Y�ͬL������$�7�So`����"��>�~���_��-��-�������
�ܩip�1z��_n�
��~��~���a4.<��8Ql��x��L
vxtČ6�h/Ō��֎z�tob�
��$�@��T�&��]�4v�4�ޘ�{���9ڍ�k�|�N1�y|XG���� ���H�7:U9|@3.&82�'f�1�]f�Vcfk at _���g�O}y,[�^�Q|[�
�
�S�&�7��!�}��t��t=s���?֔��
��7g�΃
*��'�ْ��.��̈����>�Į�7u$�@����<���i���~��A9r��3�|������=O��Π�7��}������鑆W�
o��n�4�3��Jg7�ob��خ�6��l��g�}V�}��QT�ٌ�lt��^Ħ˚;3
hDK��T�_����y�{,:�Ó [...]
+�_���(���u"}g�o��9d�

3�GF�H�b�
f��cS�
��.cMc�Xgx��{e
�߾�E�����>��zS�}�U�
���=�?o�a��g�]�ж�K�5��ua�쳒��W�l��]ѹc�I�ؗk#�W�nX���,����|&f2�5�
w���#}����M�|��=����L�q���8C��BΦ=��
�>
+�B>�68�
+�m�_�?B�
�$o�k��Ϙ��r�o,�e�keD�e�����M��f}7Z;FkL��fkJyF�ý���K~oHG��Y`}A�ۧ��o~��U8�C
�O|!��X#g!5��ɴ
�P�v����
�rިq�Qߍ�N0_3�c&����P����U�u�:��$��V�f8d���$��1���}��
+>��9�@W@��O����P�7Z
m�\o��cQ���c���{�B:BN��`?�e)����i�>��(�X��͕2
KA���c������g���W��� �Y���
N����:JG���I�K��#/�����b�컠��n v�A �
a>�f|�6�6y�F�mWx/ݯ(qmoj���7�f~�r�V�
�97���g�p��7��\�J�ԯ
���|��� ~�I68lC��7�m����C�`
b܀��@7 ]l����@�$���4?>rHa�6�Ø�*���#���mf�Ct
+�
w��F^^b�e��V�Z��z�.%
�qUg at x���OA~���oX~���W���4w��ohm���\@�ֈ>�D�-�i����x/��G�o`?)��>��
�����,g|Y��%��鮑�$�
v�e�2�F�a�+�Y[�:Yx�=��&��ۏ��𪵶w��S��
8���C�H-�sE��
���3�HN�@H,���a�b�����[9k�Cf�7}�"v} 
3?l%��G�X�aa��7fd�u�� ~T�Q�� ��OJx���
�>
�'K9X{�R��@��Uֈ]�	��$ĶA,%9��S8�
+� �m y)��w6���Ə%��h�(�2Q�D�L~E������{�zJ�&�}�)NJ ��Ý�`��
o?��«>=�£�2x��
�[��$��G����`o#�	}>�
+�R�پ�t=��g�;�5,B��\=0?b�<Q܉�߈���Oޚ嶍�R������a~��Soï�Ω��Ps^�
+خ�i��]x������X at O�I|�����
R|�פ
 -
���� o\YX���`�ZÊ50�=�y�L�þͦ�1��`�W�o$ߖ,Á�b� oF���?
�o �}���G~b����R����[�1�iC�BX�<���?�l�s�T�
��:|��n��r��F��mf��J���xd�"��Y;D�*��i���2
�$��6�1�@���X_���gb/����?��� p6��F	kOa�.�m��6�H

�p�+�����=���`��њd͟?2é��`D�x8���U6�ѱ(�V��M�Re?�M�Q�M��L�/��@�-�h�ԟ�h�`��@fC�(�Q���6���|/�^
+�ug���t����r��
W�y-_O/Xs*�ۢ_kF�
�5����J�ku��w��XG�����M�|}�M�?�x�5'��m0���@%t��:��o��J�m��8~wޢ�I	z)�&��7��_Di��z4���h��S9qǕ�c�3����Ө]z^#��A��������{�
2�>����~k�/`
�����?ށi�,ù	�>⿥��L	b�3
��A�|�情3Q^Ƣcf�4áY�֯H��K$@)�E����
���~T�K���s�?����O ��/��gR/<���ǘx{m���g�7�C�Q�Bh�l��e��Ojl�����@�}/'FW��xx-����l�Y�e�e�[V�y�F���ho�X�I�}�4�(��6o�O�>��x|�iq�
��*��>��:�1m=ln࿒��:�g$|I�)}��weF�Dh�L����V�Y����
���"�_V	=4����Qd.�%�T�� ~Tl�b��g/��/��g�/�n���X [...]
+r�@ ��g ���8�ݾ��*�yt��o����3
�]�k��+͞-�f�c]fq�f�i��0�3�~-��
�|}�b
ƛ�/|6���.��G|%{b�7��Y
tQ�Z�D'^:ެ�p~��7���8���7/:<��(��y�"��fs˛W��ΌG����(��p/�T9G�U�� }�x~
+xK����
�e�e�
{���"t�=8�ж�`�ᥟ�{�вm1Æ���O��G�>ϊ�-����\��w��_��^]�����.�� 6_�� ��g%�=��_*Č�2�����6�K-ߋ�^
+91���
|X�9��n<|����D��s��i,�������=���,^��6�e��v������U�l"r.��>�7��}n��
��z��^�/L�ޫ�m��.�Ka�#؃d7ȝ'v��՜���M`���(�t��w]'���xd9��NtmWJ�屒�y�x��Dd������?����o�����
4�
y�u��ދm@� V
��=bA���
4��"y
+��d�/�3x��x�Ț��H�"coT��
ёj���<����J��]-�_K������|Z2}���7D�~a��/�3<��u����cۇ�G���o
�
�8^����FΌ�}�3�36���rhO�����W
�Y��y�����Ƅ7FFc˛�����or

��U�o�����#���ǟ�L�a�2�:o��8�X#x���Ke;��ɺ9�j���a�\ZU���͉�o�Y�fX��O�k˨.Y4�Ǭ,~��&�T���68�c�m��C%��o��h��9.
��l\��}��"2�wjh�R���kCg�X^����g�|E�o���7�
<Z(��ye���
�f1�f�It]җ�o���)�
�x��W�C���g%��ǟ��5�o�7�Lӈ>�IO�.l��� ��n��ّp�2��X^��)�~��F?'f�i6G���a�)N���"k��Nx����بL�l����D���R�
|���c�x��o�8������訐�'�4B�>���O �}����
rLɹW�W�3)&���ƛ3���f�E��h^�l�,�0�¯���������fu(:*��;帤�g���>����7���l��7 �~i�9ǯL?�����T�}�`
�h��1m�8^�����n�~�g%�a�*:7f���F�P?��9��vT�
k�Y�N��"�d�-��ڣ��u6ߏHy
#"��(�}���g=M�7�z����{����0�&���qIO������G9��nj�j���
F��_==g�7����g�c�qb�+޺��3��'3�aެ^��OJq"*ވ|�2����ހ���̳]�G��p63�N�����OH��X/^
+v7�7�o?��_���0�%��ZSf�~�9�G��a��EK�>���
7f}e�M=��6����ś
�,o�%>�g��o�^�!��_�|��k��z}�u�;�u��=&����w���U�
��D���׭6DPoD���3��4ݨ`�2i�
6M�8��V�
+%N8P�$h4Ze�R#FEQ�	��TL*ߒTLR��C���^w�o��������m18]�}���
{��_�5��y�����Ԗ.߭��}���֏�?��5����Ϸ���a>�����|�p����bd���
��Cz��_s��:��vx{��[�����ۧ��r
x��=xӃ��cZ��ԎjL���m�A���Ʀ_�͛��I���2$���ŌC����3�[C��c�^�t%V>>�w�k?�
��i���-�m�����ޓ�7�KD�
Nkm�-jG�;?ś�n�k�g��^"��;�
YTcp�{
�lY�1��a)��(�Yc�2t�~��Kf_�up��h��c��7�)��oۄ�$6o/�߶�g��pv��?��?{��:�E��y����X�gm71|���"�:�'[;>�`
/
(�B��k{�}}2�E�}MN��S�̀7�߰�o�-|�=�}�����[�8��uW��v*��{WgG߭�F\��u�X�5H�<�=]��?��iL�3$o�
bp�����ʼn!
���X.҇�~��g�
���5.�9�n�Ho�S������[ o�{���-[�8|��5P�s	gI�@�w�+ܮx��X��f���T��� �ñz����mbq|���w��.=��X�

�%��!�	��+7���ͳ��x���k-?y����=�;��R��<
k˻��v���k�Y�����t/��y����]C>���;>54���0㒉
S1׏
�Bk�c��:���~;bx+į1:a���S�7݃
+�N�w({���^b�;��R�}�����\�i�S;�|)���u~���y۹�.�۷������{��.�q[�o�
���!=�ݳk�B�gH�Bk�C����w
�
��o�9���ǧ��o��b�3k�>���
�W�����$x�œ����q)s��n쏹d�]ݞ��w�
�m��#�������a�d���|��W
�

�3�åk��]b�Q��aO��������|}��T�v��#5�{Ξ��Wꯜ��dp�������q�y�?��m�3���\o�G�����]ϸ�F]���/�|\Y�1������]�t�W?��c���Y7�~+Vt�̭'�;̬
!�K.�筞��
VOW_���;;�q���4V`�~W��m����2a�7^1<##��>��ׇ8l�>��08��
���(C�v��\|��g�o�_`��m
�L�\���.�{2�"���|���5.e^�g���7�+h��GV|��E��<�x3V?B�
�ˇ�X{�kK�L|{�||��eoV����ٹ��Kl��vυ{O�f��gT���x����+��B�v�-_�gj� �|�~�]:��5���]�x����^���X��8֗���cH}��
��oS~;������<��n�t�
�����]=��}*
v^�/S����7���Aso/^߾c��۰~��η�(�
Czc|x[7.N8��
�ӥ�!̆d�§#���-Y���S�׃7�{#6����ܕ�z����z��S�%����7k���	�R|7օ0��o��!.]���б���=/��P{Bm��Vb�s]W��o(n�ՙ��xf
���_��z��-|؊M?/�)���/ػ����w�5+�hq�ߟ�� ��x����d�.}_s�����mh
b�Ζ��#�t4�k|6h}��>��������-��T�������<7���<?��zr!<�M�!��y��W�����>�;�=ߌ�iY�}���۾���^��d�-k����aHGCc
�?��¤�7C�'&���C��a��>s
�
	��_���<���,r��
+��e��</y7�R���;��A�	�+�9���wh�w��ȻaKɽ�,˗���5�g��u�ק����
+�{�����L��
Z�0�_�v��R��9$��t�������kl*������
+�+|��+��-�����}Ϣ0gp��uO)6�o|5
+�׈K�Wx�����Z��
�B�4}�p�-C��'.�p�(����03�v,�G�~�d�����~�;3��{)yv�R�y�Ζ�n�Ύ}O7x���������
-�v����T;J
�uH�[�J�Y��9�u�A�LB��Xn
a����7�u����8�m�1v�
£��ce�j���yn�46�l魛��>k����M�?"BLj�Fy�!o��5�|��y�Ea.������
�M�m�{gQ�Ά�u�1ꏗ�}��A�}t�g
��k�5����5O�\X�-��j�<��G:�}� ��b
�<k,�3%ǫ~�y�'������Ng�n��v�c�8�}��E
�����{L���Y���O�;��w��W,�|kbm�й>��f���U
�B���s(.
j�
�~��b���`[����҃x�*s�	��sc�����R�Qpf��]ϸ�����P1�s�x�}���Zأ�
z�~�J�k�_�|A�NM�M��c����r��u��:�,��
��=�����dH�Cr�����p�k�g
�\$��8n��[�'L��}�l�Q�:��N8���{�ڕ�Yn����o�~I�={~�5�=�����c
�����!]�a�gO��d�B�
�>b�雫�Ck�}�쨾�C�7tq9^փ��;���>��lo����y���~�Xر1t����
8v(n��[>��
�8
+�y�:�s�
��
�y�����<�߯�xͼ��쩿��6���#���s,��0X3x+?�k�t�k�kR��l�u���qOS̻F�
���
�ąGW>�5�!�[��-�Q1�=���1
js�7m���5��X���Ƕ���뙟g������Î2O��وl�ٸ�
rP���+
�o��	��u�ル����sЯ�p�{����7�ٟ�
b֢��9dCb8�w�E�¥1���l��1r���)�Yϳdo
�6���3�����]�wk_�|o�3?u鳢�_��b�5�uɭ���Z/W
�=��:
�0׷�C���+���͐L}ra`�7
a�ז�<��!|�z–���Z����ޣ~� �Ũ
�x��������fߎ�M�`��;���'��3
�so�i��ۍ�`�����s>Y��v�|�/�q
�w�.|��b��v����V_ϧ?����P��T�I�G��g�ꎳ�L�r���>��qe��
��~F��~�`�&�.�����R���½o4��w�]�g����׹��e�bt��9LJ�L����[l���_�qf_�1��jk�3�k���l��=sϘ��ˆ�x{�S�����x��+�#]�N
�P����� �`�ghp�� [...]
{������;�sǶX��ͬ�`�<X3s�g`��6x�o3qB�s��c���M?ֽ����B�K�`��ôCq'mz�+�uƿ���Z���c��	
�Ţc
ˏs�Y���s��.,��0��>
��iN�
k�$^m���~�4�+X#��^�!.���/_���oG���!gݟ��\
������M~v0��ik��
\k�l��^���x�x���o
��!셸�5�}N������9��t�����2f����
�FY��~�O��v�;���~ѹ��Oq�k���~���,}p���#�o����`L³�[ll썇�hL;�:0�P
s¹:��
+ٟи�9�7F!,�td�z^ctå#�����q��հU�r���i>��}��"x��о��Ϸ1��5���[
ijn��%��7�:�a�G���w�o`c�1��m
e���'�6�?듥
g1��5vC�t��0���1}��iz��ml�yn��{�Xk�.k'O�{$q���˜�����p�"X3����{-�m��K�����`T�;��������'6��ء8�o#|x
ٻ>��b7f�C�
���|?���|��x��i��v����g�=�C���寞��8r�_�p�)1�S׀l��1�5>���wc����o��6
~�g�G�=ŝ�?�6Sϲw���Լ�a�x��^��ݐ<cm\���p,.�g,�]�ч����Ύ��96v~��xӘ���������Wco��u��>�n=�ǹb�E0����p+� ������a���(�������џ��og�����a�[
���.�
�=C���J�C96����`7��Ӽ�yj;�<�M�{��=D�>eƖg~�g��j}l���
��ϒ`�M�?�g��GN���
���;�
�=8��C��)6���M]������Nqw�Cf1Őo�W~)�-���p��WC���/�|4�n��|��G�����10����nힿ�{X+�^ѡ��5�Y��[X�1w}q�2�e-�跴�}H�����\��y�wjg_���z+���݆y[벳���g������q���c+c��Ea?
�1G ��9m��u�[N����2�k�����X�?�?�
3w���=m�H����3�^f}1������ƿ{{�Cy�v<�2�۸�n(���+���@�??/䟹�5�s-�y�������ڽ�o�pvs��!�����3��oy�����m��ל��Ca@�>�=�}b��cY��b�����Cֱ��<�<�/$� �w�G!o|�,�24Gv�5_1��!ܹ�-6��Q
n��ɐ9d_m�9�ec��=��7M������=���i����3�n�i�9��vi�k���̇��~��?=��_쑠��ށA֪�=��> ����g�rx���BcZ��r^���co�� [...]
�^��[�������)�����ޣ�`�p
2�ւ�ww9<r�&�%����2�<�Cn����M1��^o!�qՅl�+f��.3�ٙ�ly��c�|b|�e�2���L���w�ώ
�
�n��f���;B������y
9h��ѧ;�ٓ�3u�[a�M�'���̉3���ϳ�
�^��L������S
���n2s�]�A^��
:��M18�^`(��ͯ�8�K����0�׵��4q%}2
�KlO�ɧ3w
��(�Dn��Eo�K��������!���if�Gw�j�ȸ`��q�?���C�O�M_)���w�{g��Aco����@O��}g"6w2��m���c(�ukBo�쯉;4�5<�ǡ#��
�I��؏#����D�����i��Hm��ב-��;��.�#�G)Ƭ�)O��&��J�3_��PX�q��߹��5��n8���t�js�y�Ǜ���� ta�&�5�dl.s���vk���ْ�ٿ���am
�i���fm�Yo��<��31��ϊKkϐ�W��˵��
�28W<m�a
+}�-p�YS
�h��;�Ȝ9>-
��|�}_����c��x�3�
�e srh�~c���/�X'���i�ω�<��<�_��'����'�c8
��g���C��]���c����y�������ݺ����_2àY/e�P׊�k�׬Uָ�Z/�
�Y�|��㵽��o����)~��Gt�K���������nm���[�괝>�������g ]4�M��껩���4��
�l���!�z��������
"\w�䲃?��'��t���� �>�svW|�)��
��Y�4,�#Ʒ9�12<8]�Ǻ�'���

?[��ؿ��&�����ʛ���#[�j��n
+���i�N���~�0�Xi��F;��m�K�%}��j�3�o��DŽÈ��I��3d�>�g���J��fx�I��W��\���{ؚkO|�Ø�E�x�
�;������á�{�
�)��9$�5�S���&ϧ6ؚӵ�0��g�\��ad|���Z�g8��紈O�'�ݚ�?�����S9�µ��3x����
������>`�+�����Y��3����Elk��X.�WBy5���=�>�=��}yՓߴ=$�h
+}�ف�o�h���@�M���<w������4��a�O_}��A�
J����[d��6L>i�r$P|��[�g�Y����ݱ��אk麭�
�u5b
o���C
�>&md^�`
?���'�_�
��P[�c����]1�P������o�����B������Փ����6�X�����o�rό��-<&m�?058���:)`�ks/
+z`0����H��
�x^|Z�F?�/}��h��a��O�y�)8��+k��B2�u�� 6;
�X
�X�1�y=&
5'}F�I�KÓ�|�
3Og����nO��¹�:z]�=��g;<�����l4�"��k���GW
��|Ǜz��&�l����
|���&�\���������ˆk�
\ׁ�h�Fl��]��.&�c��G�v��y�.6��.&��SƇ5�r��}��k��O^������e��w��'
a,v
�����W4���Y�g�Lc�~���������p-�K���v�.����Ҿl������=�7��b?�Ӂ=��G
�_�~(�
�	�=|��җEڄ�"��z��W����;>�����d�ӡq�sBL���V�.�����>]������|�E���V�v�w���S!�fQ�c>���m��5�
�*�e�?<7�X�-Oy�#������������e��~��`�>�_���o?��CLF��

�}|k7cc �j��.�V��[l�z}O
+�/ژd��]x�~�A!Ι^S
+��^��~S1u�Q�\~��
�w,������Gm>��Hj��q��]W.�=}im6��6ˏi���:OFy���,�F/�*��
We]�^,�u5���
�����kJ�
��>gi��Kk�XZی��4�.��c�\���$�dzvS6m��|��y>�L�b���4Ÿ*�4��Y�ȉM3��E>�I[&c9<�t�6�%�H�Q�f����f\W��d帑��i=��>ͩ�d��ɸ�ԙ��h��iތ3=��l�󤲩'V�6�$b���:����¾|Ռs=�nD]�'�۬�RS\iڟ�y���-bʓ���S�r�IiI�槜hj�
I�c�^����R&�g��%�	��d\5U#
���$F/�&��Smt�T*�,��i�<'"�&KG�t2m���R*d`���� ��e9�KDҤzDz,
+�F.0)�BE2�����H
��'�e�d\�u2��~@����R�5c�_9ʲt�d�
�I�˪��De6Ad�ܯJFԤ"SmAYW��ԊE�&֞(C��2�*-ABB��\*�j4m��)i��<�j����u�H��k�^�(�!O3#�R�� dI:�"yi~�J��d��i2���U�Mf&��Rj�q�'�J��"w�D [�#��|�9-в<
�~РT��!K�2+'� 2�9��dP�j���+��W�M����t>�s�.��J�w���D�"��i�Y��(}H��>L:,��/%=W<�wu��K6e�4:��niQ�ZY��4i�ՠ�Y!C��Ŭ���t
e�
���V�}�Lt��gw��R@[�mk'y]k3J4g�����8�d���R��t�L�QʠT:f���!ɬK͸�4�j�e���TH$��L(2-�JG�ё,����
��!�(IF[��4��.��2ibĞ6���<
����N��߄�R�-J�D$�*+�XZi夆b�
����GE�055;9OF%Cæ����&vz%QߴHf [...]
+�
��ЋJ�Qi�BI�].}H�:�u7X:4���I]Z��

��
eZ�h���I����
BP�3wC�U����
��)�E�yP碦e�KM*v�h��D�JP�
8�]̔U�-y�I
p
��4^<�T5�L���h`M�I���?OLh��呑h�
Y-O���D4#��d�8�fJs[���q�2�"�
+ȪB�,�
���jbl�%��Re@ަ
���5�of%�[�6�T�C����DrM���J�@|��6�G�c!����җ־̐F]�w�N�UE=�,b��Cf��ė����ŦM�ƺR���d�7�E45
�ː�aM7^bk�6ˉM����=ґ���dh9~��
� i��e��������
�^��Lt(�x)E��E�  �X##N�N�|^eė�#k��T��N�+�o�W=%�V�V
+7	6p���J��I�W�J���PX%��Ո�&o	dZ�����S
�J�\�6#
S�eHB����~HڊO�Q\�ā���kGJ��R�D�8�:���V��"�TL�
&Л�BVF7�kj:��'�J1�"2�Xlu�JR�vsG�-f5;����mC��Y�sZ�w�%KkK����\�	.q*&w�@/���\���,�����⡋-��>�D&
5�
xRSem���A��K��A�'�8 B�b&�s���R=L��4Gk�$I	iDO�S�#g��	(�,m�pA
C�t��D�Wm�%�0�R�L0�)j�W��X
�#1����<Q+/�a�UiDti���a�Dr��^�D3��>
+0��氼�H�
+�:�T�v�L�aV�ꝥ�l��KxX!��$fK��+��Q\���T��:i�=<��-x¤
w�R#�\n/w�����Z
�F�̉�FɥV���a�UZ#�k5:W��r�����hz�B�eĬB�:ڹ�fڴ���P�(7��D��Z�S�9o�S\`�F�:h�L8%�l���0 ���dڒ$��n�aEѴ�Iو�f05�4�s�
+�֭�%�ŤTn��I&�
+�,���M��;Wgc���H�0���e��1��j�T���ɤ5�%~��A�h�\� �F
+�ΫR	Q��\�'jZ�
��F��UK�E^4mԏ(ԈOZ�S)�wRh;�l�>����� 1YJ�`��Ja$wq	�
n�TF�uF�.�boiy%+�5�Tr�¶dDDli3)F�
�����v�,o�m�ջ�<��]�^v�V���m��n#���?eR�]���觞��M�m���=a󕻷^�s�eW\��ʫG�k��gl;�ԭ��Gݡ'���|j2�H���M�c9���W7���W��xԳv\���+w\�bx�U;^�k���˯ؽc���ʟF�^���W\�kt�
�x5�4=ᨣNy�S����Ep�
+endstream
endobj
7 0 obj
[6 0 R 5 0 R]
endobj
29 0 obj
<</CreationDate(D:20090709143709+02'00')/Creator(Adobe Illustrator CS4)/ModDate(D:20090709143709+02'00')/Producer(Adobe PDF library 9.00)/Title(logo_camp)>>
endobj
xref
+0 30
+0000000000 65535 f
+0000000016 00000 n
+0000000156 00000 n
+0000038957 00000 n
+0000000000 00000 f
+0000061346 00000 n
+0000061413 00000 n
+0000431500 00000 n
+0000039008 00000 n
+0000039406 00000 n
+0000061825 00000 n
+0000061712 00000 n
+0000041997 00000 n
+0000041117 00000 n
+0000041435 00000 n
+0000041483 00000 n
+0000061596 00000 n
+0000061627 00000 n
+0000061480 00000 n
+0000061511 00000 n
+0000061899 00000 n
+0000062183 00000 n
+0000063645 00000 n
+0000071026 00000 n
+0000136615 00000 n
+0000202204 00000 n
+0000267793 00000 n
+0000333382 00000 n
+0000398971 00000 n
+0000431529 00000 n
+trailer
+<</Size 30/Root 1 0 R/Info 29 0 R/ID[<2E7527EF4CBFC74AB7C7752FBE1E99F3><3A254DDB04EC5841BDABC0217DC87556>]>>
+startxref
+431702
+%%EOF
diff --git a/doc/images/logo_camp.svg b/doc/images/logo_camp.svg
new file mode 100644
index 0000000..85a1335
--- /dev/null
+++ b/doc/images/logo_camp.svg
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 14.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 43363)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="595.275px" height="841.89px" viewBox="0 0 595.275 841.89" enable-background="new 0 0 595.275 841.89"
+	 xml:space="preserve">
+<g id="CAMP">
+	<g>
+		<defs>
+			<path id="SVGID_1_" d="M250.03,357.92c-25.566,0-34.088-11.783-36.711-15.056c-2.622-3.272-1.967-24.873,6.555-37.964
+				c8.522-13.092,21.634-21.601,29.5-21.601h0.606c7.866,0,20.977,8.509,29.5,21.601c8.522,13.091,9.176,34.692,6.554,37.964
+				c-2.622,3.273-11.144,15.056-36.71,15.056H250.03z"/>
+		</defs>
+		<clipPath id="SVGID_2_">
+			<use xlink:href="#SVGID_1_"  overflow="visible"/>
+		</clipPath>
+		<g clip-path="url(#SVGID_2_)">
+			<g>
+				<defs>
+					<rect id="SVGID_3_" x="211.684" y="283.121" width="76.209" height="75.234"/>
+				</defs>
+				<clipPath id="SVGID_4_">
+					<use xlink:href="#SVGID_3_"  overflow="visible"/>
+				</clipPath>
+				<g transform="matrix(1 0 0 1 -6.371256e-007 7.187002e-006)" clip-path="url(#SVGID_4_)">
+					
+						<image overflow="visible" width="156" height="154" xlink:href="data:image/jpeg;base64,/9j/4AAQSkZJRgABAgEAkwCTAAD/7AARRHVja3kAAQAEAAAAHgAA/+4AIUFkb2JlAGTAAAAAAQMA
+EAMCAwYAAAOIAAAFUwAAB9D/2wCEABALCwsMCxAMDBAXDw0PFxsUEBAUGx8XFxcXFx8eFxoaGhoX
+Hh4jJSclIx4vLzMzLy9AQEBAQEBAQEBAQEBAQEABEQ8PERMRFRISFRQRFBEUGhQWFhQaJhoaHBoa
+JjAjHh4eHiMwKy4nJycuKzU1MDA1NUBAP0BAQEBAQEBAQEBAQP/CABEIAJsAnQMBIgACEQEDEQH/
+xAC/AAEAAgMBAQAAAAAAAAAAAAAAAwQBBQYCBwEBAAMBAQAAAAAAAAAAAAAAAAECAwQFEAABBAEC
+BQQCAwEAAAAAAAABAAIDBBEwBRAgITESIhMUBjIjQCQlFhEAAQIDAwUNBQYHAAAAAAAAAQACETED
+IUEEMEBREiIQIGFxgZGhsTJCUnIUwYKSExXxosIjpEUzQ2PDJIQ1EgABAgQEBQUBAAAAAAAAAAAB
+AAIwESExECBRoUBBYXGxkdESMnJi/9oADAMBAAIRAxEAAAD6AAAeTMcFekTw14MYt+9fmkbufnbm
+s7d59b2AAAEYp+amMSU4o+KmcYYRnPkS+oPV5t73mZN56dFL33CQwY1/unjHmki4aBjAAAGWMk/S
+8js+u29HfdBPrKxDSmpcFcYOaoAAAACGaGzrbHOdH6d49PsdXSa9eSPz6BWAAAAAEcnkr9xwPS90
+2NfapJr+c44agAAAAAMZwUp4a/W6ipYqxaEctQAAAAAAKWvu6zqr2FTb85W9pHJzwAAAAAA8NdeI
+Kvjse+Ol53o8bbfPbPQcny57T1pLPPGzU5M5sIcwlQ4J1SC0bCDV1NouU73adSrvzbYJl59DQaHv
+WeXy2P6pzlK8fnbwVjXednaloLHab208L0G6XvjJfQD/2gAIAQIAAQUA4ufhOlC91MnHM+TCkmJR
+JKyg9RWCwggjhI9SyEnkyqs2CnuwJn87e7XkxTO6yHLuYd4nfrlPqPfnjPplPXQYPRPG4PIxzsYX
+FsfpcwOD4E6EhGNwXi5eDkInFMrpkeFgY4HwRDFhiAYgGoeHH//aAAgBAwABBQDjlZWUHcxKJ5Ac
+chKJ5mngUdAH0lHQaeh0R3Oie7uh5yUOpIyiCFlZ45Rcg0uXiMcHe2sBYWFhqb7fH//aAAgBAQAB
+BQDnfOxqfZeU6VyM0jSzcZWGC5DNque1glnc5PkAT7ACdZC98Fe4CvJVdzfGWSMkboyStjEkpcZZ
+wFJYJTnk8Q4hNes5Va5LVfXsR2I+eWURtkkJM0+FJKSSeYOWcqtakqy17EdiLle8MbLKXGabCkkJ
+OgCiqN11SZj2yM5LM3m6aXAlkJOm5bJf8X8bUvhG9+BNJkk6h7FzmOo2m26vC3L5yzP6Pdk6sgX1
+y14zqZ/hE5yndryDpXsGrb8hjcH+MLz0lOTrPHScL5x/5rc3/skPRx66zu1gIWCdg3B2bMh6HvrH
+tYTJcVLp/tSHprntZXn67p/tvPTXPa05ef7t0Jjul+f4Ejw1t2x1bG41t7ovmjE3VkgKB1XvDRdu
+hoa2WeUfVSNhW97G7LJy0x2QU2UFAg6JeApbTGCzuBcmMlsS/Xfrjdubx3b67BdV2nf218d3CZeC
+bdahbYULLF8iNfJjRtxhOvMCk3JoUu4ucnzSPW27DuO5HaNgp7W3lkjjlZf+n7bZVr6ju9dTV71U
+ixIF8mVfKkRsyozylF7iq+27haVT6ZuUyofVdqpoAAaLvx3HHlN8Nf5q/wA7MPxc7X+XP//aAAgB
+AgIGPwDJdUKk6nXPIKuFVI1adlMVBySGb4Gxt3xlALuYafUKWkF4/klOgu/DvCd3MF35KdoTMQSO
+hUjhRWVlZWVVQSUslwrtV2q698f/2gAIAQMCBj8A4yUOcIjpxxPICDoFLHTsqO2X2C+3lVdsqb4/
+/9oACAEBAQY/AN/AWlWGHEu0edRDiOVbe2OlQBg7wnKxcVCTdG5NT3Yg2oMrbTPFeEHsOs03jJWz
+uCi45GLTFh7TUKlM2Xi8HIRvuCLnG3Jh7Jd5txCFSmbDMaDvi4ouOVjOm6x7fag9hi1wiDvYDsjL
++kqHZd/DPDo3kBN2YBzTBzTEHhCZWEyIPGhwnunQ2wZjUwrjZUGuzzNn0bjnaAo5jSrj+W4E8V/Q
+taNkIx4EG+I9WZ+ojtfK+VG/Wj8pNboGZuo+HFAHyuY53W1O4ABmRVWlpq0nczao9qqceZFFtxt5
+vtVXzZkdx40wPPmJRAmqlfwVKbI+cVD+FeopCL2DabpCgcwLWm1BjAX1HmDWiZJuRwgd/mOcK5N2
+uGloZxQO47F4MRvqUh1tUDYQp5SaIYmsYC+o8wa0WkkoYrFAOxbhYJimDcOHeGrQIo4jT3XcYWri
+qRa254tYeJwU1NTU1NTU1NTU1sraKDqNMto31n2N5NPIg5o+ZiD2qrp+7o3xZUaHsdYWuEQeQovw
+5OFqHw7TPhPsKJohuIYL2Og74XQUK9KpSI8bS3rU92amrSV+RhqlQHvBph8UkDiXMwzbwTrv5m2d
+KD3sOJqjvVbRHgZJQAgBIZIykZy5UY/SIf1o6/3bUdf6V7nqvwL9v/Xr9v8A162PpHv+o/uIf8z/
+AFJzyH//2Q==" transform="matrix(0.4885 0 0 0.4885 211.6841 283.1211)">
+					</image>
+				</g>
+			</g>
+		</g>
+	</g>
+	<g>
+		<path d="M331.798,334.391l-1.224,4.782c-3.336,1.724-7.283,2.391-11.01,2.391c-11.898,0-20.905-7.339-20.905-18.737
+			c0-14.513,10.008-21.129,22.129-21.129c3.67,0,8.118,0.945,11.344,2.725c-0.501,1.891-0.835,3.78-1.279,5.727h-0.778
+			c-2.058-3.002-5.616-5.115-9.23-5.115c-9.229,0-12.955,8.841-12.955,17.014c0,9.508,4.67,16.18,13.233,16.18
+			c3.447,0,7.45-1.779,9.952-4.17L331.798,334.391z"/>
+		<path d="M342.806,329.22c-1.445,4.226-2.835,7.673-3.892,11.51c-0.89-0.056-1.724-0.167-2.614-0.167
+			c-0.889,0-1.778,0.111-2.668,0.167l15.902-38.532c0.723,0.111,1.39,0.167,2.112,0.167s1.391-0.056,2.113-0.167l15.513,38.643
+			c-1.612-0.111-3.169-0.278-4.782-0.278c-1.612,0-3.169,0.167-4.781,0.278c-1.277-4.115-2.447-7.895-3.947-11.621H342.806z
+			 M354.482,325.829l-4.948-12.956l-5.227,12.956H354.482z"/>
+		<path d="M406.526,302.698c0.776,0.111,1.556,0.278,2.334,0.278s1.613-0.167,2.391-0.278c1.725,14.957,3.002,27.078,4.894,38.143
+			c-1.557-0.111-3.058-0.278-4.614-0.278s-2.948,0.167-4.505,0.278c-0.444-8.841-1.557-17.348-2.391-25.911
+			c-4.227,8.507-8.396,17.014-12.345,25.633c-0.722-0.111-1.389-0.167-2.112,0c-3.559-7.673-7.95-16.292-12.177-25.021
+			c-1.278,9.787-2.168,17.515-2.334,25.299c-0.89-0.111-1.724-0.278-2.613-0.278s-1.669,0.167-2.559,0.278
+			c2.001-11.176,3.779-24.076,5.671-38.143c0.78,0.111,1.502,0.278,2.28,0.278s1.558-0.167,2.334-0.278
+			c4.006,8.73,8.397,17.403,12.789,26.133C397.573,320.936,402.299,312.206,406.526,302.698z"/>
+		<path d="M428.988,340.841c-1.391-0.111-2.781-0.278-4.171-0.278c-1.391,0-2.779,0.167-4.17,0.278v-38.143h13.677
+			c7.73,0,11.899,3.114,11.899,9.397c0,9.897-7.228,12.01-17.235,12.01V340.841z M428.988,321.047c1.223-0.056,2.5-0.111,3.67-0.389
+			c3.612-1.001,4.947-4.17,4.947-7.563c0-4.448-2.279-7.395-5.17-7.395h-3.447V321.047z"/>
+	</g>
+	<path fill="#FFFFFF" d="M269.099,314.66c-3.801-4.002-7.025-9.88-7.598-10.505c-0.575-0.627-2.071,0.249-7.251,0
+		c-5.181-0.251-13.007-3.378-14.157-3.378c-1.153,0-22.561,28.517-22.102,29.268c0.416,0.675,5.456-0.866,7.398-1.097
+		c5.976-9.097,12.44-18.354,14.011-18.354c1.612,0,5.835,5.694,13.573,16.908c2.08,3.009,3.873,5.609,4.359,6.107
+		c1.158,0.677,11.888-1.964,23.865-5.412c0.487-0.17,0.792-0.278,0.792-0.278S272.896,318.664,269.099,314.66z"/>
+	<g>
+		<path fill="#FFFFFF" d="M225.132,337.717c0.226,0.5,2.646-0.247,3.451-0.625c0.667-0.31,7.444-16.463,10.195-22.331
+			c-2.219,2.433-6.821,9.015-11.971,16.822C226.911,333.229,224.941,337.308,225.132,337.717z"/>
+		<path fill="#FFFFFF" d="M256.407,336.624c-0.581-0.589-2.304-3.424-4.581-6.724c-3.669-5.313-10.641-14.909-12.084-15.008
+			l0.584,25.452l16.227,1.376c0,0,17.497-6.754,17.613-7.128c0.071-0.238-0.405-0.873-0.593-1.373
+			C265.368,335.418,257.37,337.599,256.407,336.624z"/>
+	</g>
+</g>
+<g id="GICS">
+</g>
+</svg>
diff --git a/doc/images/logo_package.bmp b/doc/images/logo_package.bmp
new file mode 100644
index 0000000..c414e4b
Binary files /dev/null and b/doc/images/logo_package.bmp differ
diff --git a/include/camp-xml/common.hpp b/include/camp-xml/common.hpp
new file mode 100644
index 0000000..5ac1c40
--- /dev/null
+++ b/include/camp-xml/common.hpp
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_COMMON_HPP
+#define CAMP_XML_COMMON_HPP
+
+#include <camp/userobject.hpp>
+#include <camp/value.hpp>
+#include <camp/arrayproperty.hpp>
+#include <string>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Serialize a CAMP object into XML elements
+ *
+ * This function uses a proxy class that defines a unified
+ * interface for creating and populating XML nodes. To
+ * provide support for a particular XML library, you just
+ * have to provide a specialized Proxy which maps the
+ * unified interface to the library's API, and call this
+ * function.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+template <typename Proxy>
+void serialize(const UserObject& object, typename Proxy::NodeType node, const Value& exclude);
+
+/**
+ * \brief Deserialize a CAMP object from XML elements
+ *
+ * This function uses a proxy class that defines a unified
+ * interface for reading and iterating over XML nodes. To
+ * provide support for a particular XML library, you just
+ * have to provide a specialized Proxy which maps the
+ * unified interface to the library's API, and call this
+ * function.
+ *
+ * \param object Object to serialize
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+template <typename Proxy>
+void deserialize(const UserObject& object, typename Proxy::NodeType node, const Value& exclude);
+
+} // namespace detail
+
+} // namespace xml
+
+} // namespace camp
+
+#include <camp-xml/common.inl>
+
+#endif // CAMP_XML_COMMON_HPP
diff --git a/include/camp-xml/common.inl b/include/camp-xml/common.inl
new file mode 100644
index 0000000..079dcbf
--- /dev/null
+++ b/include/camp-xml/common.inl
@@ -0,0 +1,158 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+template <typename Proxy>
+void serialize(const UserObject& object, typename Proxy::NodeType node, const Value& exclude)
+{
+    // Iterate over the object's properties using its metaclass
+    const Class& metaclass = object.getClass();
+    for (std::size_t i = 0; i < metaclass.propertyCount(); ++i)
+    {
+        const Property& property = metaclass.property(i);
+
+        // If the property has the exclude tag, ignore it
+        if ((exclude != Value::nothing) && property.hasTag(exclude))
+            continue;
+
+        // Create a child node for the new property
+        typename Proxy::NodeType child = Proxy::addChild(node, property.name());
+        if (!Proxy::isValid(child))
+            continue;
+
+        if (property.type() == userType)
+        {
+            // The current property is a composed type: serialize it recursively
+            serialize<Proxy>(property.get(object).to<UserObject>(), child, exclude);
+        }
+        else if (property.type() == arrayType)
+        {
+            // The current property is an array
+            const ArrayProperty& arrayProperty = static_cast<const ArrayProperty&>(property);
+
+            // Iterate over the array elements
+            std::size_t count = arrayProperty.size(object);
+            for (std::size_t j = 0; j < count; ++j)
+            {
+                // Add a new XML node for each array element
+                typename Proxy::NodeType item = Proxy::addChild(child, "item");
+                if (Proxy::isValid(item))
+                {
+                    if (arrayProperty.elementType() == userType)
+                    {
+                        // The array elements are composed objects: serialize them recursively
+                        serialize<Proxy>(arrayProperty.get(object, j).to<UserObject>(), item, exclude);
+                    }
+                    else
+                    {
+                        // The array elements are simple properties: write them as the text of their XML node
+                        Proxy::setText(item, arrayProperty.get(object, j));
+                    }
+                }
+            }
+        }
+        else
+        {
+            // The current property is a simple property: write its value as the node's text
+            Proxy::setText(child, property.get(object));
+        }
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename Proxy>
+void deserialize(const UserObject& object, typename Proxy::NodeType node, const Value& exclude)
+{
+    // Iterate over the object's properties using its metaclass
+    const Class& metaclass = object.getClass();
+    for (std::size_t i = 0; i < metaclass.propertyCount(); ++i)
+    {
+        const Property& property = metaclass.property(i);
+
+        // If the property has the exclude tag, ignore it
+        if ((exclude != Value::nothing) && property.hasTag(exclude))
+            continue;
+
+        // Find the child node corresponding to the new property
+        typename Proxy::NodeType child = Proxy::findFirstChild(node, property.name());
+        if (!Proxy::isValid(child))
+            continue;
+
+        if (property.type() == userType)
+        {
+            // The current property is a composed type: deserialize it recursively
+            deserialize<Proxy>(property.get(object).to<UserObject>(), child, exclude);
+        }
+        else if (property.type() == arrayType)
+        {
+            // The current property is an array
+            const ArrayProperty& arrayProperty = static_cast<const ArrayProperty&>(property);
+
+            // Iterate over the child XML node and extract all the array elements
+            std::size_t index = 0;
+            for (typename Proxy::NodeType item = Proxy::findFirstChild(child, "item")
+                ; Proxy::isValid(item)
+                ; item = Proxy::findNextSibling(item, "item"))
+            {
+                // Make sure that there are enough elements in the array
+                std::size_t count = arrayProperty.size(object);
+                if (index >= count)
+                {
+                    if (arrayProperty.dynamic())
+                        arrayProperty.resize(object, index + 1);
+                    else
+                        break;
+                }
+
+                if (arrayProperty.elementType() == userType)
+                {
+                    // The array elements are composed objects: deserialize them recursively
+                    deserialize<Proxy>(arrayProperty.get(object, index).to<UserObject>(), item, exclude);
+                }
+                else
+                {
+                    // The array elements are simple properties: read their value from the text of their XML node
+                    arrayProperty.set(object, index, Proxy::getText(item));
+                }
+
+                index++;
+            }
+        }
+        else
+        {
+            // The current property is a simple property: read its value from the node's text
+            property.set(object, Proxy::getText(child));
+        }
+    }
+}
+
+} // namespace detail
+
+} // namespace xml
+
+} // namespace camp
diff --git a/include/camp-xml/libxml.hpp b/include/camp-xml/libxml.hpp
new file mode 100644
index 0000000..d293813
--- /dev/null
+++ b/include/camp-xml/libxml.hpp
@@ -0,0 +1,146 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_LIBXML_HPP
+#define CAMP_XML_LIBXML_HPP
+
+#include <camp-xml/common.hpp>
+#include <libxml/tree.h>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Proxy that adapts the camp::xml functions to the libxml library
+ */
+struct LibXml
+{
+    typedef xmlNodePtr NodeType;
+
+    static NodeType addChild(NodeType node, const std::string& name)
+    {
+        return xmlAddChild(node, xmlNewNode(0, reinterpret_cast<const xmlChar*>(name.c_str())));
+    }
+
+    static void setText(NodeType node, const std::string& text)
+    {
+        xmlNodeSetContent(node, reinterpret_cast<const xmlChar*>(text.c_str()));
+    }
+
+    static NodeType findFirstChild(NodeType node, const std::string& name)
+    {
+        const xmlChar* convertedName = reinterpret_cast<const xmlChar*>(name.c_str());
+        NodeType child = xmlFirstElementChild(node);
+        while (child)
+        {
+            if (xmlStrcmp(child->name, convertedName) == 0)
+                break;
+            else
+                child = xmlNextElementSibling(child);
+        }
+
+        return child;
+    }
+
+    static NodeType findNextSibling(NodeType node, const std::string& name)
+    {
+        const xmlChar* convertedName = reinterpret_cast<const xmlChar*>(name.c_str());
+        NodeType sibling = xmlNextElementSibling(node);
+        while (sibling)
+        {
+            if (xmlStrcmp(sibling->name, convertedName) == 0)
+                break;
+            else
+                node = xmlNextElementSibling(sibling);
+        }
+
+        return sibling;
+    }
+
+    static std::string getText(NodeType node)
+    {
+        return reinterpret_cast<const char*>(xmlNodeGetContent(node));
+    }
+
+    static bool isValid(NodeType node)
+    {
+        return node != 0;
+    }
+};
+
+} // namespace detail
+
+/**
+ * \brief Serialize a CAMP object into a libxml xmlNodePtr
+ *
+ * This function iterates over all the object's properties
+ * and transforms them into valid XML nodes. Composed sub-objects
+ * are serialized recursively.
+ *
+ * \a node is the parent node to which the generated child nodes
+ * will be appended.
+ *
+ * You have the possibility to exclude some properties from the
+ * generated output with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the serialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+inline void serialize(const UserObject& object, xmlNodePtr node, const Value& exclude = Value::nothing)
+{
+    detail::serialize<detail::LibXml>(object, node, exclude);
+}
+
+/**
+ * \brief Deserialize a CAMP object from a libxml xmlNodePtr
+ *
+ * This function iterates over all the object's properties
+ * and read their value from XML nodes. Composed sub-objects
+ * are deserialized recursively.
+ *
+ * You have the possibility to exclude some properties from
+ * being read with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the deserialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to fill with deserialized information
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+inline void deserialize(const UserObject& object, xmlNodePtr node, const Value& exclude = Value::nothing)
+{
+    detail::deserialize<detail::LibXml>(object, node, exclude);
+}
+
+} // namespace xml
+
+} // namespace camp
+
+#endif // CAMP_XML_LIBXML_HPP
diff --git a/include/camp-xml/qtxml.hpp b/include/camp-xml/qtxml.hpp
new file mode 100644
index 0000000..13ff7b7
--- /dev/null
+++ b/include/camp-xml/qtxml.hpp
@@ -0,0 +1,129 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_QTXML_HPP
+#define CAMP_XML_QTXML_HPP
+
+#include <camp-xml/common.hpp>
+#include <QDomDocument>
+#include <QDomElement>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Proxy that adapts the camp::xml functions to the QtXml library
+ */
+struct QtXml
+{
+    typedef QDomElement NodeType;
+
+    static NodeType addChild(NodeType node, const std::string& name)
+    {
+        QDomElement child = node.ownerDocument().createElement(name.c_str());
+        node.appendChild(child);
+        return child;
+    }
+
+    static void setText(NodeType node, const std::string& text)
+    {
+        node.appendChild(node.ownerDocument().createTextNode(text.c_str()));
+    }
+
+    static NodeType findFirstChild(NodeType node, const std::string& name)
+    {
+        return node.firstChildElement(name.c_str());
+    }
+
+    static NodeType findNextSibling(NodeType node, const std::string& name)
+    {
+        return node.nextSiblingElement(name.c_str());
+    }
+
+    static std::string getText(NodeType node)
+    {
+        return node.text().toStdString();
+    }
+
+    static bool isValid(NodeType node)
+    {
+        return !node.isNull();
+    }
+};
+
+} // namespace detail
+
+/**
+ * \brief Serialize a CAMP object into a QtXml QDomElement
+ *
+ * This function iterates over all the object's properties
+ * and transforms them into valid XML nodes. Composed sub-objects
+ * are serialized recursively.
+ *
+ * \a node is the parent node to which the generated child nodes
+ * will be appended.
+ *
+ * You have the possibility to exclude some properties from the
+ * generated output with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the serialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+inline void serialize(const UserObject& object, QDomElement node, const Value& exclude = Value::nothing)
+{
+    detail::serialize<detail::QtXml>(object, node, exclude);
+}
+
+/**
+ * \brief Deserialize a CAMP object from a QtXml QDomElement
+ *
+ * This function iterates over all the object's properties
+ * and read their value from XML nodes. Composed sub-objects
+ * are deserialized recursively.
+ *
+ * You have the possibility to exclude some properties from
+ * being read with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the deserialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to fill with deserialized information
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+inline void deserialize(const UserObject& object, QDomElement node, const Value& exclude = Value::nothing)
+{
+    detail::deserialize<detail::QtXml>(object, node, exclude);
+}
+
+} // namespace xml
+
+} // namespace camp
+
+#endif // CAMP_XML_QTXML_HPP
diff --git a/include/camp-xml/rapidxml.hpp b/include/camp-xml/rapidxml.hpp
new file mode 100644
index 0000000..3e16788
--- /dev/null
+++ b/include/camp-xml/rapidxml.hpp
@@ -0,0 +1,129 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_RAPIDXML_HPP
+#define CAMP_XML_RAPIDXML_HPP
+
+#include <camp-xml/common.hpp>
+#include <rapidxml.hpp>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Proxy that adapts the camp::xml functions to the rapidxml library
+ */
+struct RapidXml
+{
+    typedef rapidxml::xml_node<>* NodeType;
+
+    static NodeType addChild(NodeType node, const std::string& name)
+    {
+        const char* allocatedName = node->document()->allocate_string(name.c_str());
+        NodeType child = node->document()->allocate_node(rapidxml::node_element, allocatedName);
+        node->append_node(child);
+        return child;
+    }
+
+    static void setText(NodeType node, const std::string& text)
+    {
+        node->value(node->document()->allocate_string(text.c_str()));
+    }
+
+    static NodeType findFirstChild(NodeType node, const std::string& name)
+    {
+        return node->first_node(name.c_str());
+    }
+
+    static NodeType findNextSibling(NodeType node, const std::string& name)
+    {
+        return node->next_sibling(name.c_str());
+    }
+
+    static std::string getText(NodeType node)
+    {
+        return node->value();
+    }
+
+    static bool isValid(NodeType node)
+    {
+        return node != 0;
+    }
+};
+
+} // namespace detail
+
+/**
+ * \brief Serialize a CAMP object into a rapidxml xml_node<>
+ *
+ * This function iterates over all the object's properties
+ * and transforms them into valid XML nodes. Composed sub-objects
+ * are serialized recursively.
+ *
+ * \a node is the parent node to which the generated child nodes
+ * will be appended.
+ *
+ * You have the possibility to exclude some properties from the
+ * generated output with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the serialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+inline void serialize(const UserObject& object, rapidxml::xml_node<>* node, const Value& exclude = Value::nothing)
+{
+    detail::serialize<detail::RapidXml>(object, node, exclude);
+}
+
+/**
+ * \brief Deserialize a CAMP object from a TinyXml TiXmlElement
+ *
+ * This function iterates over all the object's properties
+ * and read their value from XML nodes. Composed sub-objects
+ * are deserialized recursively.
+ *
+ * You have the possibility to exclude some properties from
+ * being read with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the deserialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to fill with deserialized information
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+inline void deserialize(const UserObject& object, rapidxml::xml_node<>* node, const Value& exclude = Value::nothing)
+{
+    detail::deserialize<detail::RapidXml>(object, node, exclude);
+}
+
+} // namespace xml
+
+} // namespace camp
+
+#endif // CAMP_XML_RAPIDXML_HPP
diff --git a/include/camp-xml/tinyxml.hpp b/include/camp-xml/tinyxml.hpp
new file mode 100644
index 0000000..869ac91
--- /dev/null
+++ b/include/camp-xml/tinyxml.hpp
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_TINYXML_HPP
+#define CAMP_XML_TINYXML_HPP
+
+#include <camp-xml/common.hpp>
+#include <tinyxml.h>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Proxy that adapts the camp::xml functions to the TinyXml library
+ */
+struct TinyXml
+{
+    typedef TiXmlElement* NodeType;
+
+    static NodeType addChild(NodeType node, const std::string& name)
+    {
+        return static_cast<NodeType>(node->InsertEndChild(TiXmlElement(name.c_str())));
+    }
+
+    static void setText(NodeType node, const std::string& text)
+    {
+        node->InsertEndChild(TiXmlText(text.c_str()));
+    }
+
+    static NodeType findFirstChild(NodeType node, const std::string& name)
+    {
+        return node->FirstChildElement(name.c_str());
+    }
+
+    static NodeType findNextSibling(NodeType node, const std::string& name)
+    {
+        return node->NextSiblingElement(name.c_str());
+    }
+
+    static std::string getText(NodeType node)
+    {
+        return node->GetText();
+    }
+
+    static bool isValid(NodeType node)
+    {
+        return node != 0;
+    }
+};
+
+} // namespace detail
+
+/**
+ * \brief Serialize a CAMP object into a TinyXml TiXmlElement
+ *
+ * This function iterates over all the object's properties
+ * and transforms them into valid XML nodes. Composed sub-objects
+ * are serialized recursively.
+ *
+ * \a node is the parent node to which the generated child nodes
+ * will be appended.
+ *
+ * You have the possibility to exclude some properties from the
+ * generated output with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the serialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+inline void serialize(const UserObject& object, TiXmlElement* node, const Value& exclude = Value::nothing)
+{
+    detail::serialize<detail::TinyXml>(object, node, exclude);
+}
+
+/**
+ * \brief Deserialize a CAMP object from a TinyXml TiXmlElement
+ *
+ * This function iterates over all the object's properties
+ * and read their value from XML nodes. Composed sub-objects
+ * are deserialized recursively.
+ *
+ * You have the possibility to exclude some properties from
+ * being read with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the deserialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to fill with deserialized information
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+inline void deserialize(const UserObject& object, TiXmlElement* node, const Value& exclude = Value::nothing)
+{
+    detail::deserialize<detail::TinyXml>(object, node, exclude);
+}
+
+} // namespace xml
+
+} // namespace camp
+
+#endif // CAMP_XML_TINYXML_HPP
diff --git a/include/camp-xml/xerces.hpp b/include/camp-xml/xerces.hpp
new file mode 100644
index 0000000..82d0a6c
--- /dev/null
+++ b/include/camp-xml/xerces.hpp
@@ -0,0 +1,162 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMP_XML_XERCES_HPP
+#define CAMP_XML_XERCES_HPP
+
+#include <camp-xml/common.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/dom/DOMDocument.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+
+namespace camp
+{
+namespace xml
+{
+namespace detail
+{
+/**
+ * \brief Proxy that adapts the camp::xml functions to the Xerces library
+ */
+struct Xerces
+{
+    typedef xercesc::DOMElement* NodeType;
+
+    static NodeType addChild(NodeType node, const std::string& name)
+    {
+        XMLCh buffer[256];
+        xercesc::XMLString::transcode(name.c_str(), buffer, sizeof(buffer));
+
+        NodeType child = node->getOwnerDocument()->createElement(buffer);
+        node->appendChild(child);
+
+        return child;
+    }
+
+    static void setText(NodeType node, const std::string& text)
+    {
+        XMLCh buffer[256];
+        xercesc::XMLString::transcode(text.c_str(), buffer, sizeof(buffer));
+
+        node->setTextContent(buffer);
+    }
+
+    static NodeType findFirstChild(NodeType node, const std::string& name)
+    {
+        XMLCh buffer[256];
+        xercesc::XMLString::transcode(name.c_str(), buffer, sizeof(buffer));
+
+        xercesc::DOMNodeList* children = node->getElementsByTagName(buffer);
+        if (children && (children->getLength() > 0))
+            return static_cast<NodeType>(children->item(0));
+        else
+            return 0;
+    }
+
+    static NodeType findNextSibling(NodeType node, const std::string& name)
+    {
+        XMLCh buffer[256];
+        xercesc::XMLString::transcode(name.c_str(), buffer, sizeof(buffer));
+
+        xercesc::DOMNode* sibling = node->getNextSibling();
+        while (sibling)
+        {
+            bool same = xercesc::XMLString::compareString(sibling->getNodeName(), buffer) == 0;
+            if ((sibling->getNodeType() == xercesc::DOMNode::ELEMENT_NODE) && same)
+                return static_cast<NodeType>(sibling);
+            sibling = sibling->getNextSibling();
+        }
+
+        return 0;
+    }
+
+    static std::string getText(NodeType node)
+    {
+        const XMLCh* text = node->getTextContent();
+
+        char buffer[256];
+        xercesc::XMLString::transcode(text, buffer, sizeof(buffer) - 1);
+
+        return buffer;
+    }
+
+    static bool isValid(NodeType node)
+    {
+        return node != 0;
+    }
+};
+
+} // namespace detail
+
+/**
+ * \brief Serialize a CAMP object into a Xerces DOMElement
+ *
+ * This function iterates over all the object's properties
+ * and transforms them into valid XML nodes. Composed sub-objects
+ * are serialized recursively.
+ *
+ * \a node is the parent node to which the generated child nodes
+ * will be appended.
+ *
+ * You have the possibility to exclude some properties from the
+ * generated output with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the serialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to serialize
+ * \param node Parent for the generated XML nodes
+ * \param exclude Tag to exclude from the serialization process
+ */
+inline void serialize(const UserObject& object, xercesc::DOMElement* node, const Value& exclude = Value::nothing)
+{
+    detail::serialize<detail::Xerces>(object, node, exclude);
+}
+
+/**
+ * \brief Deserialize a CAMP object from a Xerces DOMElement
+ *
+ * This function iterates over all the object's properties
+ * and read their value from XML nodes. Composed sub-objects
+ * are deserialized recursively.
+ *
+ * You have the possibility to exclude some properties from
+ * being read with the last (optional) parameter, \a exclude.
+ * If it is defined, any property containing this value as a tag
+ * will be excluded from the deserialization process. It is empty
+ * by default, which means that no property will be excluded.
+ *
+ * \param object Object to fill with deserialized information
+ * \param node XML node to parse
+ * \param exclude Tag to exclude from the deserialization process
+ */
+inline void deserialize(const UserObject& object, xercesc::DOMElement* node, const Value& exclude = Value::nothing)
+{
+    detail::deserialize<detail::Xerces>(object, node, exclude);
+}
+
+
+} // namespace xml
+
+} // namespace camp
+
+#endif // CAMP_XML_TINYXML_HPP
diff --git a/include/camp/args.hpp b/include/camp/args.hpp
new file mode 100644
index 0000000..3477d4e
--- /dev/null
+++ b/include/camp/args.hpp
@@ -0,0 +1,166 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ARGS_HPP
+#define CAMP_ARGS_HPP
+
+
+#include <camp/config.hpp>
+#include <vector>
+
+
+namespace camp
+{
+class Value;
+
+/**
+ * \brief Wrapper for packing an arbitrary number of arguments into a single object
+ *
+ * camp::Args is defined as a list of arguments of any type (wrapped in camp::Value instances),
+ * which can conveniently be passed to all the CAMP entities which may need an arbitrary number of arguments
+ * in a uniform way.
+ *
+ * Arguments lists can be constructed on the fly using one of the constructors (accept up to 5 arguments):
+ *
+ * \code
+ * camp::Args args(1, true, "hello", 5.24, myObject);
+ * \endcode
+ *
+ * ... or appended one by one using the + and += operators:
+ *
+ * \code
+ * camp::Args args;
+ * args += 1;
+ * args += true;
+ * args += "hello";
+ * args += 5.24;
+ * args = args + myObject;
+ * \endcode
+ *
+ */
+class CAMP_API Args
+{
+public:
+
+    /**
+     * \brief Default constructor (empty list of argument)
+     */
+    Args();
+
+    /**
+     * \brief Construct the list with 1 argument
+     *
+     * \param a0 Argument to put in the list
+     */
+    Args(const Value& a0);
+
+    /**
+     * \brief Construct the list with 2 arguments
+     *
+     * \param a0 First argument to put in the list
+     * \param a1 Second argument to put in the list
+     */
+    Args(const Value& a0, const Value& a1);
+
+    /**
+     * \brief Construct the list with 3 arguments
+     *
+     * \param a0 First argument to put in the list
+     * \param a1 Second argument to put in the list
+     * \param a2 Third argument to put in the list
+     */
+    Args(const Value& a0, const Value& a1, const Value& a2);
+
+    /**
+     * \brief Construct the list with 4 arguments
+     *
+     * \param a0 First argument to put in the list
+     * \param a1 Second argument to put in the list
+     * \param a2 Third argument to put in the list
+     * \param a3 Fourth argument to put in the list
+     */
+    Args(const Value& a0, const Value& a1, const Value& a2, const Value& a3);
+
+    /**
+     * \brief Construct the list with 5 arguments
+     *
+     * \param a0 First argument to put in the list
+     * \param a1 Second argument to put in the list
+     * \param a2 Third argument to put in the list
+     * \param a3 Fourth argument to put in the list
+     * \param a4 Fifth argument to put in the list
+     */
+    Args(const Value& a0, const Value& a1, const Value& a2, const Value& a3, const Value& a4);
+
+    /**
+     * \brief Return the number of arguments contained in the list
+     *
+     * \return Size of the arguments list
+     */
+    std::size_t count() const;
+
+    /**
+     * \brief Overload of operator [] to access an argument from its index
+     *
+     * \param index Index of the argument to get
+     *
+     * \return Value of the index-th argument
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Value& operator[](std::size_t index) const;
+
+    /**
+     * \brief Overload of operator + to concatenate a list and a new argument
+     *
+     * \param arg Argument to concatenate to the list
+     *
+     * \return New list
+     */
+    Args operator+(const Value& arg) const;
+
+    /**
+     * \brief Overload of operator += to append a new argument to the list
+     *
+     * \param arg Argument to append to the list
+     *
+     * \return Reference to this
+     */
+    Args& operator+=(const Value& arg);
+
+public:
+
+    /**
+     * \brief Special instance representing an empty set of arguments
+     */
+    static const Args empty;
+
+private:
+
+    std::vector<Value> m_values; ///< List of the values
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ARGS_HPP
diff --git a/include/camp/arraymapper.hpp b/include/camp/arraymapper.hpp
new file mode 100644
index 0000000..b0a90b7
--- /dev/null
+++ b/include/camp/arraymapper.hpp
@@ -0,0 +1,301 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ARRAYMAPPER_HPP
+#define CAMP_ARRAYMAPPER_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/yesnotype.hpp>
+#include <boost/array.hpp>
+#include <list>
+#include <vector>
+
+
+namespace camp_ext
+{
+/**
+ * \class ArrayMapper
+ *
+ * \brief Template providing a mapping between C++ arrays and CAMP ArrayProperty
+ *
+ * ArrayMapper<T> must define the following members in order to make T fully compliant with the system:
+ *
+ * \li \c ElementType: type of the elements stored in the array
+ * \li \c dynamic(): tells if the array is dynamic (i.e. supports insert and remove)
+ * \li \c size(): retrieve the size of the array
+ * \li \c get(): get the value of an element
+ * \li \c set(): set the value of an element
+ * \li \c insert(): insert a new element
+ * \li \c remove(): remove an element
+ *
+ * ValueMapper is specialized for every supported type, and can be specialized
+ * for any of your own array types in order to extend the system.
+ *
+ * By default, ValueMapper supports the following types of array:
+ *
+ * \li T[]
+ * \li boost::array
+ * \li std::vector
+ * \li std::list
+ *
+ * Here is an example of mapping for the std::vector class:
+ *
+ * \code
+ * namespace camp_ext
+ * {
+ *     template <typename T>
+ *     struct ArrayMapper<std::vector<T> >
+ *     {
+ *         typedef T ElementType;
+ *         
+ *         static bool dynamic()
+ *         {
+ *             return true;
+ *         }
+ *
+ *         static std::size_t size(const std::vector<T>& arr)
+ *         {
+ *             return arr.size();
+ *         }
+ *
+ *         static const T& get(const std::vector<T>& arr, std::size_t index)
+ *         {
+ *             return arr[index];
+ *         }
+ *
+ *         static void set(std::vector<T>& arr, std::size_t index, const T& value)
+ *         {
+ *             arr[index] = value;
+ *         }
+ *
+ *         static void insert(std::vector<T>& arr, std::size_t before, const T& value)
+ *         {
+ *             arr.insert(arr.begin() + before, value);
+ *         }
+ *
+ *         static void remove(std::vector<T>& arr, std::size_t index)
+ *         {
+ *             arr.erase(arr.begin() + index);
+ *         }
+ *     };
+ * }
+ * \endcode
+ */
+
+/*
+ * Generic version -- doesn't define anything
+ */
+template <typename T>
+struct ArrayMapper
+{
+};
+
+/*
+ * Specialization of ArrayMapper for built-in static arrays
+ */
+template <typename T, std::size_t N>
+struct ArrayMapper<T[N]>
+{
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return false;
+    }
+
+    static std::size_t size(T (&)[N])
+    {
+        return N;
+    }
+
+    static const T& get(T (& arr)[N], std::size_t index)
+    {
+        return arr[index];
+    }
+
+    static void set(T (& arr)[N], std::size_t index, const T& value)
+    {
+        arr[index] = value;
+    }
+
+    static void insert(T (&)[N], std::size_t, const T&)
+    {
+    }
+
+    static void remove(T (&)[N], std::size_t)
+    {
+    }
+};
+
+/*
+ * Specialization of ArrayMapper for boost::array
+ */
+template <typename T, std::size_t N>
+struct ArrayMapper<boost::array<T, N> >
+{
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return false;
+    }
+
+    static std::size_t size(const boost::array<T, N>&)
+    {
+        return N;
+    }
+
+    static const T& get(const boost::array<T, N>& arr, std::size_t index)
+    {
+        return arr[index];
+    }
+
+    static void set(boost::array<T, N>& arr, std::size_t index, const T& value)
+    {
+        arr[index] = value;
+    }
+
+    static void insert(boost::array<T, N>&, std::size_t, const T&)
+    {
+    }
+
+    static void remove(boost::array<T, N>&, std::size_t)
+    {
+    }
+};
+
+/*
+ * Specialization of ArrayMapper for std::vector
+ */
+ template <typename T>
+ struct ArrayMapper<std::vector<T> >
+ {
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return true;
+    }
+
+    static std::size_t size(const std::vector<T>& arr)
+    {
+        return arr.size();
+    }
+
+    static const T& get(const std::vector<T>& arr, std::size_t index)
+    {
+        return arr[index];
+    }
+
+    static void set(std::vector<T>& arr, std::size_t index, const T& value)
+    {
+        arr[index] = value;
+    }
+
+    static void insert(std::vector<T>& arr, std::size_t before, const T& value)
+    {
+        arr.insert(arr.begin() + before, value);
+    }
+
+    static void remove(std::vector<T>& arr, std::size_t index)
+    {
+        arr.erase(arr.begin() + index);
+    }
+};
+
+/*
+ * Specialization of ArrayMapper for std::list
+ */
+ template <typename T>
+ struct ArrayMapper<std::list<T> >
+ {
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return true;
+    }
+
+    static std::size_t size(const std::list<T>& arr)
+    {
+        return arr.size();
+    }
+
+    static const T& get(const std::list<T>& arr, std::size_t index)
+    {
+        typename std::list<T>::const_iterator it = arr.begin();
+        std::advance(it, index);
+        return *it;
+    }
+
+    static void set(std::list<T>& arr, std::size_t index, const T& value)
+    {
+        typename std::list<T>::iterator it = arr.begin();
+        std::advance(it, index);
+        *it = value;
+    }
+
+    static void insert(std::list<T>& arr, std::size_t before, const T& value)
+    {
+        typename std::list<T>::iterator it = arr.begin();
+        std::advance(it, before);
+        arr.insert(it, value);
+    }
+
+    static void remove(std::list<T>& arr, std::size_t index)
+    {
+        typename std::list<T>::iterator it = arr.begin();
+        std::advance(it, index);
+        arr.erase(it);
+    }
+};
+
+} // namespace camp_ext
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Helper structure to check at compile time if a type is an array
+ *
+ * This structure check if the specialization of ArrayMapper for the
+ * template parameter T exists (i.e. the ElementType member is properly defined).
+ */
+template <typename T>
+struct IsArray
+{
+    template <typename U> static TypeYes check(typename U::ElementType*);
+    template <typename U> static TypeNo  check(...);
+
+    enum {value = sizeof(check<camp_ext::ArrayMapper<T> >(0)) == sizeof(TypeYes)};
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_ARRAYMAPPER_HPP
diff --git a/include/camp/arrayproperty.hpp b/include/camp/arrayproperty.hpp
new file mode 100644
index 0000000..ba1816d
--- /dev/null
+++ b/include/camp/arrayproperty.hpp
@@ -0,0 +1,250 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ARRAYPROPERTY_HPP
+#define CAMP_ARRAYPROPERTY_HPP
+
+
+#include <camp/property.hpp>
+
+
+namespace camp
+{
+/**
+ * \brief Specialized type of property for arrays
+ *
+ */
+class CAMP_API ArrayProperty : public Property
+{
+public:
+
+    /**
+     * \brief Construct the property from its description
+     *
+     * \param name Name of the property
+     * \param elementType Type of the property
+     * \param dynamic Tells if the array is dynamic or not
+     */
+    ArrayProperty(const std::string& name, Type elementType, bool dynamic);
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~ArrayProperty();
+
+    /**
+     * \brief Get the type of the array elements
+     *
+     * \return Type of elements
+     */
+    Type elementType() const;
+
+    /**
+     * \brief Check if the array is dynamic
+     *
+     * If the array is not dynamic, the insert and remove functions
+     * are disabled.
+     *
+     * \return True if the array is dynamic, false otherwise
+     */
+    bool dynamic() const;
+
+    /**
+     * \brief Get the current size of the array
+     *
+     * \param object Object
+     *
+     * \return Number of elements in the array
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenRead property is not readable
+     */
+    std::size_t size(const UserObject& object) const;
+
+    /**
+     * \brief Resize the array
+     *
+     * If \a size is lesser than the current size of the array,
+     * the last elements will be removed; if \a size is greater
+     * than the current size of the array, default-constructed
+     * elements will be added at the end.
+     *
+     * This function will throw an error if the array is not dynamic
+     *
+     * \param object Object
+     * \param newSize New size of the array
+     *
+     * \throw InvalidObject object has an invalid value
+     * \throw InvalidAccess array is not writable or not dynamic
+     * \throw InvalidIndex index is out of range
+     */
+    void resize(const UserObject& object, std::size_t newSize) const;
+
+    /**
+     * \brief Get an element of the array for a given object
+     *
+     * \param object Object
+     * \param index Index of the element to get
+     *
+     * \return Value of the index-th element
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenRead property is not readable
+     * \throw OutOfRange index is out of range
+     */
+    Value get(const UserObject& object, std::size_t index) const;
+
+    /**
+     * \brief Set an element of the array for a given object
+     *
+     * \param object Object
+     * \param index Index of the element to get
+     * \param value New value to assign to the element
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenWrite property is not writable
+     * \throw BadType \a value can't be converted to the property's type
+     * \throw OutOfRange index is out of range
+     */
+    void set(const UserObject& object, std::size_t index, const Value& value) const;
+
+    /**
+     * \brief Insert a new element into the array
+     *
+     * This function will throw an error if the array is not dynamic
+     *
+     * \param object Object
+     * \param before Index before which the new element will be inserted
+     * \param value Value of the element to insert
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenWrite array is not writable or not dynamic
+     * \throw BadType \a value can't be converted to the property's type
+     * \throw OutOfRange index is out of range
+     */
+    void insert(const UserObject& object, std::size_t before, const Value& value) const;
+
+    /**
+     * \brief Remove an element from the array
+     *
+     * This function will throw an error if the array is not dynamic
+     *
+     * \param object Object
+     * \param index Index of the element to remove
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenWrite array is not writable or not dynamic
+     * \throw OutOfRange index is out of range
+     */
+    void remove(const UserObject& object, std::size_t index) const;
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+
+protected:
+
+    /**
+     * \see Property::getValue
+     */
+    virtual Value getValue(const UserObject& object) const;
+
+    /**
+     * \see Property::setValue
+     */
+    virtual void setValue(const UserObject& object, const Value& value) const;
+
+    /**
+     * \brief Do the actual retrieval of the size
+     *
+     * \param object Object
+     *
+     * \return Size of the array
+     */
+    virtual std::size_t getSize(const UserObject& object) const = 0;
+
+    /**
+     * \brief Do the actual resize of the array
+     *
+     * \param object Object
+     * \param size New size of the array
+     */
+    virtual void setSize(const UserObject& object, std::size_t size) const = 0;
+
+    /**
+     * \brief Do the actual reading of an element
+     *
+     * This function is a pure virtual which has to be implemented in derived classes
+     *
+     * \param object Object
+     * \param index Index of the element to get
+     *
+     * \return Value of the index-th element
+     */
+    virtual Value getElement(const UserObject& object, std::size_t index) const = 0;
+
+    /**
+     * \brief Do the actual writing of an element
+     *
+     * This function is a pure virtual which has to be implemented in derived classes
+     *
+     * \param object Object
+     * \param index Index of the element to get
+     * \param value New value to assign to the element
+     */
+    virtual void setElement(const UserObject& object, std::size_t index, const Value& value) const = 0;
+
+    /**
+     * \brief Do the actual insertion of an element
+     *
+     * This function is a pure virtual which has to be implemented in derived classes
+     *
+     * \param object Object
+     * \param before Index before which the new element will be inserted
+     * \param value Value of the element to insert
+     */
+    virtual void insertElement(const UserObject& object, std::size_t before, const Value& value) const = 0;
+
+    /**
+     * \brief Do the actual removal of an element
+     *
+     * This function is a pure virtual which has to be implemented in derived classes
+     *
+     * \param object Object
+     * \param index Index of the element to remove
+     */
+    virtual void removeElement(const UserObject& object, std::size_t index) const = 0;
+
+private:
+
+    Type m_elementType; ///< Type of the individual elements of the array
+    bool m_dynamic; ///< Is the array dynamic?
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ARRAYPROPERTY_HPP
diff --git a/include/camp/camptype.hpp b/include/camp/camptype.hpp
new file mode 100644
index 0000000..8f1164a
--- /dev/null
+++ b/include/camp/camptype.hpp
@@ -0,0 +1,228 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CAMPTYPE_HPP
+#define CAMP_CAMPTYPE_HPP
+
+
+#include <camp/config.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+template <typename T> struct StaticTypeId;
+template <typename T> const char* staticTypeId(const T&);
+CAMP_API void ensureTypeRegistered(const char* id, void (*registerFunc)());
+}
+
+/**
+ * \brief Macro used to register a C++ type to CAMP
+ *
+ * Every type manipulated by CAMP must be registered with CAMP_TYPE, CAMP_AUTO_TYPE or their NONCOPYABLE versions.
+ *
+ * Example:
+ *
+ * \code
+ * class MyClass
+ * {
+ *     class MyNestedClass
+ *     {
+ *     };
+ * };
+ * CAMP_TYPE(MyClass)
+ * CAMP_TYPE(MyClass::MyNestedClass)
+ * \endcode
+ */
+#define CAMP_TYPE(type) \
+    namespace camp \
+    { \
+        namespace detail \
+        { \
+            template <> struct StaticTypeId<type> \
+            { \
+                static const char* get(bool = true) {return #type;} \
+                enum {defined = true, copyable = true}; \
+            }; \
+        } \
+    }
+
+/**
+ * \brief Macro used to register a C++ type to CAMP with automatic metaclass creation
+ *
+ * Using this macro rather than CAMP_TYPE will make CAMP automatically call
+ * the provided registration function the first time the metaclass is requested.
+ * This is useful when you don't want to have to manually call an "init" function to
+ * create your metaclass.
+ *
+ * Every type manipulated by CAMP must be registered with CAMP_TYPE, CAMP_AUTO_TYPE or their NONCOPYABLE versions.
+ *
+ * Example:
+ *
+ * \code
+ * class MyClass
+ * {
+ * public:
+ *
+ *     static void registerMetaClass();
+ * };
+ * CAMP_AUTO_TYPE(MyClass, &MyClass::registerMetaClass)
+ *
+ * void MyClass::registerMetaClass()
+ * {
+ *     camp::Class::declare<MyClass>("MyClass")
+ *         ...;
+ * }
+ * \endcode
+ *
+ * \sa CAMP_TYPE
+ */
+#define CAMP_AUTO_TYPE(type, registerFunc) \
+    namespace camp \
+    { \
+        namespace detail \
+        { \
+            template <> struct StaticTypeId<type> \
+            { \
+                static const char* get(bool checkRegister = true) \
+                { \
+                    if (checkRegister) \
+                        detail::ensureTypeRegistered(#type, registerFunc); \
+                    return #type; \
+                } \
+                enum {defined = true, copyable = true}; \
+            }; \
+        } \
+    }
+
+/**
+ * \brief Macro used to register a non-copyable C++ type to CAMP
+ *
+ * Disabled copy and assignment cannot be detected at compile-time, thus users have to explicitely tell CAMP
+ * when a type is not copyable/assignable. Objects of a non-copyable class can be modified through their metaproperties,
+ * but they can't be written with a single call to replace to whole object.
+ *
+ * Every type manipulated by CAMP must be registered with CAMP_TYPE, CAMP_AUTO_TYPE or their NONCOPYABLE versions.
+ *
+ * Example:
+ *
+ * \code
+ * class NonCopyable : boost::noncopyable
+ * {
+ *     int x;
+ * };
+ * CAMP_TYPE_NONCOPYABLE(NonCopyable)
+ *
+ * class MyClass
+ * {
+ *     NonCopyable* nc;
+ * };
+ * CAMP_TYPE(MyClass)
+ *
+ * MyClass c;
+ * const camp::Class& m1 = camp::classByObject(c);
+ * const camp::Class& m2 = camp::classByObject(c.nc);
+ * const camp::Property& p1 = m1.property("nc");
+ * const camp::Property& p2 = m2.property("x");
+ * p1.set(c, NonCopyable()); // ERROR
+ * p2.set(p1.get(c).to<camp::UserObject>(), 10); // OK
+ * \endcode
+ *
+ * \sa CAMP_TYPE
+ */
+#define CAMP_TYPE_NONCOPYABLE(type) \
+    namespace camp \
+    { \
+        namespace detail \
+        { \
+            template <> struct StaticTypeId<type> \
+            { \
+                static const char* get(bool = true) {return #type;} \
+                enum {defined = true, copyable = false}; \
+            }; \
+        } \
+    }
+
+/**
+ * \brief Macro used to register a non-copyable C++ type to CAMP with automatic metaclass creation
+ *
+ * Using this macro rather than CAMP_TYPE_NONCOPYABLE will make CAMP automatically call
+ * the provided registration function the first time the metaclass is requested.
+ * This is useful when you don't want to have to manually call an "init" function to
+ * create your metaclass.
+ *
+ * Every type manipulated by CAMP must be registered with CAMP_TYPE, CAMP_AUTO_TYPE or their NONCOPYABLE versions.
+ *
+ * \sa CAMP_AUTO_TYPE, CAMP_TYPE_NONCOPYABLE
+ */
+#define CAMP_AUTO_TYPE_NONCOPYABLE(type, registerFunc) \
+    namespace camp \
+    { \
+        namespace detail \
+        { \
+            template <> struct StaticTypeId<type> \
+            { \
+                static const char* get(bool checkRegister = true) \
+                { \
+                    if (checkRegister) \
+                        detail::ensureTypeRegistered(#type, registerFunc); \
+                    return #type; \
+                } \
+                enum {defined = true, copyable = false}; \
+            }; \
+        } \
+    }
+
+/**
+ * \brief Macro used to activate the CAMP RTTI system into a hierarchy of classes
+ *
+ * This macro must be inserted in both base and derived classes if you want CAMP
+ * to be able to retrieve the dynamic type of polymorphic objects.
+ *
+ * Example:
+ *
+ * \code
+ * class MyBase
+ * {
+ *     CAMP_RTTI()
+ * };
+ *
+ * class MyDerived : public MyBase
+ * {
+ *     CAMP_RTTI()
+ * };
+ *
+ * MyBase* b = new MyDerived;
+ * const camp::Class& mc = camp::classByObject(b);
+ * // mc == metaclass of MyDerived
+ * \endcode
+ */
+#define CAMP_RTTI() \
+    public: virtual const char* campClassId() const {return camp::detail::staticTypeId(this);} \
+    private:
+
+} // namespace camp
+
+
+#endif // CAMP_CAMPTYPE_HPP
diff --git a/include/camp/class.hpp b/include/camp/class.hpp
new file mode 100644
index 0000000..0aa6424
--- /dev/null
+++ b/include/camp/class.hpp
@@ -0,0 +1,372 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CLASS_HPP
+#define CAMP_CLASS_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/args.hpp>
+#include <camp/classget.hpp>
+#include <camp/classcast.hpp>
+#include <camp/property.hpp>
+#include <camp/function.hpp>
+#include <camp/tagholder.hpp>
+#include <camp/errors.hpp>
+#include <camp/userobject.hpp>
+#include <camp/detail/classmanager.hpp>
+#include <camp/detail/typeid.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <string>
+
+
+namespace bm = boost::multi_index;
+
+namespace camp
+{
+template <typename T> class ClassBuilder;
+class Constructor;
+class Value;
+class ClassVisitor;
+
+/**
+ * \brief camp::Class represents a metaclass composed of properties and functions
+ *
+ * camp::Class is the main class of the CAMP API. It defines a metaclass, which
+ * is an abstract representation of a C++ class with its own properties,
+ * functions, constructors, base classes, etc.
+ *
+ * Classes are declared, bound to a C++ type and filled with the \c declare
+ * template function.
+ *
+ * \code
+ * class MyClass
+ * {
+ * public:
+ *
+ *     MyClass();
+ *     int getProp() const;
+ *     void setProp(int);
+ *     std::string func();
+ * };
+ *
+ * camp::Class::declare<MyClass>("MyClass")
+ *     .tag("help", "this is my class")
+ *     .constructor0()
+ *     .property("prop", &MyClass::getProp, &MyClass::setProp)
+ *     .function("func", &MyClass::func);
+ * \endcode
+ *
+ * It then provides a set of accessors to retrieve its member functions and properties.
+ *
+ * \code
+ * const camp::Class& metaclass = camp::classByType<MyClass>();
+ *
+ * const camp::Property& prop = metaclass.property("prop");
+ * const camp::Function& func = metaclass.function("func");
+ * \endcode
+ *
+ * Another way to inspect a class, which is more type-safe, is to use a ClassVisitor.
+ *
+ * \code
+ * MyVisitor visitor;
+ * metaclass.visit(visitor);
+ * \endcode
+ *
+ * It also allows to create and destroy instances of the bound C++ class.
+ *
+ * \code
+ * MyClass* obj = metaclass.construct<MyClass>();
+ * metaclass.destroy(obj);
+ * \endcode
+ *
+ * \remark All function and property names are unique within the metaclass.
+ *
+ * \sa Enum, TagHolder, ClassBuilder, Function, Property
+ */
+class CAMP_API Class : public TagHolder, boost::noncopyable
+{
+public:
+
+    /**
+     * \brief Declare a new metaclass
+     *
+     * This is the function to call to create a new metaclass. The template
+     * parameter T is the C++ class that will be bound to the metaclass.
+     *
+     * \param name Name of the metaclass in CAMP. This name identifies
+     *             the metaclass and thus has to be unique
+     *
+     * \return A ClassBuilder<T> object that will provide functions
+     *         to fill the new metaclass with properties, functions, etc.
+     */
+    template <typename T>
+    static ClassBuilder<T> declare(const std::string& name);
+
+public:
+
+    /**
+     * \brief Return the name of the metaclass
+     *
+     * \return String containing the name of the metaclass
+     */
+    const std::string& name() const;
+
+    /**
+     * \brief Return the total number of base metaclasses of this metaclass
+     *
+     * \return Number of base metaclasses
+     */
+    std::size_t baseCount() const;
+
+    /**
+     * \brief Return a base metaclass from its index
+     *
+     * \param index Index of the base to get
+     *
+     * \return Reference to the index-th base metaclass of this metaclass
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Class& base(std::size_t index) const;
+
+    /**
+     * \brief Return the total number of functions of this metaclass
+     *
+     * \return Number of functions
+     */
+    std::size_t functionCount() const;
+
+    /**
+     * \brief Check if this metaclass contains the given function
+     *
+     * \param name Name of the function to check
+     *
+     * \return True if the function is in the metaclass, false otherwise
+     */
+    bool hasFunction(const std::string& name) const;
+
+    /**
+     * \brief Get a function from its index in this metaclass
+     *
+     * \param index Index of the function to get
+     *
+     * \return Reference to the function
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Function& function(std::size_t index) const;
+
+    /**
+     * \brief Get a function from its name
+     *
+     * \param name Name of the function to get (case sensitive)
+     *
+     * \return Reference to the function
+     *
+     * \throw FunctionNotFound \a name is not a function of the metaclass
+     */
+    const Function& function(const std::string& name) const;
+
+    /**
+     * \brief Return the total number of properties of this metaclass
+     *
+     * \return Number of properties
+     */
+    std::size_t propertyCount() const;
+
+    /**
+     * \brief Check if this metaclass contains the given property
+     *
+     * \param name Name of the property to check
+     *
+     * \return True if the property is in the metaclass, false otherwise
+     */
+    bool hasProperty(const std::string& name) const;
+
+    /**
+     * \brief Get a property from its index in this metaclass
+     *
+     * \param index Index of the property to get
+     *
+     * \return Reference to the property
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Property& property(std::size_t index) const;
+
+    /**
+     * \brief Get a property from its name
+     *
+     * \param name Name of the property to get (case sensitive)
+     *
+     * \return Reference to the property
+     *
+     * \throw PropertyNotFound \a name is not a property of the metaclass
+     */
+    const Property& property(const std::string& name) const;
+
+    /**
+     * \brief Construct a new instance of the C++ class bound to the metaclass
+     *
+     * If no constructor can match the provided arguments, UserObject::nothing
+     * is returned.
+     * The new instance is wrapped into a UserObject. It must be destroyed
+     * with the Class::destroy function.
+     *
+     * \param args Arguments to pass to the constructor (empty by default)
+     *
+     * \return New instance wrapped into a UserObject, or UserObject::nothing if it failed
+     */
+    UserObject construct(const Args& args = Args::empty) const;
+
+    /**
+     * \brief Destroy an instance of the C++ class bound to the metaclass
+     *
+     * This function must be called to destroy every instance created with
+     * Class::construct.
+     *
+     * \param object Object to be destroyed
+     */
+    void destroy(const UserObject& object) const;
+
+    /**
+     * \brief Start visitation of a class
+     *
+     * \param visitor Visitor to use for visitation
+     */
+    void visit(ClassVisitor& visitor) const;
+
+    /**
+     * \brief Convert a pointer to an object to be compatible with a base or derived metaclass
+     *
+     * The target metaclass may be a base or a derived of this, both cases are properly handled.
+     *
+     * \param pointer Pointer to convert
+     * \param target Target metaclass to convert to
+     *
+     * \return Converted pointer
+     *
+     * \throw ClassUnrelated \a target is not a base nor a derived class of this
+     */
+    void* applyOffset(void* pointer, const Class& target) const;
+
+    /**
+     * \brief Operator == to check equality between two metaclasses
+     *
+     * Two metaclasses are equal if their name is the same.
+     *
+     * \param other Metaclass to compare with this
+     *
+     * \return True if both metaclasses are the same, false otherwise
+     */
+    bool operator==(const Class& other) const;
+
+    /**
+     * \brief Operator != to check inequality between two metaclasses
+     *
+     * \param other Metaclass to compare with this
+     *
+     * \return True if metaclasses are different, false if they are equal
+     */
+     bool operator!=(const Class& other) const;
+
+private:
+
+    template <typename T> friend class ClassBuilder;
+    friend class detail::ClassManager;
+
+    /**
+     * \brief Construct the metaclass from its name
+     *
+     * \param name Name of the metaclass
+     */
+    Class(const std::string& name);
+
+    /**
+     * \brief Get the offset of a base metaclass
+     *
+     * \param base Base metaclass to check
+     *
+     * \return offset between this and base, or -1 if both classes are unrelated
+     */
+    int baseOffset(const Class& base) const;
+
+private:
+
+    /**
+     * \brief Structure holding informations about a base metaclass
+     */
+    struct BaseInfo
+    {
+        const Class* base;
+        int offset;
+    };
+
+    typedef boost::shared_ptr<Property> PropertyPtr;
+    typedef boost::shared_ptr<Function> FunctionPtr;
+    typedef boost::shared_ptr<Constructor> ConstructorPtr;
+    typedef std::vector<ConstructorPtr> ConstructorList;
+    typedef std::vector<BaseInfo> BaseList;
+
+    struct Id;
+    struct Name;
+
+    typedef boost::multi_index_container<PropertyPtr,
+        bm::indexed_by<bm::random_access<bm::tag<Id> >,
+                       bm::ordered_unique<bm::tag<Name>, bm::const_mem_fun<Property, const std::string&, &Property::name> >
+        >
+    > PropertyTable;
+
+    typedef boost::multi_index_container<FunctionPtr,
+        bm::indexed_by<bm::random_access<bm::tag<Id> >,
+                       bm::ordered_unique<bm::tag<Name>, bm::const_mem_fun<Function, const std::string&, &Function::name> >
+        >
+    > FunctionTable;
+
+    typedef PropertyTable::index<Name>::type PropertyNameIndex;
+    typedef FunctionTable::index<Name>::type FunctionNameIndex;
+    typedef void (*Destructor)(const UserObject&);
+
+    std::string m_name; ///< Name of the metaclass
+    FunctionTable m_functions; ///< Table of metafunctions indexed by name
+    PropertyTable m_properties; ///< Table of metaproperties indexed by name
+    BaseList m_bases; ///< List of base metaclasses
+    ConstructorList m_constructors; ///< List of metaconstructors
+    Destructor m_destructor; ///< Destructor (function that is able to delete an abstract object)
+};
+
+} // namespace camp
+
+// Must be included here because of mutual dependance between Class and ClassBuilder
+#include <camp/classbuilder.hpp>
+
+#include <camp/class.inl>
+
+
+#endif // CAMP_CLASS_HPP
diff --git a/include/camp/class.inl b/include/camp/class.inl
new file mode 100644
index 0000000..b5d1e52
--- /dev/null
+++ b/include/camp/class.inl
@@ -0,0 +1,44 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+    template <typename T>
+    void destroy(const UserObject& object)
+    {
+        //delete object.get<T*>();
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T> Class::declare(const std::string& name)
+{
+    Class& newClass = detail::ClassManager::instance().addClass(name, detail::StaticTypeId<T>::get(false));
+    newClass.m_destructor = &detail::destroy<T>;
+    return ClassBuilder<T>(newClass);
+}
+
+} // namespace camp
diff --git a/include/camp/classbuilder.hpp b/include/camp/classbuilder.hpp
new file mode 100644
index 0000000..ae5e6ec
--- /dev/null
+++ b/include/camp/classbuilder.hpp
@@ -0,0 +1,485 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CLASSBUILDER_HPP
+#define CAMP_CLASSBUILDER_HPP
+
+
+#include <camp/type.hpp>
+#include <camp/classget.hpp>
+#include <camp/detail/functionimpl.hpp>
+#include <camp/detail/functiontraits.hpp>
+#include <camp/detail/constructorimpl.hpp>
+#include <camp/detail/propertyfactory.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/function_types/function_type.hpp>
+#include <cassert>
+#include <string>
+
+
+namespace camp
+{
+/**
+ * \brief Proxy class which fills a metaclass with its members
+ *
+ * This class is returned by Class::declare<T> in order construct a
+ * new metaclass. It contains functions to declare and bind metaproperties,
+ * metafunctions, base metaclasses, metaconstructors, etc. with many overloads
+ * in order to accept as many types of binds as possible.
+ *
+ * ClassBuilder also contains functions to set attributes of metafunctions
+ * and metaproperties.
+ *
+ * This class should never be explicitely instanciated, unless you
+ * need to split the metaclass creation in multiple parts.
+ */
+template <typename T>
+class ClassBuilder
+{
+public:
+
+    /**
+     * \brief Construct the builder with a target metaclass to fill
+     *
+     * \param target Metaclass to build
+     */
+    ClassBuilder(Class& target);
+
+    /**
+     * \brief Declare a base metaclass
+     *
+     * The template parameter U is the C++ base class of T.
+     *
+     * This function makes the target metaclass inherit of all the metaproperties and
+     * metafunctions of the given base metaclass.
+     *
+     * \return Reference to this, in order to chain other calls
+     *
+     * \throw ClassNotFound no metaclass is bound to U
+     */
+    template <typename U>
+    ClassBuilder<T>& base();
+
+    /**
+     * \brief Declare a new property from a single accessor
+     *
+     * The accessor argument can be a getter of any valid type, or a direct
+     * pointer-to-member (which is considered both a getter and a setter)
+     *
+     * Example:
+     *
+     * \code
+     * struct Point
+     * {
+     *     float x;
+     *     float y;
+     *
+     *     float length() const;
+     * };
+     *
+     * camp::Class::declare<Point>("Point")
+     *     .property("x",      &Point::x);      // getter + setter
+     *     .property("y",      &Point::y);      // getter + setter
+     *     .property("length", &Point::length); // getter only
+     * \endcode
+
+     * \param name Name of the property (must be unique within the metaclass)
+     * \param accessor Accessor to the C++ implementation of the property
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& property(const std::string& name, F accessor);
+
+    /**
+     * \brief Declare a new property from a pair of accessors
+     *
+     * The accessor1 and accessor2 arguments can be a pair of getter/setter, or
+     * two getters which must be composed to form a single getter.
+     * If F1 is a direct pointer-to-member, it is considered both a getter and a setter.
+     *
+     * Having two getters allows to expose a property which requires an extra level of indirection to be accessed
+     * (for example, a property of a member of the class instead of a property of the class itself).
+     *
+     * Example:
+     *
+     * \code
+     * struct Point {float x, y;};
+     * 
+     * class Entity
+     * {
+     * public:
+     *
+     *     Point p;
+     * };
+     *
+     * camp::Class::declare<Entity>("Entity")
+     *     .property("x", &Point::x, &Entity::p); // will internally resolve to e.p.x
+     *     .property("y", &Point::y, &Entity::p); // will internally resolve to e.p.y
+     * \endcode
+     *
+     * \param name Name of the property (must be unique within the metaclass)
+     * \param accessor1 First accessor to the C++ implementation of the property (getter)
+     * \param accessor2 Second accessor to the C++ implementation of the property (setter or getter to compose)
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F1, typename F2>
+    ClassBuilder<T>& property(const std::string& name, F1 accessor1, F2 accessor2);
+
+    /**
+     * \brief Declare a new property from three accessors
+     *
+     * The accessor1 and accessor2 arguments are a pair of getter/setter, accessor3 is
+     * an accessor to compose to accessor1 and accessor2 to get the final accessors.
+     *
+     * This allows to expose a property which requires an extra level of indirection to be accessed
+     * (for example, a property of a member of the class instead of a property of the class itself).
+     *
+     * Example:
+     *
+     * \code
+     * struct Point
+     * {
+     *     float getX() const;
+     *     void setX(float);
+     *
+     *     float getY() const;
+     *     void setY(float);
+     * };
+     * 
+     * class Entity
+     * {
+     * public:
+     *
+     *     Point p;
+     * };
+     *
+     * camp::Class::declare<Entity>("Entity")
+     *     .property("x", &Point::getX, &Point::setX, &Entity::p); // will internally resolve to e.p.get/setX()
+     *     .property("y", &Point::getY, &Point::setY, &Entity::p); // will internally resolve to e.p.get/setY()
+     * \endcode
+     *
+     * \param name Name of the property (must be unique within the metaclass)
+     * \param accessor1 First accessor (getter)
+     * \param accessor2 Second accessor (setter)
+     * \param accessor3 Third accessor (getter)
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F1, typename F2, typename F3>
+    ClassBuilder<T>& property(const std::string& name, F1 accessor1, F2 accessor2, F3 accessor3);
+
+    /**
+     * \brief Declare a new function from any bindable type
+     *
+     * The function argument can be any valid type: a non-member function,
+     * a member function, const, non-const, etc.
+     *
+     * \param name Name of the function (must be unique within the metaclass)
+     * \param function C++ callable entity to bind to the function
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& function(const std::string& name, F function);
+
+    /**
+     * \brief Declare a new function from a boost::function
+     *
+     * Overload handling functions of type boost::function.
+     *
+     * \param name Name of the function (must be unique within the metaclass)
+     * \param function Instance of boost::function to bind to the function
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& function(const std::string& name, boost::function<F> function);
+
+    /**
+     * \brief Declare a new function from two functions to compose
+     *
+     * This allows to expose a function which requires an extra level of indirection to be accessed
+     * (for example, a function of a member of the class instead of a function of the class itself).
+     *
+     * Example:
+     *
+     * \code
+     * struct Point
+     * {
+     *     void move(float x, float y);
+     * };
+     * 
+     * class Entity
+     * {
+     * public:
+     *
+     *     Point p;
+     * };
+     *
+     * camp::Class::declare<Entity>("Entity")
+     *     .function("move", &Point::move, &Entity::p); // will internally resolve to e.p.move()
+     * \endcode
+     *
+     * \param name Name of the function (must be unique within the metaclass)
+     * \param function1 C++ callable entity to bind to the function
+     * \param function2 Accessor returning the member to apply to function1
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F1, typename F2>
+    ClassBuilder<T>& function(const std::string& name, F1 function1, F2 function2);
+
+    /**
+     * \brief Declare a new static tag
+     *
+     * \param id Identifier of the new tag (must be unique within the metaclass)
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& tag(const Value& id);
+
+    /**
+     * \brief Declare a new tag with value
+     *
+     * \param id Identifier of the new tag (must be unique within the metaclass)
+     * \param value Value associated to the tag. It can be a static value, or a function
+     *              which will be evaluated each time the tag will be requested
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename U>
+    ClassBuilder<T>& tag(const Value& id, const U& value);
+
+    /**
+     * \brief Set the readable state of the current property with a static value
+     *
+     * \param value True to set the current property as readable, false otherwise
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& readable(bool value);
+
+    /**
+     * \brief Set the readable state of the current property with a dynamic value
+     *
+     * function can be any C++ callable type, and will be called to return the
+     * readable state of the property each time it is requested. This way, the readable
+     * state of a property can depend on metaclass instances.
+     *
+     * \param function Function to call to get the readable state of the property
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& readable(F function);
+
+    /**
+     * \brief Set the writable state of the current property with a static value
+     *
+     * \param value True to set the current property as writable, false otherwise
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& writable(bool value);
+
+    /**
+     * \brief Set the writable state of the current property with a dynamic value
+     *
+     * function can be any C++ callable type, and will be called to return the
+     * writable state of the property each time it is requested. This way, the writable
+     * state of a property can depend on metaclass instances.
+     *
+     * \param function Function to call to get the writable state of the property
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& writable(F function);
+
+    /**
+     * \brief Set the callable state of the current function with a static value
+     *
+     * \param value True to set the current function as callable, false otherwise
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& callable(bool value);
+
+    /**
+     * \brief Set the callable state of the current function with a dynamic value
+     *
+     * function can be any C++ callable type, and will be called to return the
+     * callable state of the function each time it is requested. This way, the callable
+     * state of a function can depend on metaclass instances.
+     *
+     * \param function Function to call to get the callable state of the function
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename F>
+    ClassBuilder<T>& callable(F function);
+
+    /**
+     * \brief Declare a default constructor for the metaclass
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& constructor0();
+
+    /**
+     * \brief Declare a constructor with 1 parameter for the metaclass
+     *
+     * A0 is the type of the parameter
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename A0>
+    ClassBuilder<T>& constructor1();
+
+    /**
+     * \brief Declare a constructor with 2 parameters for the metaclass
+     *
+     * A0 is the type of the first parameter.
+     * A1 is the type of the second parameter.
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename A0, typename A1>
+    ClassBuilder<T>& constructor2();
+
+    /**
+     * \brief Declare a constructor with 3 parameters for the metaclass
+     *
+     * A0 is the type of the first parameter.
+     * A1 is the type of the second parameter.
+     * A2 is the type of the third parameter.
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename A0, typename A1, typename A2>
+    ClassBuilder<T>& constructor3();
+
+    /**
+     * \brief Declare a constructor with 4 parameters for the metaclass
+     *
+     * A0 is the type of the first parameter.
+     * A1 is the type of the second parameter.
+     * A2 is the type of the third parameter.
+     * A3 is the type of the fourth parameter.
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename A0, typename A1, typename A2, typename A3>
+    ClassBuilder<T>& constructor4();
+
+    /**
+     * \brief Declare a constructor with 5 parameters for the metaclass
+     *
+     * A0 is the type of the first parameter.
+     * A1 is the type of the second parameter.
+     * A2 is the type of the third parameter.
+     * A3 is the type of the fourth parameter.
+     * A4 is the type of the fifth parameter.
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <typename A0, typename A1, typename A2, typename A3, typename A4>
+    ClassBuilder<T>& constructor5();
+
+    /**
+     * \brief Add properties and/or functions from an external source
+     *
+     * The purpose of this function is to allow the binding of classes
+     * that already use a similar system of metaproperties and metafunctions,
+     * with a direct mapping from external attributes to CAMP ones.
+     *
+     * The mapping process must be done in a specific mapper class (see below), thus avoiding
+     * to manually write the mapping for every class.
+     *
+     * The mapper class must accept a template parameter (which is the target C++ class)
+     * and be compatible with the following interface:
+     *
+     * \code
+     * template <typename T>
+     * class MyClassMapper
+     * {
+     * public:
+     *
+     *     MyClassMapper();
+     *
+     *     size_t propertyCount();
+     *     camp::Property* property(size_t index);
+     *
+     *     size_t functionCount();
+     *     camp::Function* function(size_t index);
+     * };
+     * \endcode
+     *
+     * Example of usage:
+     *
+     * \code
+     * camp::Class::declare<MyClass>("MyClass")
+     *     .external<MyClassMapper>()
+     *     ...
+     * \endcode
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    template <template <typename> class U>
+    ClassBuilder<T>& external();
+
+private:
+
+    /**
+     * \brief Add a new property to the target class
+     *
+     * \param property Property to add
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& addProperty(Property* property);
+
+    /**
+     * \brief Add a new function to the target class
+     *
+     * \param function Function to add
+     *
+     * \return Reference to this, in order to chain other calls
+     */
+    ClassBuilder<T>& addFunction(Function* function);
+
+    Class* m_target; ///< Target metaclass to fill
+    TagHolder* m_currentTagHolder; ///< Last tag holder which has been declared
+    Property* m_currentProperty; ///< Last metaproperty which has been declared
+    Function* m_currentFunction; ///< Last function which has been declared
+};
+
+} // namespace camp
+
+#include <camp/classbuilder.inl>
+
+
+#endif // CAMP_CLASSBUILDER_HPP
diff --git a/include/camp/classbuilder.inl b/include/camp/classbuilder.inl
new file mode 100644
index 0000000..6b9b5bb
--- /dev/null
+++ b/include/camp/classbuilder.inl
@@ -0,0 +1,375 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>::ClassBuilder(Class& target)
+    : m_target(&target)
+    , m_currentTagHolder(m_target)
+    , m_currentProperty(0)
+    , m_currentFunction(0)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename U>
+ClassBuilder<T>& ClassBuilder<T>::base()
+{
+    // Retrieve the base metaclass and its name
+    const Class& baseClass = classByType<U>();
+    std::string baseName = baseClass.name();
+
+    // First make sure that the base class is not already a base of the current class
+    Class::BaseList::const_iterator endBase = m_target->m_bases.end();
+    for (Class::BaseList::const_iterator it = m_target->m_bases.begin(); it != endBase; ++it)
+    {
+        assert(it->base->name() != baseName);
+    }
+
+    // Compute the offset to apply for pointer conversions
+    T* asDerived = reinterpret_cast<T*>(1);
+    U* asBase = static_cast<U*>(asDerived);
+    int offset = static_cast<int>(reinterpret_cast<char*>(asBase) - reinterpret_cast<char*>(asDerived));
+
+    // Add the base metaclass to the bases of the current class
+    Class::BaseInfo baseInfos;
+    baseInfos.base = &baseClass;
+    baseInfos.offset = offset;
+    m_target->m_bases.push_back(baseInfos);
+
+    // Copy all properties of the base class into the current class
+    for (Class::PropertyTable::const_iterator it = baseClass.m_properties.begin();
+        it != baseClass.m_properties.end();
+        ++it)
+    {
+        m_target->m_properties.push_back(*it);
+    }
+
+    // Copy all functions of the base class into the current class
+    for (Class::FunctionTable::const_iterator it = baseClass.m_functions.begin();
+        it != baseClass.m_functions.end();
+        ++it)
+    {
+        m_target->m_functions.push_back(*it);
+    }
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::property(const std::string& name, F accessor)
+{
+    // Find the factory which will be able to construct a camp::Property from an accessor of type F
+    typedef detail::PropertyFactory1<T, F> Factory;
+
+    // Construct and add the metaproperty
+    return addProperty(Factory::get(name, accessor));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F1, typename F2>
+ClassBuilder<T>& ClassBuilder<T>::property(const std::string& name, F1 accessor1, F2 accessor2)
+{
+    // Find the factory which will be able to construct a camp::Property from accessors of type F1 and F2
+    typedef detail::PropertyFactory2<T, F1, F2> Factory;
+
+    // Construct and add the metaproperty
+    return addProperty(Factory::get(name, accessor1, accessor2));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F1, typename F2, typename F3>
+ClassBuilder<T>& ClassBuilder<T>::property(const std::string& name, F1 accessor1, F2 accessor2, F3 accessor3)
+{
+    // Find the factory which will be able to construct a camp::Property from accessors of type F1, F2 and F3
+    typedef detail::PropertyFactory3<T, F1, F2, F3> Factory;
+
+    // Construct and add the metaproperty
+    return addProperty(Factory::get(name, accessor1, accessor2, accessor3));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::function(const std::string& name, F function)
+{
+    // Get a uniform function type from F, whatever it really is
+    typedef typename boost::function_types::function_type<F>::type Signature;
+
+    // Construct and add the metafunction
+    return addFunction(new detail::FunctionImpl<Signature>(name, function));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::function(const std::string& name, boost::function<F> function)
+{
+    return addFunction(new detail::FunctionImpl<F>(name, function));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F1, typename F2>
+ClassBuilder<T>& ClassBuilder<T>::function(const std::string& name, F1 function1, F2 function2)
+{
+    // Get uniform function types from F1 and F2, whatever they really are
+    typedef typename boost::function_types::function_type<F1>::type Signature1;
+    typedef typename boost::function_types::function_type<F2>::type Signature2;
+
+    // Construct and add the metafunction
+    return addFunction(new detail::FunctionImpl<Signature1, Signature2>(name, function1, function2));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::tag(const Value& id)
+{
+    return tag(id, Value::nothing);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename U>
+ClassBuilder<T>& ClassBuilder<T>::tag(const Value& id, const U& value)
+{
+    // Make sure we have a valid tag holder, and the tag doesn't already exists
+    assert(m_currentTagHolder && !m_currentTagHolder->hasTag(id));
+
+    // For the special case of Getter<Value>, the ambiguity between both constructors
+    // cannot be automatically solved, so let's do it manually
+    typedef typename boost::mpl::if_c<detail::FunctionTraits<U>::isFunction, boost::function<Value (T&)>, Value>::type Type;
+
+    // Add the new tag (override if already exists)
+    m_currentTagHolder->m_tags[id] = detail::Getter<Value>(Type(value));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::readable(bool value)
+{
+    // Make sure we have a valid property
+    assert(m_currentProperty != 0);
+
+    m_currentProperty->m_readable = detail::Getter<bool>(value);
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::readable(F function)
+{
+    // Make sure we have a valid property
+    assert(m_currentProperty != 0);
+
+    m_currentProperty->m_readable = detail::Getter<bool>(boost::function<bool (T&)>(function));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::writable(bool value)
+{
+    // Make sure we have a valid property
+    assert(m_currentProperty != 0);
+
+    m_currentProperty->m_writable = detail::Getter<bool>(value);
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::writable(F function)
+{
+    // Make sure we have a valid property
+    assert(m_currentProperty != 0);
+
+    m_currentProperty->m_writable = detail::Getter<bool>(boost::function<bool (T&)>(function));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::callable(bool value)
+{
+    // Make sure we have a valid function
+    assert(m_currentFunction != 0);
+
+    m_currentFunction->m_callable = detail::Getter<bool>(value);
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename F>
+ClassBuilder<T>& ClassBuilder<T>::callable(F function)
+{
+    // Make sure we have a valid function
+    assert(m_currentFunction != 0);
+
+    m_currentFunction->m_callable = detail::Getter<bool>(boost::function<bool (T&)>(function));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::constructor0()
+{
+    Constructor* constructor = new detail::ConstructorImpl0<T>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename A0>
+ClassBuilder<T>& ClassBuilder<T>::constructor1()
+{
+    Constructor* constructor = new detail::ConstructorImpl1<T, A0>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename A0, typename A1>
+ClassBuilder<T>& ClassBuilder<T>::constructor2()
+{
+    Constructor* constructor = new detail::ConstructorImpl2<T, A0, A1>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename A0, typename A1, typename A2>
+ClassBuilder<T>& ClassBuilder<T>::constructor3()
+{
+    Constructor* constructor = new detail::ConstructorImpl3<T, A0, A1, A2>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename A0, typename A1, typename A2, typename A3>
+ClassBuilder<T>& ClassBuilder<T>::constructor4()
+{
+    Constructor* constructor = new detail::ConstructorImpl4<T, A0, A1, A2, A3>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename A0, typename A1, typename A2, typename A3, typename A4>
+ClassBuilder<T>& ClassBuilder<T>::constructor5()
+{
+    Constructor* constructor = new detail::ConstructorImpl5<T, A0, A1, A2, A3, A4>;
+    m_target->m_constructors.push_back(Class::ConstructorPtr(constructor));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <template <typename> class U>
+ClassBuilder<T>& ClassBuilder<T>::external()
+{
+    // Create an instance of the mapper
+    U<T> mapper;
+
+    // Retrieve the properties
+    std::size_t propertyCount = mapper.propertyCount();
+    for (std::size_t i = 0; i < propertyCount; ++i)
+        addProperty(mapper.property(i));
+
+    // Retrieve the functions
+    std::size_t functionCount = mapper.functionCount();
+    for (std::size_t i = 0; i < functionCount; ++i)
+        addFunction(mapper.function(i));
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::addProperty(Property* property)
+{
+    // Retrieve the class' properties indexed by name
+    Class::PropertyNameIndex& properties = m_target->m_properties.get<Class::Name>();
+
+    // First remove any property that already exists with the same name
+    properties.erase(property->name());
+
+    // Insert the new property
+    properties.insert(Class::PropertyPtr(property));
+
+    m_currentTagHolder = m_currentProperty = property;
+    m_currentFunction = 0;
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ClassBuilder<T>& ClassBuilder<T>::addFunction(Function* function)
+{
+    // Retrieve the class' functions indexed by name
+    Class::FunctionNameIndex& functions = m_target->m_functions.get<Class::Name>();
+
+    // First remove any function that already exists with the same name
+    functions.erase(function->name());
+
+    // Insert the new function
+    functions.insert(Class::FunctionPtr(function));
+
+    m_currentTagHolder = m_currentFunction = function;
+    m_currentProperty = 0;
+
+    return *this;
+}
+
+} // namespace camp
diff --git a/include/camp/classcast.hpp b/include/camp/classcast.hpp
new file mode 100644
index 0000000..8d3188e
--- /dev/null
+++ b/include/camp/classcast.hpp
@@ -0,0 +1,50 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CLASSCAST_HPP
+#define CAMP_CLASSCAST_HPP
+
+
+#include <camp/config.hpp>
+
+
+namespace camp
+{
+class Class;
+
+/**
+ * \brief Convert a pointer from a source metaclass to a related target metaclass
+ *
+ * \param pointer Source pointer to convert
+ * \param sourceClass Source metaclass to convert from
+ * \param targetClass Target metaclass to convert to
+ *
+ * \return Converted pointer, or 0 on failure
+ *
+ * \throw ClassUnrelated sourceClass is not a base nor a derived of targetClass
+ */
+CAMP_API void* classCast(void* pointer, const Class& sourceClass, const Class& targetClass);
+
+} // namespace camp
+
+#endif // CAMP_CLASSCAST_HPP
diff --git a/include/camp/classget.hpp b/include/camp/classget.hpp
new file mode 100644
index 0000000..17d5b88
--- /dev/null
+++ b/include/camp/classget.hpp
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CLASSGET_HPP
+#define CAMP_CLASSGET_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/error.hpp>
+#include <camp/detail/typeid.hpp>
+#include <camp/detail/classmanager.hpp>
+#include <string>
+
+
+namespace camp
+{
+/**
+ * \relates Class
+ *
+ * \brief Get the total number of existing metaclasses
+ *
+ * \return Global metaclass count
+ */
+std::size_t classCount();
+
+/**
+ * \relates Class
+ *
+ * \brief Get a metaclass from its global index
+ *
+ * The purpose of this function is to provide a way to iterate through
+ * all existing metaclasses. \sa classCount
+ *
+ * \param index Index of the metaclass to get
+ *
+ * \return Reference to the index-th metaclass
+ *
+ * \throw OutOfRange index is out of range
+ */
+const Class& classByIndex(std::size_t index);
+
+/**
+ * \relates Class
+ *
+ * \brief Get a metaclass from its name
+ *
+ * \param name Name of the metaclass to retrieve (case sensitive)
+ *
+ * \return Reference to the requested metaclass
+ *
+ * \throw ClassNotFound name is not a valid metaclass name
+ */
+const Class& classByName(const std::string& name);
+
+/**
+ * \relates Class
+ *
+ * \brief Get a metaclass from a C++ object
+ *
+ * \param object object to get the metaclass of
+ *
+ * \return Reference to the etaclass bound to type T
+ *
+ * \throw ClassNotFound no metaclass has been declared for T or any of its bases
+ */
+template <typename T>
+const Class& classByObject(const T& object);
+
+/**
+ * \relates Class
+ *
+ * \brief Get a metaclass from its C++ type
+ *
+ * \return Reference to the metaclass bound to type T
+ *
+ * \throw ClassNotFound no metaclass has been declared for T
+ */
+template <typename T>
+const Class& classByType();
+
+/**
+ * \relates Class
+ *
+ * \brief Get a metaclass from its C++ type
+ *
+ * \return Pointer to the metaclass bound to type T, or 0 if no metaclass has been declared
+ */
+template <typename T>
+const Class* classByTypeSafe();
+
+} // namespace camp
+
+#include <camp/classget.inl>
+
+
+#endif // CAMP_CLASSGET_HPP
diff --git a/include/camp/classget.inl b/include/camp/classget.inl
new file mode 100644
index 0000000..c7f4786
--- /dev/null
+++ b/include/camp/classget.inl
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+inline std::size_t classCount()
+{
+    return detail::ClassManager::instance().count();
+}
+
+//-------------------------------------------------------------------------------------------------
+inline const Class& classByIndex(std::size_t index)
+{
+    return detail::ClassManager::instance().getByIndex(index);
+}
+
+//-------------------------------------------------------------------------------------------------
+inline const Class& classByName(const std::string& name)
+{
+    return detail::ClassManager::instance().getByName(name);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Class& classByObject(const T& object)
+{
+    return detail::ClassManager::instance().getById(detail::typeId(object));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Class& classByType()
+{
+    return detail::ClassManager::instance().getById(detail::typeId<T>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Class* classByTypeSafe()
+{
+    return detail::ClassManager::instance().getByIdSafe(detail::safeTypeId<T>());
+}
+
+} // namespace camp
diff --git a/include/camp/classvisitor.hpp b/include/camp/classvisitor.hpp
new file mode 100644
index 0000000..6220bd7
--- /dev/null
+++ b/include/camp/classvisitor.hpp
@@ -0,0 +1,159 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CLASSVISITOR_HPP
+#define CAMP_CLASSVISITOR_HPP
+
+
+#include <camp/config.hpp>
+
+
+namespace camp
+{
+class Property;
+class SimpleProperty;
+class ArrayProperty;
+class EnumProperty;
+class UserProperty;
+class Function;
+
+/**
+ * \brief Base class for writing custom Class visitors
+ *
+ * A ClassVisitor, when applied to a Class, will be notified for each member property and function of
+ * the target class. To receive this notification for a specific type T of property or function,
+ * you have to override the \c visit(T) function.
+ *
+ * The benefit of such visitation is that you directly get the actual type of the
+ * property or function, and can handle it safely without having to use dangerous downcasts.
+ *
+ * Another benefit of this method is that you can easily filter the properties and functions
+ * according to their C++ type: if you don't want to handle a specific type of property or function,
+ * just don't override the corresponding \c visit function.
+ *
+ * Here an example of a visitor which prints the contents of a class:
+ * \code
+ * class MyClassVisitor : public camp::ClassVisitor
+ * {
+ *     void visit(const camp::SimpleProperty& property)
+ *     {
+ *         std::cout << "Simple property: " << property.name() << std::endl;
+ *     }
+ * 
+ *     void visit(const camp::ArrayProperty& property)
+ *     {
+ *         std::cout << "Array property: " << property.name() << " - "
+ *                   << "dynamic:" << property.dynamic() << std::endl;
+ *     }
+ * 
+ *     void visit(const camp::EnumProperty& property)
+ *     {
+ *         std::cout << "Enum property: " << property.name() << " - "
+ *                   << "owner enum:" << property.getEnum().name() << std::endl;
+ *     }
+ * 
+ *     void visit(const camp::UserProperty& property)
+ *     {
+ *         std::cout << "User property: " << property.name() << " - "
+ *                   << "owner class:" << property.getClass().name() << std::endl;
+ *     }
+ * 
+ *     void visit(const camp::Function& function)
+ *     {
+ *         std::cout << "Function: " << function.name() << " - "
+ *                   << "number of arguments:" << function.argCount() << std::endl;
+ *     }
+ * };
+ * 
+ * const camp::Class& metaclass = camp::classByName("MyClass");
+ * MyClassVisitor visitor;
+ * metaclass.visit(visitor);
+ * \endcode
+ */
+class CAMP_API ClassVisitor
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~ClassVisitor();
+
+    /**
+     * \brief Visit any kind of property
+     *
+     * This function is a generic callback which can be used
+     * to receive all property types which are not handled with
+     * their derived type.
+     *
+     * \param property Property which is being visited
+     */
+    virtual void visit(const Property& property);
+
+    /**
+     * \brief Visit a simple property
+     *
+     * \param property Property which is being visited
+     */
+    virtual void visit(const SimpleProperty& property);
+
+    /**
+     * \brief Visit an array property
+     *
+     * \param property Property which is being visited
+     */
+    virtual void visit(const ArrayProperty& property);
+
+    /**
+     * \brief Visit an enum property
+     *
+     * \param property Property which is being visited
+     */
+    virtual void visit(const EnumProperty& property);
+
+    /**
+     * \brief Visit a user property
+     *
+     * \param property Property which is being visited
+     */
+    virtual void visit(const UserProperty& property);
+
+    /**
+     * \brief Visit a function
+     *
+     * \param function Function which is being visited
+     */
+    virtual void visit(const Function& function);
+
+protected:
+
+    /**
+     * \brief Default constructor
+     */
+    ClassVisitor();
+};
+
+} // namespace camp
+
+
+#endif // CAMP_VALUEVISITOR_HPP
diff --git a/include/camp/config.hpp b/include/camp/config.hpp
new file mode 100644
index 0000000..d333043
--- /dev/null
+++ b/include/camp/config.hpp
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CONFIG_HPP
+#define CAMP_CONFIG_HPP
+
+
+// We define the CAMP_API macro according to the
+// current operating system and build mode
+#if defined(_WIN32) || defined(__WIN32__)
+
+    #ifndef CAMP_STATIC
+
+        // Windows platforms need specific keywords for import / export
+        #ifdef CAMP_EXPORTS
+
+            // From DLL side, we must export
+            #define CAMP_API __declspec(dllexport)
+
+        #else
+
+            // From client application side, we must import
+            #define CAMP_API __declspec(dllimport)
+
+        #endif
+
+    #else
+
+        // No specific directive needed for static build
+        #define CAMP_API
+
+    #endif
+
+#else
+
+    // Other platforms don't need to define anything
+    #define CAMP_API
+
+#endif
+
+
+// We disable some annoying warnings of VC++
+#if defined(_MSC_VER)
+
+    #pragma warning(disable: 4275) // non dll-interface class 'X' used as base for dll-interface class 'Y'
+    #pragma warning(disable: 4251) // class 'X' needs to have dll-interface to be used by clients of class 'Y'
+
+#endif
+
+
+#endif // CAMP_CONFIG_HPP
diff --git a/include/camp/constructor.hpp b/include/camp/constructor.hpp
new file mode 100644
index 0000000..c210900
--- /dev/null
+++ b/include/camp/constructor.hpp
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_CONSTRUCTOR_HPP
+#define CAMP_CONSTRUCTOR_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/args.hpp>
+#include <vector>
+
+
+namespace camp
+{
+class Value;
+class UserObject;
+
+/**
+ * \brief camp::Constructor represents a metaconstructor which is used to create objects instances from metaclasses
+ *
+ * This class is an interface which has to be derived to implement typed constructors.
+ *
+ * \sa Property, Function
+ */
+class Constructor
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~Constructor() {}
+
+    /**
+     * \brief Check if the constructor matches the given set of arguments
+     *
+     * \param args Set of arguments to check
+     *
+     * \return True if the constructor is compatible with the given arguments
+     */
+    virtual bool matches(const Args& args) const = 0;
+
+    /**
+     * \brief Use the constructor to create a new object
+     *
+     * \param args Set of arguments to pass to the constructor
+     *
+     * \return Pointer to the new object wrapped in a UserObject, or UserObject::nothing on failure
+     */
+    virtual UserObject create(const Args& args) const = 0;
+};
+
+} // namespace camp
+
+
+#endif // CAMP_CONSTRUCTOR_HPP
diff --git a/include/camp/detail/arraypropertyimpl.hpp b/include/camp/detail/arraypropertyimpl.hpp
new file mode 100644
index 0000000..ec3ca65
--- /dev/null
+++ b/include/camp/detail/arraypropertyimpl.hpp
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_ARRAYPROPERTYIMPL_HPP
+#define CAMP_DETAIL_ARRAYPROPERTYIMPL_HPP
+
+
+#include <camp/arrayproperty.hpp>
+#include <camp/arraymapper.hpp>
+#include <camp/detail/valueprovider.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Typed implementation of ArrayProperty
+ *
+ * ArrayPropertyImpl is a template implementation of ArrayProperty, which is strongly typed
+ * in order to keep track of the true underlying C++ types involved in the property.
+ *
+ * The template parameter A is an abstract helper to access the actual C++ property.
+ *
+ * This class uses the camp_ext::ArrayMapper template to implement its operations according
+ * to the type of array.
+ *
+ * \sa ArrayProperty, camp_ext::ArrayMapper
+ */
+template <typename A>
+class ArrayPropertyImpl : public ArrayProperty
+{
+public:
+
+    /**
+     * \brief Construct the property
+     *
+     * \param name Name of the property
+     * \param accessor Object used to access the actual C++ property
+     */
+    ArrayPropertyImpl(const std::string& name, const A& accessor);
+
+protected:
+
+    /**
+     * \see ArrayProperty::getSize
+     */
+    virtual std::size_t getSize(const UserObject& object) const;
+
+    /**
+     * \see ArrayProperty::setSize
+     */
+    virtual void setSize(const UserObject& object, std::size_t size) const;
+
+    /**
+     * \see ArrayProperty::getElement
+     */
+    virtual Value getElement(const UserObject& object, std::size_t index) const;
+
+    /**
+     * \see ArrayProperty::setElement
+     */
+    virtual void setElement(const UserObject& object, std::size_t index, const Value& value) const;
+
+    /**
+     * \see ArrayProperty::insertElement
+     */
+    virtual void insertElement(const UserObject& object, std::size_t before, const Value& value) const;
+
+    /**
+     * \see ArrayProperty::removeElement
+     */
+    virtual void removeElement(const UserObject& object, std::size_t index) const;
+
+private:
+
+    typedef typename boost::remove_reference<typename A::DataType>::type ArrayType;
+    typedef camp_ext::ArrayMapper<ArrayType> Mapper;
+    typedef typename Mapper::ElementType ElementType;
+
+    /**
+     * \brief Retrieve a reference to the array
+     *
+     * \param object Owner object
+     *
+     * \return Reference to the underlying array
+     */
+    ArrayType& array(const UserObject& object) const;
+
+    A m_accessor; ///< Object used to access the actual C++ property
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/arraypropertyimpl.inl>
+
+
+#endif // CAMP_DETAIL_ARRAYPROPERTYIMPL_HPP
diff --git a/include/camp/detail/arraypropertyimpl.inl b/include/camp/detail/arraypropertyimpl.inl
new file mode 100644
index 0000000..5372fd4
--- /dev/null
+++ b/include/camp/detail/arraypropertyimpl.inl
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+ArrayPropertyImpl<A>::ArrayPropertyImpl(const std::string& name, const A& accessor)
+    : ArrayProperty(name, mapType<ElementType>(), Mapper::dynamic())
+    , m_accessor(accessor)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+std::size_t ArrayPropertyImpl<A>::getSize(const UserObject& object) const
+{
+    return Mapper::size(array(object));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void ArrayPropertyImpl<A>::setSize(const UserObject& object, std::size_t size) const
+{
+    std::size_t currentSize = getSize(object);
+    if (size < currentSize)
+    {
+        while (size < currentSize)
+            removeElement(object, --currentSize);
+    }
+    else if (size > currentSize)
+    {
+        ValueProvider<ElementType> provider;
+        while (size > currentSize)
+            insertElement(object, currentSize++, provider());
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+Value ArrayPropertyImpl<A>::getElement(const UserObject& object, std::size_t index) const
+{
+    return Mapper::get(array(object), index);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void ArrayPropertyImpl<A>::setElement(const UserObject& object, std::size_t index, const Value& value) const
+{
+    Mapper::set(array(object), index, value.to<ElementType>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void ArrayPropertyImpl<A>::insertElement(const UserObject& object, std::size_t before, const Value& value) const
+{
+    Mapper::insert(array(object), before, value.to<ElementType>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void ArrayPropertyImpl<A>::removeElement(const UserObject& object, std::size_t index) const
+{
+    Mapper::remove(array(object), index);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+typename ArrayPropertyImpl<A>::ArrayType& ArrayPropertyImpl<A>::array(const UserObject& object) const
+{
+    return m_accessor.get(object.get<typename A::ClassType>());
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/callhelper.hpp b/include/camp/detail/callhelper.hpp
new file mode 100644
index 0000000..2100db7
--- /dev/null
+++ b/include/camp/detail/callhelper.hpp
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_CALLHELPER_HPP
+#define CAMP_DETAIL_CALLHELPER_HPP
+
+
+#include <camp/value.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \class CallHelper
+ *
+ * \brief Helper structure used to make a function call and return the result as a camp::Value.
+ *
+ * This structure is necessary because we need a specific code for functions returning void.
+ */
+
+/*
+ * Generic version of CallHelper
+ */
+template <typename R, typename C>
+struct CallHelper
+{
+    template <typename F>
+    static Value call(F func, C obj) {return func(obj);}
+
+    template <typename F, typename A0>
+    static Value call(F func, C obj, A0 a0) {return func(obj, a0);}
+
+    template <typename F, typename A0, typename A1>
+    static Value call(F func, C obj, A0 a0, A1 a1) {return func(obj, a0, a1);}
+
+    template <typename F, typename A0, typename A1, typename A2>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2) {return func(obj, a0, a1, a2);}
+
+    template <typename F, typename A0, typename A1, typename A2, typename A3>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2, A3 a3) {return func(obj, a0, a1, a2, a3);}
+
+    template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {return func(obj, a0, a1, a2, a3, a4);}
+};
+
+/*
+ * Specialization of CallHelper for functions returning void
+ */
+template <typename C>
+struct CallHelper<void, C>
+{
+    template <typename F>
+    static Value call(F func, C obj) {func(obj); return Value::nothing;}
+
+    template <typename F, typename A0>
+    static Value call(F func, C obj, A0 a0) {func(obj, a0); return Value::nothing;}
+
+    template <typename F, typename A0, typename A1>
+    static Value call(F func, C obj, A0 a0, A1 a1) {func(obj, a0, a1); return Value::nothing;}
+
+    template <typename F, typename A0, typename A1, typename A2>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2) {func(obj, a0, a1, a2); return Value::nothing;}
+
+    template <typename F, typename A0, typename A1, typename A2, typename A3>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2, A3 a3) {func(obj, a0, a1, a2, a3); return Value::nothing;}
+
+    template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
+    static Value call(F func, C obj, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {func(obj, a0, a1, a2, a3, a4); return Value::nothing;}
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_CALLHELPER_HPP
diff --git a/include/camp/detail/classmanager.hpp b/include/camp/detail/classmanager.hpp
new file mode 100644
index 0000000..a38b31f
--- /dev/null
+++ b/include/camp/detail/classmanager.hpp
@@ -0,0 +1,189 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_CLASSMANAGER_HPP
+#define CAMP_DETAIL_CLASSMANAGER_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/observernotifier.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <string>
+
+
+namespace bm = boost::multi_index;
+
+namespace camp
+{
+class Class;
+
+namespace detail
+{
+/**
+ * \brief Manages creation, storage, retrieval and destruction of metaclasses
+ *
+ * camp::ClassManager is the place where all metaclasses are stored and accessed.
+ * It consists of a singleton which is created on first use and destroyed at global exit.
+ *
+ * \sa Class
+ */
+class CAMP_API ClassManager : public ObserverNotifier, boost::noncopyable
+{
+public:
+
+    /**
+     * \brief Get the unique instance of the class
+     *
+     * \return Reference to the unique instance of ClassManager
+     */
+    static ClassManager& instance();
+
+    /**
+     * \brief Create and register a new metaclass
+     *
+     * This is the entry point for every metaclass creation. This
+     * function also notifies registered observers after successful creations.
+     *
+     * \param name Name of the metaclass to create (must be unique)
+     * \param id Identifier of the C++ class bound to the metaclass
+     *
+     * \return Reference to the new metaclass
+     *
+     * \throw ClassAlreadyCreated \a name or \a id already exists
+     */
+    Class& addClass(const std::string& name, const std::string& id);
+
+    /**
+     * \brief Get the total number of metaclasses
+     *
+     * \return Number of metaclasses that have been registered
+     */
+    std::size_t count() const;
+
+    /**
+     * \brief Get a metaclass from its global index
+     *
+     * This function, together with ClassManager::count, provides a way to iterate through
+     * all the metaclasses that have been declared.
+     *
+     * \param index Global index of the metaclass to get
+     *
+     * \return Reference to the index-th metaclass
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Class& getByIndex(std::size_t index) const;
+
+    /**
+     * \brief Get a metaclass from its name
+     *
+     * \param name Name of the metaclass to retrieve
+     *
+     * \return Reference to the requested metaclass
+     *
+     * \throw ClassNotFound name is not the name of an existing metaclass
+     */
+    const Class& getByName(const std::string& name) const;
+
+    /**
+     * \brief Get a metaclass from a C++ type
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return Reference to the requested metaclass
+     *
+     * \throw ClassNotFound id is not the name of an existing metaclass
+     */
+    const Class& getById(const std::string& id) const;
+
+    /**
+     * \brief Get a metaclass from a C++ type
+     *
+     * This version returns a null pointer if no metaclass is found, instead
+     * of throwing an exception.
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return Pointer to the requested metaclass, or 0 if not found
+     */
+    const Class* getByIdSafe(const std::string& id) const;
+
+    /**
+     * \brief Check if a given type has a metaclass
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return True if the class exists, false otherwise
+     */
+    bool classExists(const std::string& id) const;
+
+private:
+
+    /**
+     * \brief Default constructor
+     */
+    ClassManager();
+
+    /**
+     * \brief Destructor
+     *
+     * The destructor destroys all the registered metaclasses and notifies the observers.
+     */
+    ~ClassManager();
+
+    /**
+     * \brief Structure gathering a class, its type identifier and its name
+     */
+    struct ClassInfo
+    {
+        std::string id;
+        std::string name;
+        boost::shared_ptr<Class> classPtr;
+    };
+
+    struct Id;
+    struct Name;
+
+    typedef boost::multi_index_container<ClassInfo,
+        bm::indexed_by<bm::ordered_unique<bm::tag<Id>,   bm::member<ClassInfo, std::string, &ClassInfo::id> >,
+                       bm::ordered_unique<bm::tag<Name>, bm::member<ClassInfo, std::string, &ClassInfo::name> >
+        >
+    > ClassTable;
+
+    typedef ClassTable::index<Id>::type IdIndex;
+    typedef ClassTable::index<Name>::type NameIndex;
+
+    ClassTable m_classes; ///< Table storing classes indexed by their id and name
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_CLASSMANAGER_HPP
diff --git a/include/camp/detail/constructorimpl.hpp b/include/camp/detail/constructorimpl.hpp
new file mode 100644
index 0000000..b3f42ba
--- /dev/null
+++ b/include/camp/detail/constructorimpl.hpp
@@ -0,0 +1,299 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_CONSTRUCTORIMPL_HPP
+#define CAMP_DETAIL_CONSTRUCTORIMPL_HPP
+
+
+#include <camp/constructor.hpp>
+#include <camp/valuemapper.hpp>
+#include <camp/value.hpp>
+#include <camp/valuevisitor.hpp>
+#include <camp/errors.hpp>
+#include <camp/userobject.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Helper function which converts an argument to a C++ type
+ *
+ * The main purpose of this function is to convert any BadType error to
+ * a BadArgument one.
+ *
+ * \param args List of arguments
+ * \param index Index of the argument to convert
+ *
+ * \return Value of args[index] converted to T
+ *
+ * \thrown BadArgument conversion triggered a BadType error
+ */
+template <typename T>
+inline typename boost::remove_reference<T>::type convertArg(const Args& args, std::size_t index)
+{
+    try
+    {
+        return args[index].to<typename boost::remove_reference<T>::type>();
+    }
+    catch (BadType&)
+    {
+        CAMP_ERROR(BadArgument(args[index].type(), mapType<T>(), index, "constructor"));
+    }
+}
+
+/**
+ * \brief Check if a value is compatible with a C++ type
+ *
+ * This is a strong test, we check if the type of the value is directly mappable to T, not
+ * just convertible.
+ *
+ * \param value Value to check
+ *
+ * \return True if the value is compatible with the type T
+ */
+template <typename T>
+bool checkArg(const Value& value);
+
+/**
+ * \brief Implementation of metaconstructors with no parameter
+ */
+template <typename T>
+class ConstructorImpl0 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 0);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args&) const
+    {
+        return new T();
+    }
+};
+
+/**
+ * \brief Implementation of metaconstructors with 1 parameter
+ */
+template <typename T, typename A0>
+class ConstructorImpl1 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 1)
+               && checkArg<A0>(args[0]);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args& args) const
+    {
+        return new T(convertArg<A0>(args, 0));
+    }
+};
+
+/**
+ * \brief Implementation of metaconstructors with 2 parameters
+ */
+template <typename T, typename A0, typename A1>
+class ConstructorImpl2 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 2)
+               && checkArg<A0>(args[0])
+               && checkArg<A1>(args[1]);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args& args) const
+    {
+        return new T(convertArg<A0>(args, 0),
+                     convertArg<A1>(args, 1));
+    }
+};
+
+/**
+ * \brief Implementation of metaconstructors with 3 parameters
+ */
+template <typename T, typename A0, typename A1, typename A2>
+class ConstructorImpl3 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 3)
+               && checkArg<A0>(args[0])
+               && checkArg<A1>(args[1])
+               && checkArg<A2>(args[2]);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args& args) const
+    {
+        return new T(convertArg<A0>(args, 0),
+                     convertArg<A1>(args, 1),
+                     convertArg<A2>(args, 2));
+    }
+};
+
+/**
+ * \brief Implementation of metaconstructors with 4 parameters
+ */
+template <typename T, typename A0, typename A1, typename A2, typename A3>
+class ConstructorImpl4 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 4)
+               && checkArg<A0>(args[0])
+               && checkArg<A1>(args[1])
+               && checkArg<A2>(args[2])
+               && checkArg<A3>(args[3]);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args& args) const
+    {
+        return new T(convertArg<A0>(args, 0),
+                     convertArg<A1>(args, 1),
+                     convertArg<A2>(args, 2),
+                     convertArg<A3>(args, 3));
+    }
+};
+
+/**
+ * \brief Implementation of metaconstructors with 5 parameters
+ */
+template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
+class ConstructorImpl5 : public Constructor
+{
+public:
+
+    /**
+     * \see Constructor::matches
+     */
+    virtual bool matches(const Args& args) const
+    {
+        return (args.count() == 5)
+               && checkArg<A0>(args[0])
+               && checkArg<A1>(args[1])
+               && checkArg<A2>(args[2])
+               && checkArg<A3>(args[3])
+               && checkArg<A4>(args[4]);
+    }
+
+    /**
+     * \see Constructor::create
+     */
+    virtual UserObject create(const Args& args) const
+    {
+        return new T(convertArg<A0>(args, 0),
+                     convertArg<A1>(args, 1),
+                     convertArg<A2>(args, 2),
+                     convertArg<A3>(args, 3),
+                     convertArg<A4>(args, 4));
+    }
+};
+
+/**
+ * \brief Value visitor which checks the type of the visited value against the C++ type T
+ */
+template <typename T>
+struct CheckTypeVisitor : public ValueVisitor<bool>
+{
+    /**
+     * \brief Common case: check mapping
+     */
+    template <typename U>
+    bool operator()(const U&)
+    {
+        return mapType<T>() == mapType<U>();
+    }
+
+    /**
+     * \brief Special case of enum objects: check metaenum and bound type
+     */
+    bool operator()(const EnumObject& obj)
+    {
+        const Enum* targetEnum = enumByTypeSafe<T>();
+        return targetEnum && (*targetEnum == obj.getEnum());
+    }
+
+    /**
+     * \brief Special case of user objects: check metaclass and bound type
+     */
+    bool operator()(const UserObject& obj)
+    {
+        const Class* targetClass = classByTypeSafe<T>();
+        return targetClass && (*targetClass == obj.getClass());
+    }
+};
+
+template <typename T>
+bool checkArg(const Value& value)
+{
+    return value.visit(CheckTypeVisitor<T>());
+}
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_CONSTRUCTORIMPL_HPP
diff --git a/include/camp/detail/enummanager.hpp b/include/camp/detail/enummanager.hpp
new file mode 100644
index 0000000..721cf09
--- /dev/null
+++ b/include/camp/detail/enummanager.hpp
@@ -0,0 +1,186 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_ENUMMANAGER_HPP
+#define CAMP_DETAIL_ENUMMANAGER_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/observernotifier.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <string>
+
+
+namespace bm = boost::multi_index;
+
+namespace camp
+{
+class Enum;
+
+namespace detail
+{
+/**
+ * \brief Manages creation, storage, retrieval and destruction of metaenums
+ *
+ * camp::EnumManager is the place where all metaenums are stored and accessed.
+ * It consists of a singleton which is created on first use and destroyed at global exit.
+ *
+ * \sa Enum
+ */
+class CAMP_API EnumManager : public ObserverNotifier, boost::noncopyable
+{
+public:
+
+    /**
+     * \brief Get the unique instance of the class
+     *
+     * \return Reference to the unique instance of EnumManager
+     */
+    static EnumManager& instance();
+
+    /**
+     * \brief Create and register a new metaenum
+     *
+     * This is the entry point for every metaenum creation. This
+     * function also notifies registered observers after successful creations.
+     *
+     * \param name Name of the metaenum to create (must be unique)
+     * \param id Identifier of the C++ enum bound to the metaenum
+     *
+     * \return Reference to the new metaenum
+     */
+    Enum& addClass(const std::string& name, const std::string& id);
+
+    /**
+     * \brief Get the total number of metaenums
+     *
+     * \return Number of metaenums that have been registered
+     */
+    std::size_t count() const;
+
+    /**
+     * \brief Get a metaenum from its global index
+     *
+     * This function, together with EnumManager::count, provides a way to iterate through
+     * all the metaenums that have been declared.
+     *
+     * \param index Global index of the metaenum to get
+     *
+     * \return Reference to the index-th metaenum
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Enum& getByIndex(std::size_t index) const;
+
+    /**
+     * \brief Get a metaenum from its name
+     *
+     * \param name Name of the metaenum to retrieve
+     *
+     * \return Reference to the requested metaenum
+     *
+     * \throw EnumNotFound name is not the name of an existing metaenum
+     */
+    const Enum& getByName(const std::string& name) const;
+
+    /**
+     * \brief Get a metaenum from a C++ type
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return Reference to the requested metaenum
+     *
+     * \throw EnumNotFound id is not the name of an existing metaenum
+     */
+    const Enum& getById(const std::string& id) const;
+
+    /**
+     * \brief Get a metaenum from a C++ type
+     *
+     * This version returns a null pointer if no metaenum is found, instead
+     * of throwing an exception.
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return Pointer to the requested metaenum, or 0 if not found
+     */
+    const Enum* getByIdSafe(const std::string& id) const;
+
+    /**
+     * \brief Check if a given type has a metaenum
+     *
+     * \param id Identifier of the C++ type
+     *
+     * \return True if the enum exists, false otherwise
+     */
+    bool enumExists(const std::string& id) const;
+
+private:
+
+    /**
+     * \brief Default constructor
+     */
+    EnumManager();
+
+    /**
+     * \brief Destructor
+     *
+     * The destructor destroys all the registered metaenums and notifies the observers.
+     */
+    ~EnumManager();
+
+    /**
+     * \brief Structure gathering an enum, its type identifier and its name
+     */
+    struct EnumInfo
+    {
+        std::string id;
+        std::string name;
+        boost::shared_ptr<Enum> enumPtr;
+    };
+
+    struct Id;
+    struct Name;
+
+    typedef boost::multi_index_container<EnumInfo,
+        bm::indexed_by<bm::ordered_unique<bm::tag<Id>,   bm::member<EnumInfo, std::string, &EnumInfo::id> >,
+                       bm::ordered_unique<bm::tag<Name>, bm::member<EnumInfo, std::string, &EnumInfo::name> >
+        >
+    > EnumTable;
+
+    typedef EnumTable::index<Id>::type IdIndex;
+    typedef EnumTable::index<Name>::type NameIndex;
+
+    EnumTable m_enums; ///< Table storing enums indexed by their id and name
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_ENUMMANAGER_HPP
diff --git a/include/camp/detail/enumpropertyimpl.hpp b/include/camp/detail/enumpropertyimpl.hpp
new file mode 100644
index 0000000..1a87bf3
--- /dev/null
+++ b/include/camp/detail/enumpropertyimpl.hpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_ENUMPROPERTYIMPL_HPP
+#define CAMP_DETAIL_ENUMPROPERTYIMPL_HPP
+
+
+#include <camp/enumproperty.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Typed implementation of EnumProperty
+ *
+ * EnumPropertyImpl is a template implementation of EnumProperty, which is strongly typed
+ * in order to keep track of the true underlying C++ types involved in the property.
+ *
+ * The template parameter A is an abstract helper to access the actual C++ property.
+ *
+ * \sa EnumProperty
+ */
+template <typename A>
+class EnumPropertyImpl : public EnumProperty
+{
+public:
+
+    /**
+     * \brief Construct the property from its accessors
+     *
+     * \param name Name of the property
+     * \param accessor Object used to access the actual C++ property
+     */
+    EnumPropertyImpl(const std::string& name, const A& accessor);
+
+protected:
+
+    /**
+     * \see Property::isReadable
+     */
+    virtual bool isReadable() const;
+
+    /**
+     * \see Property::isWritable
+     */
+    virtual bool isWritable() const;
+
+    /**
+     * \see Property::getValue
+     */
+    virtual Value getValue(const UserObject& object) const;
+
+    /**
+     * \see Property::setValue
+     */
+    virtual void setValue(const UserObject& object, const Value& value) const;
+
+private:
+
+    A m_accessor; ///< Object used to access the actual C++ property
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/enumpropertyimpl.inl>
+
+
+#endif // CAMP_DETAIL_ENUMPROPERTYIMPL_HPP
diff --git a/include/camp/detail/enumpropertyimpl.inl b/include/camp/detail/enumpropertyimpl.inl
new file mode 100644
index 0000000..f063e1a
--- /dev/null
+++ b/include/camp/detail/enumpropertyimpl.inl
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+EnumPropertyImpl<A>::EnumPropertyImpl(const std::string& name, const A& accessor)
+    : EnumProperty(name, enumByType<typename A::DataType>())
+    , m_accessor(accessor)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+Value EnumPropertyImpl<A>::getValue(const UserObject& object) const
+{
+    return m_accessor.get(object.get<typename A::ClassType>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void EnumPropertyImpl<A>::setValue(const UserObject& object, const Value& value) const
+{
+    if (!m_accessor.set(object.get<typename A::ClassType>(), value))
+        CAMP_ERROR(ForbiddenWrite(name()));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool EnumPropertyImpl<A>::isReadable() const
+{
+    return A::canRead;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool EnumPropertyImpl<A>::isWritable() const
+{
+    return A::canWrite;
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/functionimpl.hpp b/include/camp/detail/functionimpl.hpp
new file mode 100644
index 0000000..912e059
--- /dev/null
+++ b/include/camp/detail/functionimpl.hpp
@@ -0,0 +1,514 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_FUNCTIONIMPL_HPP
+#define CAMP_DETAIL_FUNCTIONIMPL_HPP
+
+
+#include <camp/function.hpp>
+#include <camp/value.hpp>
+#include <camp/errors.hpp>
+#include <camp/detail/callhelper.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/assign/list_of.hpp>
+#include <string>
+
+
+namespace camp
+{
+namespace detail
+{
+using boost::assign::list_of;
+
+/**
+ * \brief Helper function which converts an argument to a C++ type
+ *
+ * The main purpose of this function is to convert any BadType error to
+ * a BadArgument one.
+ *
+ * \param args List of arguments
+ * \param index Index of the argument to convert
+ * \param function Name of the calling function
+ *
+ * \return Value of args[index] converted to T
+ *
+ * \thrown BadArgument conversion triggered a BadType error
+ */
+template <typename T>
+inline typename boost::remove_reference<T>::type convertArg(const Args& args, std::size_t index, const std::string& function)
+{
+    try
+    {
+        return args[index].to<typename boost::remove_reference<T>::type>();
+    }
+    catch (BadType&)
+    {
+        CAMP_ERROR(BadArgument(args[index].type(), mapType<T>(), index, function));
+    }
+}
+
+
+/**
+ * \class camp::detail::FunctionImpl
+ *
+ * \brief Typed specialization of camp::Function.
+ *
+ * The FunctionImpl class is a template which is specialized
+ * according to the underlying function prototype.
+ */
+
+template <typename F1, typename F2 = void> class FunctionImpl;
+
+/*
+ * Specialization of FunctionImpl for functions taking no argument
+ */
+template <typename C, typename R>
+class FunctionImpl<R (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C)> function)
+        : Function(name, mapType<R>())
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args&) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>());
+    }
+
+private:
+
+    boost::function<R (C)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for functions taking 1 argument
+ */
+template <typename C, typename R, typename A0>
+class FunctionImpl<R (C, A0)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C, A0)> function)
+        : Function(name, mapType<R>(), list_of(mapType<A0>()))
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name()));
+    }
+
+private:
+
+    boost::function<R (C, A0)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for functions taking 2 arguments
+ */
+template <typename C, typename R, typename A0, typename A1>
+class FunctionImpl<R (C, A0, A1)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C, A0, A1)> function)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>()))
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name()));
+    }
+
+private:
+
+    boost::function<R (C, A0, A1)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for functions taking 3 arguments
+ */
+template <typename C, typename R, typename A0, typename A1, typename A2>
+class FunctionImpl<R (C, A0, A1, A2)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C, A0, A1, A2)> function)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>()))
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name())
+                                      , convertArg<A2>(args, 2, name()));
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for functions taking 4 arguments
+ */
+template <typename C, typename R, typename A0, typename A1, typename A2, typename A3>
+class FunctionImpl<R (C, A0, A1, A2, A3)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C, A0, A1, A2, A3)> function)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>())(mapType<A3>()))
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name())
+                                      , convertArg<A2>(args, 2, name())
+                                      , convertArg<A3>(args, 3, name()));
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2, A3)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for functions taking 5 arguments
+ */
+template <typename C, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
+class FunctionImpl<R (C, A0, A1, A2, A3, A4)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    FunctionImpl(const std::string& name, boost::function<R (C, A0, A1, A2, A3, A4)> function)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>())(mapType<A3>())(mapType<A4>()))
+        , m_function(function)
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name())
+                                      , convertArg<A2>(args, 2, name())
+                                      , convertArg<A3>(args, 3, name())
+                                      , convertArg<A4>(args, 4, name()));
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2, A3, A4)> m_function; ///< Object containing the actual function to call
+};
+
+
+/*
+ * Specialization of FunctionImpl for composed functions taking no argument
+ */
+template <typename C, typename N, typename M, typename R>
+class FunctionImpl<R (N), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>())
+        , m_function(boost::bind(function, boost::bind(accessor, _1)))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args&) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>());
+    }
+
+private:
+
+    boost::function<R (C)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for composed functions taking 1 argument
+ */
+template <typename C, typename N, typename M, typename R, typename A0>
+class FunctionImpl<R (N, A0), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>(), list_of(mapType<A0>()))
+        , m_function(boost::bind(function, boost::bind(accessor, _1), _2))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name()));
+
+    }
+
+private:
+
+    boost::function<R (C, A0)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for composed functions taking 2 arguments
+ */
+template <typename C, typename N, typename M, typename R, typename A0, typename A1>
+class FunctionImpl<R (N, A0, A1), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>()))
+        , m_function(boost::bind(function, boost::bind(accessor, _1), _2, _3))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name()));
+
+    }
+
+private:
+
+    boost::function<R (C, A0, A1)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for composed functions taking 3 arguments
+ */
+template <typename C, typename N, typename M, typename R, typename A0, typename A1, typename A2>
+class FunctionImpl<R (N, A0, A1, A2), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>()))
+        , m_function(boost::bind(function, boost::bind(accessor, _1), _2, _3, _4))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                   , convertArg<A0>(args, 0, name())
+                                   , convertArg<A1>(args, 1, name())
+                                   , convertArg<A2>(args, 2, name()));
+
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for composed functions taking 4 arguments
+ */
+template <typename C, typename N, typename M, typename R, typename A0, typename A1, typename A2, typename A3>
+class FunctionImpl<R (N, A0, A1, A2, A3), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>())(mapType<A3>()))
+        , m_function(boost::bind(function, boost::bind(accessor, _1), _2, _3, _4, _5))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name())
+                                      , convertArg<A2>(args, 2, name())
+                                      , convertArg<A3>(args, 3, name()));
+
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2, A3)> m_function; ///< Object containing the actual function to call
+};
+
+/*
+ * Specialization of FunctionImpl for composed functions taking 5 arguments
+ */
+template <typename C, typename N, typename M, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
+class FunctionImpl<R (N, A0, A1, A2, A3, A4), M (C)> : public Function
+{
+public:
+
+    /**
+     * \brief Constructor
+     */
+    template <typename F1, typename F2>
+    FunctionImpl(const std::string& name, F1 function, F2 accessor)
+        : Function(name, mapType<R>(), list_of(mapType<A0>())(mapType<A1>())(mapType<A2>())(mapType<A3>())(mapType<A4>()))
+        , m_function(boost::bind(function, boost::bind(accessor, _1), _2, _3, _4, _5, _6))
+    {
+    }
+
+protected:
+
+    /**
+     * \see Function::execute
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const
+    {
+        return CallHelper<R, C>::call(m_function, object.get<C>()
+                                      , convertArg<A0>(args, 0, name())
+                                      , convertArg<A1>(args, 1, name())
+                                      , convertArg<A2>(args, 2, name())
+                                      , convertArg<A3>(args, 3, name())
+                                      , convertArg<A4>(args, 4, name()));
+
+    }
+
+private:
+
+    boost::function<R (C, A0, A1, A2, A3, A4)> m_function; ///< Object containing the actual function to call
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_FUNCTIONIMPL_HPP
diff --git a/include/camp/detail/functiontraits.hpp b/include/camp/detail/functiontraits.hpp
new file mode 100644
index 0000000..b9b05d9
--- /dev/null
+++ b/include/camp/detail/functiontraits.hpp
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_FUNCTIONTRAITS_HPP
+#define CAMP_DETAIL_FUNCTIONTRAITS_HPP
+
+
+#include <camp/detail/yesnotype.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/function_types/is_callable_builtin.hpp>
+#include <boost/function_types/result_type.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Helper structure to check at compile time if a type is a functor
+ *
+ * This structure checks if the provided type defines a result_type type.
+ */
+template <typename T>
+struct HasResultType
+{
+    template <typename U, typename V> struct TestForMember {};
+    template <typename U> static TypeYes check(TestForMember<U, typename U::result_type>*);
+    template <typename U> static TypeNo  check(...);
+
+    enum {value = sizeof(check<T>(0)) == sizeof(TypeYes)};
+};
+
+/**
+ * \class FunctionTraits
+ *
+ * \brief Utility class which gives compile-time informations about function types
+ *
+ * The FunctionTraits provides two informations about a type T:
+ * \li A compile-time constant \c isFunction which tells if T is any callable type
+ * \li A type \c ReturnType which is the type returned by T
+ */
+
+/**
+ * General case for all unspecified types: not a function
+ */
+template <typename T, typename E = void>
+struct FunctionTraits
+{
+    enum {isFunction = false};
+};
+
+/**
+ * Specialization for native callable types (function and pointer-to-member types)
+ */
+template <typename T>
+struct FunctionTraits<T, typename boost::enable_if<boost::function_types::is_callable_builtin<T> >::type>
+{
+    enum {isFunction = true};
+    typedef typename boost::function_types::result_type<T>::type ReturnType;
+};
+
+/**
+ * Specialization for functors (classes exporting a result_type type)
+ */
+template <typename T>
+struct FunctionTraits<T, typename boost::enable_if<HasResultType<T> >::type>
+{
+    enum {isFunction = true};
+    typedef typename T::result_type ReturnType;
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_FUNCTIONTRAITS_HPP
diff --git a/include/camp/detail/getter.hpp b/include/camp/detail/getter.hpp
new file mode 100644
index 0000000..9dbcf06
--- /dev/null
+++ b/include/camp/detail/getter.hpp
@@ -0,0 +1,151 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_GETTER_HPP
+#define CAMP_DETAIL_GETTER_HPP
+
+
+#include <camp/userobject.hpp>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Represents an abstract getter
+ *
+ * This class is an interface which must be inherited by typed specializations.
+ * The template parameter T is the type returned by the getter.
+ *
+ * \sa Getter, GetterImpl
+ */
+template <typename T>
+class GetterInterface
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~GetterInterface();
+
+    /**
+     * \brief Retrieve the value returned by the getter
+     *
+     * \param object User object to apply the getter to
+     */
+    virtual T get(const UserObject& object) const = 0;
+};
+
+/**
+ * \brief Typed implementation of GetterInterface
+ */
+template <typename T, typename C>
+class GetterImpl : public GetterInterface<T>
+{
+public:
+
+    /**
+     * \brief Construct the getter implementation from a function
+     */
+    GetterImpl(boost::function<T (C&)> function);
+
+    /**
+     * \see GetterInterface::get
+     */
+    virtual T get(const UserObject& object) const;
+
+private:
+
+    boost::function<T (C&)> m_function; ///< Function object storing the actual getter
+};
+
+/**
+ * \brief Generic getter which can be applied to user objects
+ *
+ * This class models a Getter as a non-member function; this way it can be
+ * used without knowledge about the actual owner class, and be applied
+ * uniformly to user objects.
+ *
+ * Getter can be built upon any kind of callable type or a constant value.
+ * The template parameter T is the type returned by the getter.
+ *
+ * \sa UserObject, GetterInterface
+ */
+template <typename T>
+class Getter
+{
+public:
+
+    /**
+     * \brief Construct the getter from a constant value
+     *
+     * This value will be returned either if no object is passed, or if no getter function has been defined
+     *
+     * \param defaultValue Value to return if no function has been set (default value of T by default)
+     */
+    Getter(const T& defaultValue = T());
+
+    /**
+     * \brief Construct the getter from a function
+     *
+     * \param function Function object storing the actual getter
+     */
+    template <typename C>
+    Getter(boost::function<T (C&)> function);
+
+    /**
+     * \brief Get the default value of the getter
+     *
+     * \return Constant stored in the getter
+     */
+    const T& get() const;
+
+    /**
+     * \brief Retrieve the value returned by the getter
+     *
+     * If no function has been set, it's equivalent to calling Getter::get().
+     *
+     * \param object User object to apply the getter to
+     *
+     * \return Value returned by the getter
+     */
+    T get(const UserObject& object) const;
+
+private:
+
+    boost::shared_ptr<GetterInterface<T> > m_getter; ///< Implementation of the getter
+    T m_defaultValue; ///< Default value to return if no function or no object is specified
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/getter.inl>
+
+
+#endif // CAMP_DETAIL_GETTER_HPP
diff --git a/include/camp/detail/getter.inl b/include/camp/detail/getter.inl
new file mode 100644
index 0000000..182b574
--- /dev/null
+++ b/include/camp/detail/getter.inl
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+GetterInterface<T>::~GetterInterface()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T, typename C>
+GetterImpl<T, C>::GetterImpl(boost::function<T (C&)> function)
+    : m_function(function)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T, typename C>
+T GetterImpl<T, C>::get(const UserObject& object) const
+{
+    return m_function(object.get<C>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+Getter<T>::Getter(const T& defaultValue)
+    : m_getter()
+    , m_defaultValue(defaultValue)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+template <typename C>
+Getter<T>::Getter(boost::function<T (C&)> function)
+    : m_getter(new GetterImpl<T, C>(function))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const T& Getter<T>::get() const
+{
+    return m_defaultValue;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+T Getter<T>::get(const UserObject& object) const
+{
+    return m_getter ? m_getter->get(object) : m_defaultValue;
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/issmartpointer.hpp b/include/camp/detail/issmartpointer.hpp
new file mode 100644
index 0000000..8c77f02
--- /dev/null
+++ b/include/camp/detail/issmartpointer.hpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_ISSMARTPOINTER_HPP
+#define CAMP_DETAIL_ISSMARTPOINTER_HPP
+
+
+#include <camp/detail/yesnotype.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Utility class which tells at compile-time if a type T is a smart pointer to a type U
+ *
+ * To detect a smart pointer type, we check using SFINAE if T implements an operator -> returning a U*
+ */
+template <typename T, typename U>
+struct IsSmartPointer
+{
+    // Check non-const signature
+    template <typename V, U* (V::*)()> struct TestForMember {};
+    template <typename V> static TypeYes check(TestForMember<V, &V::operator-> >*);
+    template <typename V> static TypeNo  check(...);
+
+    // Check const signature
+    template <typename V, U* (V::*)() const> struct TestForConstMember {};
+    template <typename V> static TypeYes checkConst(TestForConstMember<V, &V::operator-> >*);
+    template <typename V> static TypeNo  checkConst(...);
+
+    enum {value = (sizeof(check<T>(0)) == sizeof(TypeYes))
+               || (sizeof(checkConst<T>(0)) == sizeof(TypeYes))};
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+namespace boost
+{
+/**
+ * \brief Specialization of boost::get_pointer for all smart pointer types (const version)
+ *
+ * This function is specialized for every type T for which IsSmartPointer<T> is true. It makes
+ * the stored value available for all boost algorithms (especially for boost::bind).
+ */
+template <template <typename> class T, typename U>
+U* get_pointer(const T<U>& obj, typename enable_if<camp::detail::IsSmartPointer<T<U>, U> >::type* = 0)
+{
+    return obj.get();
+}
+
+/**
+ * \brief Specialization of boost::get_pointer for all smart pointer types (non-const version)
+ *
+ * This function is specialized for every type T for which IsSmartPointer<T> is true. It makes
+ * the stored value available for all boost algorithms (especially for boost::bind).
+ */
+template <template <typename> class T, typename U>
+U* get_pointer(T<U>& obj, typename enable_if<camp::detail::IsSmartPointer<T<U>, U> >::type* = 0)
+{
+    return obj.get();
+}
+
+} // namespace boost
+
+
+#endif // CAMP_DETAIL_ISSMARTPOINTER_HPP
diff --git a/include/camp/detail/objectholder.hpp b/include/camp/detail/objectholder.hpp
new file mode 100644
index 0000000..1923346
--- /dev/null
+++ b/include/camp/detail/objectholder.hpp
@@ -0,0 +1,198 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_OBJECTHOLDER_HPP
+#define CAMP_DETAIL_OBJECTHOLDER_HPP
+
+
+#include <camp/classget.hpp>
+#include <camp/classcast.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Abstract base class for object holders
+ *
+ * This class is meant to be used by UserObject.
+ * @todo Use an optimized memory pool if there are too many allocations of holders
+ */
+class AbstractObjectHolder
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~AbstractObjectHolder();
+
+    /**
+     * \brief Return a typeless pointer to the stored object
+     *
+     * \return Pointer to the object
+     */
+    virtual void* object() = 0;
+
+    /**
+     * \brief Return a holder which is able to modify its stored object
+     *
+     * The holder can return itself it it already meets the requirement,
+     * otherwise it may return a new holder storing a copy of its object.
+     *
+     * \return Holder storing a writable object
+     */
+    virtual AbstractObjectHolder* getWritable() = 0;
+
+protected:
+
+    /**
+     * \brief Default constructor
+     */
+    AbstractObjectHolder();
+};
+
+/**
+ * \brief Typed specialization of AbstractObjectHolder for storage by const reference
+ */
+template <typename T>
+class ObjectHolderByConstRef : public AbstractObjectHolder
+{
+public:
+
+    /**
+     * \brief Construct the holder from a const object
+     *
+     * \param object Pointer to the object to store
+     */
+    ObjectHolderByConstRef(const T* object);
+
+    /**
+     * \brief Return a typeless pointer to the stored object
+     *
+     * \return Pointer to the object
+     */
+    virtual void* object();
+
+    /**
+     * \brief Return a holder which is able to modify its stored object
+     *
+     * The holder can return itself it it already meets the requirement,
+     * otherwise it may return a new holder storing a copy of its object.
+     *
+     * \return Holder storing a writable object
+     */
+    virtual AbstractObjectHolder* getWritable();
+
+private:
+
+    const T* m_object; ///< Pointer to the object
+    void* m_alignedPtr; ///< Pointer to the actual derived part of the object (may be different than m_object in case of multiple inheritance with offset)
+};
+
+/**
+ * \brief Typed specialization of AbstractObjectHolder for storage by reference
+ */
+template <typename T>
+class ObjectHolderByRef : public AbstractObjectHolder
+{
+public:
+
+    /**
+     * \brief Construct the holder from an object
+     *
+     * \param object Pointer to the object to store
+     */
+    ObjectHolderByRef(T* object);
+
+    ObjectHolderByRef(boost::shared_ptr<T>* object);
+    
+    /**
+     * \brief Return a typeless pointer to the stored object
+     *
+     * \return Pointer to the object
+     */
+    virtual void* object();
+
+    /**
+     * \brief Return a holder which is able to modify its stored object
+     *
+     * The holder can return itself it it already meets the requirement,
+     * otherwise it may return a new holder storing a copy of its object.
+     *
+     * \return Holder storing a writable object
+     */
+    virtual AbstractObjectHolder* getWritable();
+
+private:
+
+    T* m_object; ///< Pointer to the object
+    void* m_alignedPtr; ///< Pointer to the actual derived part of the object (may be different than m_object in case of multiple inheritance with offset)
+};
+
+/**
+ * \brief Typed specialization of AbstractObjectHolder for storage by copy
+ */
+template <typename T>
+class ObjectHolderByCopy : public AbstractObjectHolder
+{
+public:
+
+    /**
+     * \brief Construct the holder from an object
+     *
+     * \param object Object to store
+     */
+    ObjectHolderByCopy(const T* object);
+
+    /**
+     * \brief Return a typeless pointer to the stored object
+     *
+     * \return Pointer to the object
+     */
+    virtual void* object();
+
+    /**
+     * \brief Return a holder which is able to modify its stored object
+     *
+     * The holder can return itself it it already meets the requirement,
+     * otherwise it may return a new holder storing a copy of its object.
+     *
+     * \return Holder storing a writable object
+     */
+    virtual AbstractObjectHolder* getWritable();
+
+private:
+
+    T m_object; ///< Copy of the object
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/objectholder.inl>
+
+
+#endif // CAMP_DETAIL_OBJECTHOLDER_HPP
diff --git a/include/camp/detail/objectholder.inl b/include/camp/detail/objectholder.inl
new file mode 100644
index 0000000..08bc694
--- /dev/null
+++ b/include/camp/detail/objectholder.inl
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+inline AbstractObjectHolder::~AbstractObjectHolder()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+inline AbstractObjectHolder::AbstractObjectHolder()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ObjectHolderByConstRef<T>::ObjectHolderByConstRef(const T* object)
+    : m_object(object)
+    , m_alignedPtr(classCast(const_cast<T*>(object), classByType<T>(), classByObject(object)))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+void* ObjectHolderByConstRef<T>::object()
+{
+    return m_alignedPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+AbstractObjectHolder* ObjectHolderByConstRef<T>::getWritable()
+{
+    // We hold a read-only object: return a holder which stores a copy of it
+    return new ObjectHolderByCopy<T>(m_object);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ObjectHolderByRef<T>::ObjectHolderByRef(T* object)
+    : m_object(object)
+    , m_alignedPtr(classCast(object, classByType<T>(), classByObject(object)))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ObjectHolderByRef<T>::ObjectHolderByRef(::boost::shared_ptr<T>* object)
+    : m_object(object->get())
+    , m_alignedPtr(classCast(object, classByType<T>(), classByObject(object->get())))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+void* ObjectHolderByRef<T>::object()
+{
+    return m_alignedPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+AbstractObjectHolder* ObjectHolderByRef<T>::getWritable()
+{
+    // We already store a modifiable object
+    return this;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+ObjectHolderByCopy<T>::ObjectHolderByCopy(const T* object)
+    : m_object(*object)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+void* ObjectHolderByCopy<T>::object()
+{
+    return &m_object;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+AbstractObjectHolder* ObjectHolderByCopy<T>::getWritable()
+{
+    // We already store a modifiable object
+    return this;
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/objecttraits.hpp b/include/camp/detail/objecttraits.hpp
new file mode 100644
index 0000000..e01ec27
--- /dev/null
+++ b/include/camp/detail/objecttraits.hpp
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_OBJECTTRAITS_HPP
+#define CAMP_DETAIL_OBJECTTRAITS_HPP
+
+
+#include <camp/detail/rawtype.hpp>
+#include <camp/detail/issmartpointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \class ObjectTraits
+ *
+ * \brief Utility class which gives compile-time informations about the semantics of a type
+ *
+ * It provides the following constants:
+ *
+ * \li isWritable: true if the type allows to modify the object (non-const references and pointers)
+ * \li isRef: true if the type is a reference type (references and pointers)
+ *
+ * ... the following types:
+ *
+ * \li RefReturnType: the reference type closest to T which allows to have direct access to the object (T& for raw types and references, T* for pointer types)
+ * \li PointerType: the pointer type closest to T which allows to have direct access to the object (T*)
+ * \li DataType: the actual raw type of the object (removes all indirections, as well const and reference modifiers)
+ *
+ * ... and the following functions:
+ *
+ * \li get(void*): get a direct access to an object given by a typeless pointer (in other words, converts from void* to RefReturnType)
+ * \li getPointer(T): get a direct pointer to an object, regardless its original storage / modifiers (in other words, convert from T to PointerType)
+ */
+
+/*
+ * Generic version -- raw types
+ */
+template <typename T, typename E = void>
+struct ObjectTraits
+{
+    enum
+    {
+        isWritable = false,
+        isRef = false
+    };
+
+    typedef T& RefReturnType;
+    typedef typename RawType<T>::Type DataType;
+
+    static RefReturnType get(void* pointer) {return *static_cast<T*>(pointer);}
+};
+
+/*
+ * Specialized version for raw pointers
+ */
+template <typename T>
+struct ObjectTraits<T*>
+{
+    enum
+    {
+        isWritable = !boost::is_const<T>::value,
+        isRef = true
+    };
+
+    typedef T* RefReturnType;
+    typedef T* PointerType;
+    typedef typename RawType<T>::Type DataType;
+
+    static RefReturnType get(void* pointer) {return static_cast<T*>(pointer);}
+    static PointerType getPointer(T* value) {return value;}
+};
+
+/*
+ * Specialized version for smart pointers
+ */
+template <template <typename> class T, typename U>
+struct ObjectTraits<T<U>, typename boost::enable_if<IsSmartPointer<T<U>, U> >::type>
+{
+    enum
+    {
+        isWritable = !boost::is_const<U>::value,
+        isRef = true
+    };
+
+    typedef U* RefReturnType;
+    typedef U* PointerType;
+    typedef typename RawType<U>::Type DataType;
+
+    static RefReturnType get(void* pointer) {return static_cast<U*>(pointer);}
+    static PointerType getPointer(T<U> value) {return boost::get_pointer(value);}
+};
+
+/*
+ * Specialized version for built-in arrays
+ */
+template <typename T, int N>
+struct ObjectTraits<T[N]>
+{
+    enum
+    {
+        isWritable = false,
+        isRef = true
+    };
+
+    typedef T(&RefReturnType)[N];
+    typedef typename RawType<T>::Type DataType;
+};
+
+/*
+ * Specialized version for references to non-ref types
+ */
+template <typename T>
+struct ObjectTraits<T&, typename boost::disable_if<boost::is_pointer<typename ObjectTraits<T>::RefReturnType> >::type>
+{
+    enum
+    {
+        isWritable = !boost::is_const<T>::value,
+        isRef = true
+    };
+
+    typedef T& RefReturnType;
+    typedef T* PointerType;
+    typedef typename RawType<T>::Type DataType;
+
+    static RefReturnType get(void* pointer) {return *static_cast<T*>(pointer);}
+    static PointerType getPointer(T& value) {return &value;}
+};
+
+/*
+ * Specialized version for references to ref types -- just remove the reference modifier
+ */
+template <typename T>
+struct ObjectTraits<T&, typename boost::enable_if<boost::is_pointer<typename ObjectTraits<T>::RefReturnType> >::type> : ObjectTraits<T>
+{
+};
+
+/*
+ * Specialized version for types with const modifier -- just remove it
+ */
+template <typename T>
+struct ObjectTraits<const T> : ObjectTraits<T>
+{
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_OBJECTTRAITS_HPP
diff --git a/include/camp/detail/observernotifier.hpp b/include/camp/detail/observernotifier.hpp
new file mode 100644
index 0000000..5a5c9e3
--- /dev/null
+++ b/include/camp/detail/observernotifier.hpp
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_OBSERVERNOTIFIER_HPP
+#define CAMP_DETAIL_OBSERVERNOTIFIER_HPP
+
+
+#include <camp/config.hpp>
+#include <set>
+
+
+namespace camp
+{
+class Observer;
+class Class;
+class Enum;
+
+namespace detail
+{
+/**
+ * \brief Base class for classes that can notify global observers
+ */
+class ObserverNotifier
+{
+public:
+
+    /**
+     * \brief Register a new observer
+     *
+     * The new observer will be notified of metaclasses and metaenums creation/removal.
+     * This function doesn't take the ownership of the given object,
+     * don't forget to destroy it on your side
+     *
+     * \param observer New observer to register
+     */
+    void addObserver(Observer* observer);
+
+    /**
+     * \brief Unregister an existing observer
+     *
+     * This function doesn't destroy the object, it just removes it
+     * from the list of registered observers.
+     *
+     * \param observer Observer to unregister
+     */
+    void removeObserver(Observer* observer);
+
+protected:
+
+    /**
+     * \brief Default constructor
+     */
+    ObserverNotifier();
+
+    /**
+     * \brief Notify all the registered observers of a class creation
+     *
+     * \param theClass Class that have been added
+     */
+    void notifyClassAdded(const Class& theClass);
+
+    /**
+     * \brief Notify all the registered observers of a class removal
+     *
+     * \param theClass Class that have been removed
+     */
+    void notifyClassRemoved(const Class& theClass);
+
+    /**
+     * \brief Notify all the registered observers of an enum creation
+     *
+     * \param theEnum Enum that have been added
+     */
+    void notifyEnumAdded(const Enum& theEnum);
+
+    /**
+     * \brief Notify all the registered observers of an enum removal
+     *
+     * \param theEnum Enum that have been removed
+     */
+    void notifyEnumRemoved(const Enum& theEnum);
+
+private:
+
+    typedef std::set<Observer*> ObserverSet;
+
+    ObserverSet m_observers; ///< Sequence of registered observers
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_OBSERVERNOTIFIER_HPP
diff --git a/include/camp/detail/propertyfactory.hpp b/include/camp/detail/propertyfactory.hpp
new file mode 100644
index 0000000..b5e0e9c
--- /dev/null
+++ b/include/camp/detail/propertyfactory.hpp
@@ -0,0 +1,434 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_PROPERTYFACTORY_HPP
+#define CAMP_DETAIL_PROPERTYFACTORY_HPP
+
+
+#include <camp/type.hpp>
+#include <camp/detail/simplepropertyimpl.hpp>
+#include <camp/detail/arraypropertyimpl.hpp>
+#include <camp/detail/enumpropertyimpl.hpp>
+#include <camp/detail/userpropertyimpl.hpp>
+#include <camp/detail/functiontraits.hpp>
+#include <boost/function.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/*
+ * Instanciate simple properties
+ */
+template <typename A, int T>
+struct PropertyMapper
+{
+    typedef SimplePropertyImpl<A> Type;
+};
+
+/*
+ * Instanciate array properties
+ */
+template <typename A>
+struct PropertyMapper<A, camp::arrayType>
+{
+    typedef ArrayPropertyImpl<A> Type;
+};
+
+/*
+ * Instanciate enum properties
+ */
+template <typename A>
+struct PropertyMapper<A, camp::enumType>
+{
+    typedef EnumPropertyImpl<A> Type;
+};
+
+/*
+ * Instanciate user properties
+ */
+template <typename A>
+struct PropertyMapper<A, camp::userType>
+{
+    typedef UserPropertyImpl<A> Type;
+};
+
+/**
+ * Helper structure to perform copy and assignment
+ *
+ * The purpose of this structure is to avoid a compiler error when the copied
+ * type is not copyable. Instead, we just return an error so that the caller
+ * can throw a CAMP exception.
+ */
+template <typename T, typename E = void>
+struct CopyHelper
+{
+    static bool copy(T& destination, const Value& source)
+    {
+        destination = source.to<T>();
+        return true;
+    }
+};
+
+/**
+ * Specialization of CopyHelper for non-copyable types
+ */
+template <typename T>
+struct CopyHelper<T, typename boost::enable_if_c<!StaticTypeId<T>::copyable>::type>
+{
+    static bool copy(T&, const Value&)
+    {
+        // We don't really return an error, we just skip the assignment
+        return true;
+    }
+};
+
+/**
+ * Helper structure to return values
+ *
+ * The purpose of this structure is to provide workarounds for types
+ * that don't exactly satisfy the compiler when returned. For example,
+ * it converts smart pointer types to the corresponding raw pointer types.
+ */
+template <typename T, typename E = void>
+struct ReturnHelper
+{
+    typedef T Type;
+    static Type get(T value) {return value;}
+};
+
+/**
+ * Specialization of ReturnHelper for smart pointer types
+ */
+template <template <typename> class T, typename U>
+struct ReturnHelper<T<U>, typename boost::enable_if<IsSmartPointer<T<U>, U> >::type>
+{
+    typedef U* Type;
+    static Type get(T<U> value) {return boost::get_pointer(value);}
+};
+
+/**
+ * Specialization of ReturnHelper for built-in array types
+ */
+template <typename T, int N>
+struct ReturnHelper<T[N]>
+{
+    typedef T (&Type)[N];
+    static Type get(T (&value)[N]) {return value;}
+};
+
+/*
+ * Property accessor composed of 1 getter
+ */
+template <typename C, typename R, typename E = void>
+class Accessor1
+{
+public:
+
+    typedef ObjectTraits<R> Traits;
+    typedef typename Traits::DataType DataType;
+    typedef C ClassType;
+
+    enum
+    {
+        canRead = true,
+        canWrite = false
+    };
+
+    template <typename F>
+    Accessor1(F getter)
+        : m_getter(getter)
+    {
+    }
+
+    typename ReturnHelper<R>::Type get(C& object) const
+    {
+        return ReturnHelper<R>::get(m_getter(object));
+    }
+
+    bool set(C&, const Value&) const
+    {
+        // Not available
+        return false;
+    }
+
+private:
+
+    boost::function<R (C&)> m_getter;
+};
+
+/*
+ * Property accessor composed of 1 read-write accessor
+ */
+template <typename C, typename R>
+class Accessor1<C, R, typename boost::enable_if_c<ObjectTraits<R>::isWritable>::type>
+{
+public:
+
+    typedef ObjectTraits<R> Traits;
+    typedef typename Traits::DataType DataType;
+    typedef C ClassType;
+
+    enum
+    {
+        canRead = true,
+        canWrite = true
+    };
+
+    template <typename F>
+    Accessor1(F getter)
+        : m_getter(getter)
+    {
+    }
+
+    typename ReturnHelper<R>::Type get(C& object) const
+    {
+        return ReturnHelper<R>::get(m_getter(object));
+    }
+
+    bool set(C& object, const Value& value) const
+    {
+        return CopyHelper<DataType>::copy(*Traits::getPointer(m_getter(object)), value);
+    }
+
+private:
+
+    boost::function<R (C&)> m_getter;
+};
+
+/*
+ * Property accessor composed of 1 getter and 1 setter
+ */
+template <typename C, typename R>
+class Accessor2
+{
+public:
+
+    typedef ObjectTraits<R> Traits;
+    typedef typename Traits::DataType DataType;
+    typedef C ClassType;
+    typedef typename boost::remove_reference<R>::type ArgumentType;
+
+    enum
+    {
+        canRead = true,
+        canWrite = true
+    };
+
+    template <typename F1, typename F2>
+    Accessor2(F1 getter, F2 setter)
+        : m_getter(getter)
+        , m_setter(setter)
+    {
+    }
+
+    typename ReturnHelper<R>::Type get(C& object) const
+    {
+        return ReturnHelper<R>::get(m_getter(object));
+    }
+
+    bool set(C& object, const Value& value) const
+    {
+        m_setter(object, value.to<ArgumentType>());
+        return true;
+    }
+
+private:
+
+    boost::function<R (C&)> m_getter;
+    boost::function<void (C&, ArgumentType)> m_setter;
+};
+
+/*
+ * Property accessor composed of 1 composed getter
+ */
+template <typename C, typename N, typename R, typename E = void>
+class Accessor3
+{
+public:
+
+    typedef ObjectTraits<R> Traits;
+    typedef typename Traits::DataType DataType;
+    typedef C ClassType;
+
+    enum
+    {
+        canRead = true,
+        canWrite = false
+    };
+
+    template <typename F1, typename F2>
+    Accessor3(F1 getter1, F2 getter2)
+        : m_getter1(getter1)
+        , m_getter2(getter2)
+    {
+    }
+
+    typename ReturnHelper<R>::Type get(C& object) const
+    {
+        return ReturnHelper<R>::get(m_getter1(m_getter2(object)));
+    }
+
+    bool set(C&, const Value&) const
+    {
+        // Not available
+        return false;
+    }
+
+private:
+
+    boost::function<R (N&)> m_getter1;
+    boost::function<N& (C&)> m_getter2;
+};
+
+/*
+ * Property accessor composed of 1 composed read-write accessor
+ */
+template <typename C, typename N, typename R>
+class Accessor3<C, N, R, typename boost::enable_if_c<ObjectTraits<R>::isWritable>::type>
+{
+public:
+
+    typedef ObjectTraits<R> Traits;
+    typedef typename Traits::DataType DataType;
+    typedef C ClassType;
+
+    enum
+    {
+        canRead = true,
+        canWrite = true
+    };
+
+    template <typename F1, typename F2>
+    Accessor3(F1 getter1, F2 getter2)
+        : m_getter1(getter1)
+        , m_getter2(getter2)
+    {
+    }
+
+    typename ReturnHelper<R>::Type get(C& object) const
+    {
+        return ReturnHelper<R>::get(m_getter1(m_getter2(object)));
+    }
+
+    bool set(C& object, const Value& value) const
+    {
+        return CopyHelper<DataType>::copy(*Traits::getPointer(m_getter1(m_getter2(object))), value);
+    }
+
+private:
+
+    boost::function<R (N&)> m_getter1;
+    boost::function<N& (C&)> m_getter2;
+};
+
+
+/*
+ * Property factory which instanciates the proper type of property from 1 accessor
+ */
+template <typename C, typename F>
+struct PropertyFactory1
+{
+    typedef typename FunctionTraits<F>::ReturnType ReturnType;
+
+    static Property* get(const std::string& name, F accessor)
+    {
+        typedef Accessor1<C, ReturnType> AccessorType;
+
+        typedef camp_ext::ValueMapper<typename AccessorType::DataType> ValueMapper;
+        typedef typename PropertyMapper<AccessorType, ValueMapper::type>::Type PropertyType;
+
+        return new PropertyType(name, AccessorType(accessor));
+    }
+};
+
+/*
+ * Property factory which instanciates the proper type of property from 2 accessors
+ */
+template <typename C, typename F1, typename F2, typename E = void>
+struct PropertyFactory2
+{
+    typedef typename FunctionTraits<F1>::ReturnType ReturnType;
+
+    static Property* get(const std::string& name, F1 accessor1, F2 accessor2)
+    {
+        typedef Accessor2<C, ReturnType> AccessorType;
+
+        typedef camp_ext::ValueMapper<typename AccessorType::DataType> ValueMapper;
+        typedef typename PropertyMapper<AccessorType, ValueMapper::type>::Type PropertyType;
+
+        return new PropertyType(name, AccessorType(accessor1, accessor2));
+    }
+};
+
+/*
+ * Specialization of PropertyFactory2 with 2 getters (which will produce 1 composed getter)
+ */
+template <typename C, typename F1, typename F2>
+struct PropertyFactory2<C, F1, F2, typename boost::enable_if_c<!boost::is_void<typename FunctionTraits<F2>::ReturnType>::value>::type>
+{
+    typedef typename FunctionTraits<F1>::ReturnType ReturnType;
+    typedef typename boost::remove_reference<typename FunctionTraits<F2>::ReturnType>::type OtherClassType;
+
+    static Property* get(const std::string& name, F1 accessor1, F2 accessor2)
+    {
+        typedef Accessor3<C, OtherClassType, ReturnType> AccessorType;
+
+        typedef camp_ext::ValueMapper<typename AccessorType::DataType> ValueMapper;
+        typedef typename PropertyMapper<AccessorType, ValueMapper::type>::Type PropertyType;
+
+        return new PropertyType(name, AccessorType(accessor1, accessor2));
+    }
+};
+
+/*
+ * Property factory which instanciates the proper type of property from 3 accessors
+ */
+template <typename C, typename F1, typename F2, typename F3>
+struct PropertyFactory3
+{
+    typedef typename FunctionTraits<F1>::ReturnType ReturnType;
+    typedef typename FunctionTraits<F3>::ReturnType InnerType;
+
+    static Property* get(const std::string& name, F1 accessor1, F2 accessor2, F3 accessor3)
+    {
+        typedef Accessor2<C, ReturnType> AccessorType;
+
+        typedef camp_ext::ValueMapper<typename AccessorType::DataType> ValueMapper;
+        typedef typename PropertyMapper<AccessorType, ValueMapper::type>::Type PropertyType;
+
+        return new PropertyType(name, AccessorType(boost::bind(boost::type<ReturnType>(), accessor1, boost::bind(boost::type<InnerType>(), accessor3, _1)),
+                                                   boost::bind(boost::type<void>(), accessor2, boost::bind(boost::type<InnerType>(), accessor3, _1), _2)));
+    }
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_PROPERTYFACTORY_HPP
diff --git a/include/camp/detail/rawtype.hpp b/include/camp/detail/rawtype.hpp
new file mode 100644
index 0000000..a3816f4
--- /dev/null
+++ b/include/camp/detail/rawtype.hpp
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_RAWTYPE_HPP
+#define CAMP_DETAIL_RAWTYPE_HPP
+
+
+#include <camp/detail/issmartpointer.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \class RawType
+ *
+ * \brief Helper structure used to extract the raw type of a composed type
+ *
+ * RawType<T> recursively removes const, reference and pointer modifiers from the given type.
+ * In other words:
+ *
+ * \li RawType<T>::Type == T
+ * \li RawType<const T>::Type == RawType<T>::Type
+ * \li RawType<T&>::Type == RawType<T>::Type
+ * \li RawType<const T&>::Type == RawType<T>::Type
+ * \li RawType<T*>::Type == RawType<T>::Type
+ * \li RawType<const T*>::Type == RawType<T>::Type
+ *
+ * \remark RawType is able to detect smart pointers and properly extract the stored type
+ */
+
+/*
+ * Generic version -- T doesn't match with any of our specialization, and is thus considered a raw type
+ */
+template <typename T, typename E = void>
+struct RawType
+{
+    typedef T Type;
+};
+
+/*
+ * Specialized version for const modifier
+ */
+template <typename T> struct RawType<const T>
+{
+    typedef typename RawType<T>::Type Type;
+};
+
+/*
+ * Specialized version for reference modifier
+ */
+template <typename T> struct RawType<T&>
+{
+    typedef typename RawType<T>::Type Type;
+};
+
+/*
+ * Specialized version for raw pointers
+ */
+template <typename T>
+struct RawType<T*>
+{
+    typedef typename RawType<T>::Type Type;
+};
+
+/*
+ * Specialized version for smart pointers
+ */
+template <template <typename> class T, typename U>
+struct RawType<T<U>, typename boost::enable_if<IsSmartPointer<T<U>, U> >::type>
+{
+    typedef typename RawType<U>::Type Type;
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_RAWTYPE_HPP
diff --git a/include/camp/detail/returntype.hpp b/include/camp/detail/returntype.hpp
new file mode 100644
index 0000000..a2f1809
--- /dev/null
+++ b/include/camp/detail/returntype.hpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_RETURNTYPE_HPP
+#define CAMP_DETAIL_RETURNTYPE_HPP
+
+
+namespace camp
+{
+namespace detail
+{
+
+/**
+ * \class ReturnType
+ *
+ * \brief Utility class used at compile-time to which type to use to avoid copying the returned object
+ *
+ * \li If T is a reference or a pointer type, ReturnType<T>::Type is T
+ * \li Otherwise, ReturnType<T>::Type is T&
+ */
+
+template <typename T> struct ReturnType     {typedef T& Type;};
+template <typename T> struct ReturnType<T&> {typedef T& Type;};
+template <typename T> struct ReturnType<T*> {typedef T* Type;};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_RETURNTYPE_HPP
diff --git a/include/camp/detail/simplepropertyimpl.hpp b/include/camp/detail/simplepropertyimpl.hpp
new file mode 100644
index 0000000..fe71876
--- /dev/null
+++ b/include/camp/detail/simplepropertyimpl.hpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_SIMPLEPROPERTYIMPL_HPP
+#define CAMP_DETAIL_SIMPLEPROPERTYIMPL_HPP
+
+
+#include <camp/simpleproperty.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Typed implementation of SimpleProperty
+ *
+ * SimplePropertyImpl is a template implementation of SimpleProperty, which is strongly typed
+ * in order to keep track of the true underlying C++ types involved in the property.
+ *
+ * The template parameter A is an abstract helper to access the actual C++ property.
+ *
+ * \sa SimpleProperty
+ */
+template <typename A>
+class SimplePropertyImpl : public SimpleProperty
+{
+public:
+
+    /**
+     * \brief Construct the property from its accessors
+     *
+     * \param name Name of the property
+     * \param accessor Object used to access the actual C++ property
+     */
+    SimplePropertyImpl(const std::string& name, const A& accessor);
+
+protected:
+
+    /**
+     * \see Property::isReadable
+     */
+    virtual bool isReadable() const;
+
+    /**
+     * \see Property::isWritable
+     */
+    virtual bool isWritable() const;
+
+    /**
+     * \see Property::getValue
+     */
+    virtual Value getValue(const UserObject& object) const;
+
+    /**
+     * \see Property::setValue
+     */
+    virtual void setValue(const UserObject& object, const Value& value) const;
+
+private:
+
+    A m_accessor; ///< Object used to access the actual C++ property
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/simplepropertyimpl.inl>
+
+
+#endif // CAMP_DETAIL_SIMPLEPROPERTYIMPL_HPP
diff --git a/include/camp/detail/simplepropertyimpl.inl b/include/camp/detail/simplepropertyimpl.inl
new file mode 100644
index 0000000..4e573fb
--- /dev/null
+++ b/include/camp/detail/simplepropertyimpl.inl
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+SimplePropertyImpl<A>::SimplePropertyImpl(const std::string& name, const A& accessor)
+    : SimpleProperty(name, mapType<typename A::DataType>())
+    , m_accessor(accessor)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+Value SimplePropertyImpl<A>::getValue(const UserObject& object) const
+{
+    return m_accessor.get(object.get<typename A::ClassType>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void SimplePropertyImpl<A>::setValue(const UserObject& object, const Value& value) const
+{
+    if (!m_accessor.set(object.get<typename A::ClassType>(), value))
+        CAMP_ERROR(ForbiddenWrite(name()));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool SimplePropertyImpl<A>::isReadable() const
+{
+    return A::canRead;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool SimplePropertyImpl<A>::isWritable() const
+{
+    return A::canWrite;
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/typeid.hpp b/include/camp/detail/typeid.hpp
new file mode 100644
index 0000000..4510668
--- /dev/null
+++ b/include/camp/detail/typeid.hpp
@@ -0,0 +1,183 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_TYPEID_HPP
+#define CAMP_DETAIL_TYPEID_HPP
+
+
+#include <camp/detail/objecttraits.hpp>
+#include <camp/detail/yesnotype.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Utility class to get the CAMP identifier associated to a C++ type
+ *
+ * A compiler error will be triggered if requesting the identifier of a type
+ * which hasn't been registered with the CAMP_TYPE macro.
+ */
+template <typename T>
+struct StaticTypeId
+{
+    static const char* get(bool = true)
+    {
+        // If you get this error, it means you didn't register
+        // your class/enum T with the CAMP_TYPE macro
+        return T::CAMP_TYPE_NOT_REGISTERED();
+    }
+
+    enum
+    {
+        defined = false,
+        copyable = true
+    };
+};
+
+/**
+ * \brief Utility class to check if a type has a CAMP id (i.e. has been registered with CAMP_TYPE)
+ */
+template <typename T>
+struct HasStaticTypeId
+{
+    enum
+    {
+        value = StaticTypeId<typename RawType<T>::Type>::defined
+    };
+};
+
+/**
+ * \brief Return the static type identifier of a C++ type T
+ */
+template <typename T> const char* staticTypeId()         {return StaticTypeId<typename RawType<T>::Type>::get();}
+template <typename T> const char* staticTypeId(const T&) {return StaticTypeId<typename RawType<T>::Type>::get();}
+
+/**
+ * \brief Utility class used to check at compile-time if a type T implements the CAMP RTTI
+ */
+template <typename T>
+struct HasCampRtti
+{
+    template <typename U, const char* (U::*)() const> struct TestForMember {};
+    template <typename U> static TypeYes check(TestForMember<U, &U::campClassId>*);
+    template <typename U> static TypeNo  check(...);
+
+    enum {value = sizeof(check<typename RawType<T>::Type>(0)) == sizeof(TypeYes)};
+};
+
+/**
+ * \brief Utility class to get the CAMP identifier associated to a C++ object
+ *
+ * If the object has a dynamic type which is different from its static type
+ * (i.e. <tt>Base* obj = new Derived</tt>), and both classes use the
+ * CAMP_RTTI macro, then the system is able to return the identifier of
+ * the true dynamic type of the object.
+ */
+template <typename T, typename E = void>
+struct DynamicTypeId
+{
+    typedef ObjectTraits<const T&> Traits;
+
+    static const char* get(const T& object)
+    {
+        typename Traits::PointerType pointer = Traits::getPointer(object);
+        return pointer ? pointer->campClassId() : staticTypeId<T>();
+    }
+};
+
+/**
+ * Specialization of DynamicTypeId for types that don't implement CAMP RTTI
+ */
+template <typename T>
+struct DynamicTypeId<T, typename boost::disable_if<HasCampRtti<T> >::type>
+{
+    static const char* get(const T&)
+    {
+        return staticTypeId<T>();
+    }
+};
+
+/**
+ * \brief Return the dynamic type identifier of a C++ object
+ */
+template <typename T> const char* typeId()                {return staticTypeId<T>();}
+template <typename T> const char* typeId(const T& object) {return DynamicTypeId<T>::get(object);}
+
+/**
+ * \brief Utility class to get a valid CAMP identifier from a C++ type even if the type wasn't declared
+ */
+template <typename T, typename E = void>
+struct SafeTypeId
+{
+    static const char* get()
+    {
+        return typeId<T>();
+    }
+
+    static const char* get(const T& object)
+    {
+        return typeId(object);
+    }
+};
+
+/**
+ * Specialization of SafeTypeId for types that have no CAMP id
+ */
+template <typename T>
+struct SafeTypeId<T, typename boost::disable_if<HasStaticTypeId<T> >::type>
+{
+    static const char* get()
+    {
+        return "";
+    }
+
+    static const char* get(const T&)
+    {
+        return "";
+    }
+};
+
+/**
+ * Specialization of SafeTypeId needed because "const void&" is not a valid expression
+ */
+template <>
+struct SafeTypeId<void>
+{
+    static const char* get() {return "";}
+};
+
+/**
+ * \brief Return the dynamic type identifier of a C++ object even if it doesn't exist (i.e. it can't fail)
+ */
+template <typename T> const char* safeTypeId()                {return SafeTypeId<typename RawType<T>::Type>::get();}
+template <typename T> const char* safeTypeId(const T& object) {return SafeTypeId<T>::get(object);}
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_TYPEID_HPP
diff --git a/include/camp/detail/userpropertyimpl.hpp b/include/camp/detail/userpropertyimpl.hpp
new file mode 100644
index 0000000..02be3f6
--- /dev/null
+++ b/include/camp/detail/userpropertyimpl.hpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_USERPROPERTYIMPL_HPP
+#define CAMP_DETAIL_USERPROPERTYIMPL_HPP
+
+
+#include <camp/userproperty.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Typed implementation of UserProperty
+ *
+ * UserPropertyImpl is a template implementation of UserProperty, which is strongly typed
+ * in order to keep track of the true underlying C++ types involved in the property.
+ *
+ * The template parameter A is an abstract helper to access the actual C++ property.
+ *
+ * \sa UserProperty
+ */
+template <typename A>
+class UserPropertyImpl : public UserProperty
+{
+public:
+
+    /**
+     * \brief Construct the property from its accessors
+     *
+     * \param name Name of the property
+     * \param accessor Object used to access the actual C++ property
+     */
+    UserPropertyImpl(const std::string& name, const A& accessor);
+
+protected:
+
+    /**
+     * \see Property::isReadable
+     */
+    virtual bool isReadable() const;
+
+    /**
+     * \see Property::isWritable
+     */
+    virtual bool isWritable() const;
+
+    /**
+     * \see Property::getValue
+     */
+    virtual Value getValue(const UserObject& object) const;
+
+    /**
+     * \see Property::setValue
+     */
+    virtual void setValue(const UserObject& object, const Value& value) const;
+
+private:
+
+    A m_accessor; ///< Object used to access the actual C++ property
+};
+
+} // namespace detail
+
+} // namespace camp
+
+#include <camp/detail/userpropertyimpl.inl>
+
+
+#endif // CAMP_DETAIL_USERPROPERTYIMPL_HPP
diff --git a/include/camp/detail/userpropertyimpl.inl b/include/camp/detail/userpropertyimpl.inl
new file mode 100644
index 0000000..ece5ce9
--- /dev/null
+++ b/include/camp/detail/userpropertyimpl.inl
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Helper structure to construct a UserObject according
+ *        to whether a type is a reference type or not
+ *
+ * The generic version assumes a non-reference type and stores
+ * the object by copy.
+ */
+template <bool IsRef>
+struct ToUserObject
+{
+    template <typename T>
+    static UserObject get(const T& value)
+    {
+        return UserObject::copy(value);
+    }
+};
+
+/**
+ * \brief Specialization of ToUserObject for reference types
+ *
+ * This version stores the object by reference (no copy).
+ */
+template <>
+struct ToUserObject<true>
+{
+    template <typename T>
+    static UserObject get(const T& value)
+    {
+        return UserObject::ref(value);
+    }
+
+    template <typename T>
+    static UserObject get(T& value)
+    {
+        return UserObject::ref(value);
+    }
+};
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+UserPropertyImpl<A>::UserPropertyImpl(const std::string& name, const A& accessor)
+    : UserProperty(name, classByType<typename A::DataType>())
+    , m_accessor(accessor)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+Value UserPropertyImpl<A>::getValue(const UserObject& object) const
+{
+    return ToUserObject<A::Traits::isRef>::get(m_accessor.get(object.get<typename A::ClassType>()));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+void UserPropertyImpl<A>::setValue(const UserObject& object, const Value& value) const
+{
+    if (!m_accessor.set(object.get<typename A::ClassType>(), value))
+        CAMP_ERROR(ForbiddenWrite(name()));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool UserPropertyImpl<A>::isReadable() const
+{
+    return A::canRead;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename A>
+bool UserPropertyImpl<A>::isWritable() const
+{
+    return A::canWrite;
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/include/camp/detail/valueimpl.hpp b/include/camp/detail/valueimpl.hpp
new file mode 100644
index 0000000..3b8aa8e
--- /dev/null
+++ b/include/camp/detail/valueimpl.hpp
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_VALUEIMPL_HPP
+#define CAMP_DETAIL_VALUEIMPL_HPP
+
+#include <camp/type.hpp>
+#include <camp/valuemapper.hpp>
+#include <camp/errors.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Value visitor which converts the stored value to a type T
+ */
+template <typename T>
+struct ConvertVisitor : public boost::static_visitor<T>
+{
+    template <typename U>
+    T operator()(const U& value) const
+    {
+        // Dispatch to the proper ValueConverter
+        return camp_ext::ValueMapper<T>::from(value);
+    }
+
+    T operator()(const T& value) const
+    {
+        // Optimization when source type is the same as requested type
+        return value;
+    }
+
+    T operator()(NoType) const
+    {
+        // Error: trying to convert an empty value
+        CAMP_ERROR(BadType(noType, mapType<T>()));
+    }
+};
+
+/**
+ * \brief Binary value visitor which compares two values using operator <
+ */
+struct LessThanVisitor : public boost::static_visitor<bool>
+{
+    template <typename T, typename U>
+    bool operator()(const T&, const U&) const
+    {
+        // Different types : compare types identifiers
+        return mapType<T>() < mapType<U>();
+    }
+
+    template <typename T>
+    bool operator()(const T& v1, const T& v2) const
+    {
+        // Same types : compare values
+        return v1 < v2;
+    }
+
+    bool operator()(NoType, NoType) const
+    {
+        // No type (empty values) : they're considered equal
+        return false;
+    }
+};
+
+/**
+ * \brief Binary value visitor which compares two values using operator ==
+ */
+struct EqualVisitor : public boost::static_visitor<bool>
+{
+    template <typename T, typename U>
+    bool operator()(const T&, const U&) const
+    {
+        // Different types : not equal
+        return false;
+    }
+
+    template <typename T>
+    bool operator()(const T& v1, const T& v2) const
+    {
+        // Same types : compare values
+        return v1 == v2;
+    }
+
+    bool operator()(NoType, NoType) const
+    {
+        // No type (empty values) : they're considered equal
+        return true;
+    }
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_VALUEIMPL_HPP
diff --git a/include/camp/detail/valueprovider.hpp b/include/camp/detail/valueprovider.hpp
new file mode 100644
index 0000000..75a3fa3
--- /dev/null
+++ b/include/camp/detail/valueprovider.hpp
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_DETAIL_VALUEPROVIDER_HPP
+#define CAMP_DETAIL_VALUEPROVIDER_HPP
+
+
+#include <camp/class.hpp>
+#include <camp/classget.hpp>
+#include <camp/valuemapper.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+/*
+ * Implementation of ValueProvider
+ * Generic version, use default constructor
+ */
+template <typename T, int Type>
+struct ValueProviderImpl
+{
+    T operator()() {return T();}
+};
+
+/*
+ * Specialization for user types: use metaclass to instanciate
+ * so that we get an exception rather than a compile error
+ * if the type has no default constructor
+ */
+template <typename T>
+struct ValueProviderImpl<T, userType>
+{
+    ValueProviderImpl() : m_value(classByType<T>().construct().template get<T*>()) {}
+    ~ValueProviderImpl() {classByType<T>().destroy(m_value);}
+    T& operator()() {return *m_value;}
+    T* m_value;
+};
+
+/*
+ * Specialization for pointer to primitive types: use new to allocate objects
+ * Here we assume that the caller will take ownership of the returned value
+ */
+template <typename T, int Type>
+struct ValueProviderImpl<T*, Type>
+{
+    T* operator()() {return new T;}
+};
+
+/*
+ * Specialization for pointer to user types: use metaclass to allocate objects
+ * Here we assume that the caller will take ownership of the returned value
+ */
+template <typename T>
+struct ValueProviderImpl<T*, userType>
+{
+    T* operator()() {return classByType<T>().construct().template get<T*>();}
+};
+
+/*
+ * Helper structure to instanciate new values based on their type
+ */
+template <typename T>
+struct ValueProvider : ValueProviderImpl<T, camp_ext::ValueMapper<T>::type>
+{
+};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_DETAIL_VALUEPROVIDER_HPP
diff --git a/include/camp/detail/yesnotype.hpp b/include/camp/detail/yesnotype.hpp
new file mode 100644
index 0000000..a5273cb
--- /dev/null
+++ b/include/camp/detail/yesnotype.hpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_YESNOTYPE_HPP
+#define CAMP_YESNOTYPE_HPP
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Defines a "yes" type to be used in metaprograms
+ *
+ * To work, sizeof(TypeYes) must be different than sizeof(TypeNo)
+ */
+typedef char TypeYes;
+
+/**
+ * \brief Defines a "no" type to be used in metaprograms
+ *
+ * To work, sizeof(TypeNo) must be different than sizeof(TypeYes)
+ */
+struct TypeNo {char padding[8];};
+
+} // namespace detail
+
+} // namespace camp
+
+
+#endif // CAMP_YESNOTYPE_HPP
diff --git a/include/camp/enum.hpp b/include/camp/enum.hpp
new file mode 100644
index 0000000..f5d1c22
--- /dev/null
+++ b/include/camp/enum.hpp
@@ -0,0 +1,230 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ENUM_HPP
+#define CAMP_ENUM_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/enumbuilder.hpp>
+#include <camp/enumget.hpp>
+#include <camp/detail/enummanager.hpp>
+#include <camp/detail/typeid.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <string>
+
+
+namespace bm = boost::multi_index;
+
+namespace camp
+{
+/**
+ * \brief camp::Enum represents a metaenum composed of <name, value> pairs
+ *
+ * Enums are declared, bound to a C++ type and filled with the \c declare
+ * template function.
+ *
+ * \code
+ * enum MyEnum {one = 1, two = 2, ten = 10};
+ *
+ * camp::Enum::declare<MyEnum>("MyEnum")
+ *     .value("one", one)
+ *     .value("two", two)
+ *     .value("ten", ten);
+ * \endcode
+ *
+ * It then provides a set of accessors to retrieve names, values and pairs contained in it.
+ *
+ * \code
+ * const camp::Enum& metaenum = camp::enumByType<MyEnum>();
+ *
+ * bool b1 = metaenum.hasName("one");     // b1 == true
+ * bool b2 = metaenum.hasValue(5);        // b2 == false
+ *
+ * std::string s = metaenum.name(10);     // s == "ten"
+ * long l = metaenum.value("two");        // l == 2
+ *
+ * camp::Enum::Pair p = metaenum.pair(0); // p == {"one", one}
+ * \endcode
+ *
+ * \remark All values and names are unique within the metaenum.
+ *
+ * \sa Class, EnumBuilder
+ */
+class CAMP_API Enum : boost::noncopyable
+{
+public:
+
+    /**
+     * \brief Structure defining the <name, value> pairs stored in metaenums
+     */
+    struct Pair
+    {
+        std::string name; ///< Name of the pair
+        long value; ///< Value of the pair
+    };
+
+public:
+
+    /**
+     * \brief Declare a new metaenum
+     *
+     * This is the function to call to create a new metaenum. The template
+     * parameter T is the C++ enum type that will be bound to the metaclass.
+     *
+     * \param name Name of the metaenum in CAMP. This name identifies
+     *             the metaenum and thus has to be unique
+     *
+     * \return A EnumBuilder object that will provide functions
+     *         to fill the new metaenum with values.
+     */
+    template <typename T>
+    static EnumBuilder declare(const std::string& name);
+
+public:
+
+    /**
+     * \brief Return the name of the metaenum
+     *
+     * \return String containing the name of the metaenum
+     */
+    const std::string& name() const;
+
+    /**
+     * \brief Return the size of the metaenum
+     *
+     * \return Total number of values contained in the metaenum
+     */
+    std::size_t size() const;
+
+    /**
+     * \brief Get a pair by its index
+     *
+     * \param index Index of the pair to get
+     *
+     * \return index-th pair
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Pair& pair(std::size_t index) const;
+
+    /**
+     * \brief Check if the enum contains a name
+     *
+     * \param name Name to check
+     *
+     * \return True if the metaenum contains a pair whose name is \a name
+     */
+    bool hasName(const std::string& name) const;
+
+    /**
+     * \brief Check if the enum contains a value
+     *
+     * \param value Value to check
+     *
+     * \return True if the metaenum contains a pair whose value is \a value
+     */
+    bool hasValue(long value) const;
+
+    /**
+     * \brief Return the name corresponding to given a value
+     *
+     * \param value Value to get
+     *
+     * \return Name of the requested value
+     *
+     * \throw InvalidEnumValue value doesn't exist in the metaenum
+     */
+    const std::string& name(long value) const;
+
+    /**
+     * \brief Return the value corresponding to given a name
+     *
+     * \param name Name to get
+     *
+     * \return Value of the requested name
+     *
+     * \throw InvalidEnumName name doesn't exist in the metaenum
+     */
+    long value(const std::string& name) const;
+
+    /**
+     * \brief Operator == to check equality between two metaenums
+     *
+     * Two metaenums are equal if their name is the same.
+     *
+     * \param other Metaenum to compare with this
+     *
+     * \return True if both metaenums are the same, false otherwise
+     */
+    bool operator==(const Enum& other) const;
+
+    /**
+     * \brief Operator != to check inequality between two metaenums
+     *
+     * \param other Metaenum to compare with this
+     *
+     * \return True if metaenums are different, false if they are equal
+     */
+    bool operator!=(const Enum& other) const;
+
+private:
+
+    friend class EnumBuilder;
+    friend class detail::EnumManager;
+
+    /**
+     * \brief Construct the metaenum from its name
+     *
+     * \param name Name of the metaenum
+     */
+    Enum(const std::string& name);
+
+    struct Id;
+    struct Val;
+    struct Name;
+
+    typedef boost::multi_index_container<Pair,
+        bm::indexed_by<bm::random_access<bm::tag<Id> >,
+                       bm::ordered_unique<bm::tag<Val>, bm::member<Pair, long, &Pair::value> >,
+                       bm::ordered_unique<bm::tag<Name>, bm::member<Pair, std::string, &Pair::name> >
+        >
+    > PairTable;
+
+    typedef PairTable::index<Val>::type ValueIndex;
+    typedef PairTable::index<Name>::type NameIndex;
+
+    std::string m_name; ///< Name of the metaenum
+    PairTable m_pairs; ///< Table of pairs, indexed by their value and name
+};
+
+} // namespace camp
+
+#include <camp/enum.inl>
+
+
+#endif // CAMP_ENUM_HPP
diff --git a/include/camp/enum.inl b/include/camp/enum.inl
new file mode 100644
index 0000000..e2f2c51
--- /dev/null
+++ b/include/camp/enum.inl
@@ -0,0 +1,34 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+EnumBuilder Enum::declare(const std::string& name)
+{
+    Enum& newEnum = detail::EnumManager::instance().addClass(name, detail::StaticTypeId<T>::get(false));
+    return EnumBuilder(newEnum);
+}
+
+} // namespace camp
diff --git a/include/camp/enumbuilder.hpp b/include/camp/enumbuilder.hpp
new file mode 100644
index 0000000..12978c5
--- /dev/null
+++ b/include/camp/enumbuilder.hpp
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ENUMBUILDER_HPP
+#define CAMP_ENUMBUILDER_HPP
+
+
+#include <camp/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <string>
+
+
+namespace camp
+{
+class Enum;
+
+/**
+ * \brief Proxy class which fills a metaenum with its members
+ *
+ * This class is returned by Enum::declare<T> in order construct a
+ * new metaenum. It contains functions to declare <name, value> pairs to
+ * fill the metaenum.
+ *
+ * This class should never be explicitely instanciated, unless you
+ * need to split the metaenum creation in multiple parts.
+ */
+class CAMP_API EnumBuilder
+{
+public:
+
+    /**
+     * \brief Construct the builder with a target metaenum
+     *
+     * \param target Target metaenum to construct
+     */
+    EnumBuilder(Enum& target);
+
+    /**
+     * \brief Add a new pair to the metaenum
+     *
+     * \param name Name of the pair
+     * \param value Value of the pair
+     */
+    EnumBuilder& value(const std::string& name, long value);
+
+private:
+
+    Enum* m_target; ///< Target metaenum to construct
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ENUMBUILDER_HPP
diff --git a/include/camp/enumget.hpp b/include/camp/enumget.hpp
new file mode 100644
index 0000000..437c326
--- /dev/null
+++ b/include/camp/enumget.hpp
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ENUMGET_HPP
+#define CAMP_ENUMGET_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/error.hpp>
+#include <camp/detail/typeid.hpp>
+#include <camp/detail/enummanager.hpp>
+#include <string>
+
+
+namespace camp
+{
+/**
+ * \relates Enum
+ *
+ * \brief Get the total number of existing metaenums
+ *
+ * \return Global metaenum count
+ */
+std::size_t enumCount();
+
+/**
+ * \relates Enum
+ *
+ * \brief Get a metaenum from its global index
+ *
+ * The purpose of this function is to provide a way to iterate through
+ * all existing metaenums. \sa enumCount
+ *
+ * \param index Index of the metaenum to get
+ *
+ * \return Reference to the index-th metaenum
+ *
+ * \throw OutOfRange index is out of range
+ */
+const Enum& enumByIndex(std::size_t index);
+
+/**
+ * \relates Enum
+ *
+ * \brief Get a metaenum from its name
+ *
+ * \param name Name of the metaenum to retrieve (case sensitive)
+ *
+ * \return Reference to the requested metaenum
+ *
+ * \throw EnumNotFound name is not a valid metaenum name
+ */
+const Enum& enumByName(const std::string& name);
+
+/**
+ * \relates Enum
+ *
+ * \brief Get a metaenum from a C++ object
+ *
+ * It is equivalent to calling enumByType<T>(index).
+ *
+ * \param value Value to get the metaenum of
+ *
+ * \return Reference to the metaenum bound to type T
+ *
+ * \throw EnumNotFound no metaenum has been declared for T
+ */
+template <typename T>
+const Enum& enumByObject(T value);
+
+/**
+ * \relates Enum
+ *
+ * \brief Get a metaenum from its C++ type
+ *
+ * \return Reference to the metaenum bound to type T
+ *
+ * \throw EnumNotFound no metaenum has been declared for T
+ */
+template <typename T>
+const Enum& enumByType();
+
+/**
+ * \relates Enum
+ *
+ * \brief Get a metaenum from its C++ type
+ *
+ * \return Pointer to the metaenum bound to type T, or 0 if no metaenum has been declared
+ */
+template <typename T>
+const Enum* enumByTypeSafe();
+
+} // namespace camp
+
+#include <camp/enumget.inl>
+
+
+#endif // CAMP_ENUMGET_HPP
diff --git a/include/camp/enumget.inl b/include/camp/enumget.inl
new file mode 100644
index 0000000..6bfe285
--- /dev/null
+++ b/include/camp/enumget.inl
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+inline std::size_t enumCount()
+{
+    return detail::EnumManager::instance().count();
+}
+
+//-------------------------------------------------------------------------------------------------
+inline const Enum& enumByIndex(std::size_t index)
+{
+    return detail::EnumManager::instance().getByIndex(index);
+}
+
+//-------------------------------------------------------------------------------------------------
+inline const Enum& enumByName(const std::string& name)
+{
+    return detail::EnumManager::instance().getByName(name);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Enum& enumByObject(T)
+{
+    return detail::EnumManager::instance().getById(detail::typeId<T>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Enum& enumByType()
+{
+    return detail::EnumManager::instance().getById(detail::typeId<T>());
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+const Enum* enumByTypeSafe()
+{
+    return detail::EnumManager::instance().getByIdSafe(detail::safeTypeId<T>());
+}
+
+} // namespace camp
diff --git a/include/camp/enumobject.hpp b/include/camp/enumobject.hpp
new file mode 100644
index 0000000..fd2f60f
--- /dev/null
+++ b/include/camp/enumobject.hpp
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ENUMOBJECT_HPP
+#define CAMP_ENUMOBJECT_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/enumget.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/operators.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <string>
+
+
+namespace camp
+{
+/**
+ * \brief Wrapper to manipulate enumerated values in the CAMP system
+ *
+ * camp::EnumObject is an abstract representation of enum values, and supports
+ * conversions from strings and integers.
+ *
+ * \sa UserObject
+ */
+class CAMP_API EnumObject : boost::totally_ordered<EnumObject>
+{
+public:
+
+    /**
+     * \brief Construct the enum object from an enumerated value
+     *
+     * \param value Value to store in the enum object
+     */
+    template <typename T>
+    EnumObject(T value, typename boost::enable_if<boost::is_enum<T> >::type* = 0);
+
+    /**
+     * \brief Get the value of the enum object
+     *
+     * \return Integer value of the enum object
+     */
+    long value() const;
+
+    /**
+     * \brief Get the name of the enum object
+     *
+     * \return String containing the name of the enum object
+     */
+    const std::string& name() const;
+
+    /**
+     * \brief Retrieve the metaenum of the stored enum object
+     *
+     * \return Reference to the object's metaenum
+     */
+    const Enum& getEnum() const;
+
+    /**
+     * \brief Operator == to compare equality between two enum objects
+     *
+     * Two enum objects are equal if their metaenums and values are both equal
+     *
+     * \param other Enum object to compare with this
+     *
+     * \return True if both enum objects are the same, false otherwise
+     */
+    bool operator==(const EnumObject& other) const;
+
+    /**
+     * \brief Operator < to compare two enum objects
+     *
+     * \param other Enum object to compare with this
+     *
+     * \return True if this < other
+     */
+    bool operator<(const EnumObject& other) const;
+
+private:
+
+    long m_value; ///< Value
+    const Enum* m_enum; ///< Metaenum associated to the value
+};
+
+} // namespace camp
+
+#include <camp/enumobject.inl>
+
+
+#endif // CAMP_ENUMOBJECT_HPP
diff --git a/include/camp/enumobject.inl b/include/camp/enumobject.inl
new file mode 100644
index 0000000..23d60ff
--- /dev/null
+++ b/include/camp/enumobject.inl
@@ -0,0 +1,34 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+EnumObject::EnumObject(T value, typename boost::enable_if<boost::is_enum<T> >::type*)
+    : m_value(value)
+    , m_enum(&enumByType<T>())
+{
+}
+
+} // namespace camp
diff --git a/include/camp/enumproperty.hpp b/include/camp/enumproperty.hpp
new file mode 100644
index 0000000..cc8603e
--- /dev/null
+++ b/include/camp/enumproperty.hpp
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ENUMPROPERTY_HPP
+#define CAMP_ENUMPROPERTY_HPP
+
+
+#include <camp/property.hpp>
+
+
+namespace camp
+{
+class Enum;
+
+/**
+ * \brief Specialized type of property for enums
+ *
+ */
+class CAMP_API EnumProperty : public Property
+{
+public:
+
+    /**
+     * \brief Construct the property from its description
+     *
+     * \param name Name of the property
+     * \param propEnum Eumeration the property is bound to
+     */
+    EnumProperty(const std::string& name, const Enum& propEnum);
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~EnumProperty();
+
+    /**
+     * \brief Get the owner enum
+     *
+     * \return Enum the property is bound to
+     */
+    const Enum& getEnum() const;
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+
+private:
+
+    const Enum* m_enum; ///< Owner enum of the property
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ENUMPROPERTY_HPP
diff --git a/include/camp/error.hpp b/include/camp/error.hpp
new file mode 100644
index 0000000..4827299
--- /dev/null
+++ b/include/camp/error.hpp
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ERROR_HPP
+#define CAMP_ERROR_HPP
+
+
+#include <camp/config.hpp>
+#include <boost/current_function.hpp>
+#include <boost/lexical_cast.hpp>
+#include <exception>
+#include <string>
+
+
+namespace camp
+{
+/**
+ * \brief Base class for every exception thrown in CAMP
+ */
+class CAMP_API Error : public std::exception
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~Error() throw();
+
+    /**
+     * \brief Return a description of the error
+     *
+     * \return Pointer to a string containing the error message
+     */
+    virtual const char* what() const throw();
+
+    /**
+     * \brief Return the error location (file + line + function)
+     *
+     * \return String containing the error location
+     */
+    virtual const char* where() const throw();
+
+    /**
+     * \brief Prepare an error to be thrown
+     *
+     * This function is meant for internal use only. It adds
+     * the current context of execution (file, line and function)
+     * to the given error and returns it.
+     *
+     * \param error Error to prepare
+     * \param file Source filename
+     * \param line Line number in the source file
+     * \param function Name of the function where the error was thrown
+     *
+     * \return Modified error, ready to be thrown
+     */
+    template <typename T>
+    static T prepare(T error, const std::string& file, int line, const std::string& function);
+
+protected:
+
+    /**
+     * \brief Default constructor
+     *
+     * \param message Error message to return in what()
+     */
+    Error(const std::string& message);
+
+    /**
+     * \brief Helper function to convert anything to a string
+     *
+     * This is a convenience function provided to help derived
+     * classes to easily build their full message
+     *
+     * \param x Value to convert
+     *
+     * \return \a x converted to a string
+     */
+    template <typename T>
+    static std::string str(T x);
+
+private:
+
+    std::string m_message; ///< Error message
+    std::string m_location; ///< Location of the error (file, line and function)
+};
+
+} // namespace camp
+
+#include <camp/error.inl>
+
+/**
+ * \brief Trigger a CAMP error
+ */
+#define CAMP_ERROR(error) throw camp::Error::prepare(error, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
+
+
+#endif // CAMP_ERROR_HPP
diff --git a/include/camp/error.inl b/include/camp/error.inl
new file mode 100644
index 0000000..5de9d29
--- /dev/null
+++ b/include/camp/error.inl
@@ -0,0 +1,41 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+T Error::prepare(T error, const std::string& file, int line, const std::string& function)
+{
+    error.m_location = file + " (" + str(line) + " ) - " + function;
+    return error;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+std::string Error::str(T value)
+{
+    return boost::lexical_cast<std::string>(value);
+}
+
+} // namespace camp
diff --git a/include/camp/errors.hpp b/include/camp/errors.hpp
new file mode 100644
index 0000000..47e30ff
--- /dev/null
+++ b/include/camp/errors.hpp
@@ -0,0 +1,326 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_ERRORS_HPP
+#define CAMP_ERRORS_HPP
+
+
+#include <camp/error.hpp>
+#include <camp/type.hpp>
+
+
+namespace camp
+{
+class Class;
+
+/**
+ * \brief Error thrown when providing a metavalue whose type is incompatible with what's expected
+ */
+class CAMP_API BadType : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param provided Provided type
+     * \param expected Expected type
+     */
+    BadType(Type provided, Type expected);
+
+protected:
+
+    /**
+     * \brief Constructor for derived classes
+     *
+     * \param message Description of the error
+     */
+    BadType(const std::string& message);
+
+    /**
+     * \brief Get the string name of a CAMP type
+     *
+     * \param type Type to convert
+     *
+     * \return Name of the provided type
+     */
+    static std::string typeName(Type type);
+};
+
+/**
+ * \brief Error thrown when providing a function argument which is incompatible with what the function expects
+ */
+class CAMP_API BadArgument : public BadType
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param provided Provided type
+     * \param expected Expected type
+     * \param index Index of the argument in the function prototype
+     * \param functionName Name of the function
+     */
+    BadArgument(Type provided, Type expected, std::size_t index, const std::string& functionName);
+};
+
+/**
+ * \brief Error thrown when a declaring a metaclass that already exists
+ */
+class CAMP_API ClassAlreadyCreated : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the class
+     * \param type Identifier of the C++ type
+     */
+    ClassAlreadyCreated(const std::string& name, const std::string& type);
+};
+
+/**
+ * \brief Error thrown when a metaclass couldn't be found (either by its name or its id)
+ */
+class CAMP_API ClassNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the requested class
+     */
+    ClassNotFound(const std::string& name);
+};
+
+/**
+ * \brief Error thrown when trying to convert an object to a class that is not a base nor a derived
+ */
+class CAMP_API ClassUnrelated : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param sourceClass Name of the source class
+     * \param requestedClass Name of the requested class
+     */
+    ClassUnrelated(const std::string& sourceClass, const std::string& requestedClass);
+};
+
+/**
+ * \brief Error thrown when a declaring a metaenum that already exists
+ */
+class CAMP_API EnumAlreadyCreated : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the enum
+     * \param type Identifier of the C++ type
+     */
+    EnumAlreadyCreated(const std::string& name, const std::string& type);
+};
+
+/**
+ * \brief Error thrown when the value of a metaenum couldn't be found by its name
+ */
+class CAMP_API EnumNameNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the requested metaenum member
+     * \param enumName Name of the owner metaenum
+     */
+    EnumNameNotFound(const std::string& name, const std::string& enumName);
+};
+
+/**
+ * \brief Error thrown when a metaenum couldn't be found (either by its name or its id)
+ */
+class CAMP_API EnumNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the requested enum
+     */
+    EnumNotFound(const std::string& name);
+};
+
+/**
+ * \brief Error thrown when a value in a metaenum couldn't be found
+ */
+class CAMP_API EnumValueNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param value Value of the requested metaenum member
+     * \param enumName Name of the owner metaenum
+     */
+    EnumValueNotFound(long value, const std::string& enumName);
+};
+
+/**
+ * \brief Error thrown when calling a function that is not callable
+ */
+class CAMP_API ForbiddenCall : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param functionName Name of the function
+     */
+    ForbiddenCall(const std::string& functionName);
+};
+
+/**
+ * \brief Error thrown when trying to read a property that is not readable
+ */
+class CAMP_API ForbiddenRead : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param propertyName Name of the property
+     */
+    ForbiddenRead(const std::string& propertyName);
+};
+
+/**
+ * \brief Error thrown when trying to write a function that is not writable
+ */
+class CAMP_API ForbiddenWrite : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param propertyName Name of the property
+     */
+    ForbiddenWrite(const std::string& propertyName);
+};
+
+/**
+ * \brief Error thrown when a function can't be found in a metaclass (by its name)
+ */
+class CAMP_API FunctionNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the requested function
+     * \param className Name of the owner metaclass
+     */
+    FunctionNotFound(const std::string& name, const std::string& className);
+};
+
+/**
+ * \brief Error thrown when a declaring a metaclass that already exists
+ */
+class CAMP_API NotEnoughArguments : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param functionName Name of the function
+     * \param provided Number of arguments provided
+     * \param expected Number of arguments expected
+     */
+    NotEnoughArguments(const std::string& functionName, std::size_t provided, std::size_t expected);
+};
+
+/**
+ * \brief Error thrown when trying to use an empty metaobject
+ */
+class CAMP_API NullObject : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param objectClass Metaclass of the object (may be null if object has no class)
+     */
+    NullObject(const Class* objectClass);
+};
+
+/**
+ * \brief Error thrown when using an index which is out of bounds
+ */
+class CAMP_API OutOfRange : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param index Invalid index
+     * \param size Allowed size
+     */
+    OutOfRange(std::size_t index, std::size_t size);
+};
+
+/**
+ * \brief Error thrown when a property can't be found in a metaclass (by its name)
+ */
+class CAMP_API PropertyNotFound : public Error
+{
+public:
+
+    /**
+     * \brief Constructor
+     *
+     * \param name Name of the requested property
+     * \param className Name of the owner metaclass
+     */
+    PropertyNotFound(const std::string& name, const std::string& className);
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ERRORS_HPP
diff --git a/include/camp/function.hpp b/include/camp/function.hpp
new file mode 100644
index 0000000..8dcb35e
--- /dev/null
+++ b/include/camp/function.hpp
@@ -0,0 +1,165 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_FUNCTION_HPP
+#define CAMP_FUNCTION_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/getter.hpp>
+#include <camp/args.hpp>
+#include <camp/tagholder.hpp>
+#include <camp/type.hpp>
+#include <camp/value.hpp>
+#include <string>
+#include <vector>
+
+
+namespace camp
+{
+template <typename T> class ClassBuilder;
+class UserObject;
+class ClassVisitor;
+
+/**
+ * \brief Abstract representation of a function
+ *
+ * Functions are members of metaclasses. Their main purpose is to be called; they also provide
+ * detailed informations about their prototype.
+ */
+class CAMP_API Function : public TagHolder
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~Function();
+
+    /**
+     * \brief Get the name of the function
+     *
+     * \return Name of the function
+     */
+    const std::string& name() const;
+
+    /**
+     * \brief Get the number of arguments of the function
+     *
+     * \return Total number of arguments taken by the function
+     */
+    std::size_t argCount() const;
+
+    /**
+     * \brief Get the type of variable returned by the function
+     *
+     * \return Type of the result of the function
+     */
+    Type returnType() const;
+
+    /**
+     * \brief Get the type of an argument given by its index
+     *
+     * \param index Index of the argument
+     *
+     * \return Type of the index-th argument
+     *
+     * \throw OutOfRange index is out of range
+     */
+    Type argType(std::size_t index) const;
+
+    /**
+     * \brief Check if the function is currently callable for a given object
+     *
+     * \param object Object
+     *
+     * \return True if the function can be called, false otherwise
+     *
+     * \throw NullObject object is invalid
+     */
+    bool callable(const UserObject& object) const;
+
+    /**
+     * \brief Call the function
+     *
+     * \param object Object
+     * \param args Arguments to pass to the function (empty list by default)
+     *
+     * \return Value returned by the function call
+     *
+     * \throw ForbiddenCall the function is not callable
+     * \throw NullObject object is invalid
+     * \throw NotEnoughArguments too few arguments are provided
+     * \throw BadArgument one of the arguments can't be converted to the requested type
+     */
+    Value call(const UserObject& object, const Args& args = Args::empty) const;
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+
+protected:
+
+    template <typename T> friend class ClassBuilder;
+
+    /**
+     * \brief Construct the function from its description
+     *
+     * \param name Name of the function
+     * \param returnType Type of the function result
+     * \param argTypes Types of the function arguments (empty array by default)
+     *
+     * \return Value returned by the function call
+     */
+    Function(const std::string& name, Type returnType, const std::vector<Type>& argTypes = std::vector<Type>());
+
+    /**
+     * \brief Do the actual call
+     *
+     * This function is a pure virtual which has to be implemented in derived classes.
+     *
+     * \param object Object
+     * \param args Arguments to pass to the function
+     *
+     * \return Value returned by the function call
+     *
+     * \throw NullObject object is invalid
+     * \throw BadArgument one of the arguments can't be converted to the requested type
+     */
+    virtual Value execute(const UserObject& object, const Args& args) const = 0;
+
+private:
+
+    std::string m_name; ///< Name of the function
+    Type m_returnType; ///< Return type
+    std::vector<Type> m_argTypes; ///< Type of all the function arguments
+    detail::Getter<bool> m_callable; ///< Accessor to get the callable state of the function
+};
+
+} // namespace camp
+
+
+#endif // CAMP_FUNCTION_HPP
diff --git a/include/camp/observer.hpp b/include/camp/observer.hpp
new file mode 100644
index 0000000..53a7bb8
--- /dev/null
+++ b/include/camp/observer.hpp
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_OBSERVER_HPP
+#define CAMP_OBSERVER_HPP
+
+
+#include <camp/config.hpp>
+
+
+namespace camp
+{
+class Class;
+class Enum;
+
+/**
+ * \brief Receives notification about creation / destruction of metaclasses and metaenums
+ *
+ * This class is a base class which must be derived in order to create custom observers.
+ * None of the virtual functions is pure, so you can only override the one you're interested in.
+ *
+ * \sa Class, Enum
+ */
+class CAMP_API Observer
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~Observer();
+
+    /**
+     * \brief Functon called when a new metaclass is created
+     *
+     * \param added Metaclass that have been added
+     */
+    virtual void classAdded(const Class& added);
+
+    /**
+     * \brief Functon called when an existing metaclass is destroyed
+     *
+     * \param removed Metaclass that have been destroyed
+     */
+    virtual void classRemoved(const Class& removed);
+
+    /**
+     * \brief Functon called when a new metaenum is created
+     *
+     * \param added Metaenum that have been added
+     */
+    virtual void enumAdded(const Enum& added);
+
+    /**
+     * \brief Functon called when an existing metaenum is destroyed
+     *
+     * \param removed Metaenum that have been destroyed
+     */
+    virtual void enumRemoved(const Enum& removed);
+
+protected:
+
+    /**
+     * \brief Default constructor
+     */
+    Observer();
+};
+
+/**
+ * \brief Register an observer
+ *
+ * \param observer Pointer to the observer instance to register
+ */
+CAMP_API void addObserver(Observer* observer);
+
+/**
+ * \brief Unregister an observer
+ *
+ * \param observer Pointer to the observer instance to unregister
+ */
+CAMP_API void removeObserver(Observer* observer);
+
+} // namespace camp
+
+
+#endif // CAMP_OBSERVER_HPP
diff --git a/include/camp/property.hpp b/include/camp/property.hpp
new file mode 100644
index 0000000..e921588
--- /dev/null
+++ b/include/camp/property.hpp
@@ -0,0 +1,185 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_PROPERTY_HPP
+#define CAMP_PROPERTY_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/getter.hpp>
+#include <camp/tagholder.hpp>
+#include <camp/type.hpp>
+#include <string>
+
+
+namespace camp
+{
+template <typename T> class ClassBuilder;
+class Value;
+class UserObject;
+class ClassVisitor;
+
+/**
+ * \brief Abstract representation of a property
+ *
+ * Properties are members of metaclasses. Their main purpose is to be get and/or set;
+ * They also provide detailed informations about their type.
+ *
+ * \sa PSimpleroperty, ArrayProperty, EnumProperty, ObjectProperty
+ */
+class CAMP_API Property : public TagHolder
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~Property();
+
+    /**
+     * \brief Get the name of the property
+     *
+     * \return Name of the property
+     */
+    const std::string& name() const;
+
+    /**
+     * \brief Get the type of the property
+     *
+     * \return Type of the property
+     */
+    Type type() const;
+
+    /**
+     * \brief Check if the property is currently readable for a given object
+     *
+     * \param object Object
+     *
+     * \return True if the property can be read, false otherwise
+     *
+     * \throw NullObject object is invalid
+     */
+    bool readable(const UserObject& object) const;
+
+    /**
+     * \brief Check if the property is currently writable for a given object
+     *
+     * \param object Object
+     *
+     * \return True if the property can be written, false otherwise
+     *
+     * \throw NullObject object is invalid
+     */
+    bool writable(const UserObject& object) const;
+
+    /**
+     * \brief Get the current value of the property for a given object
+     *
+     * \param object Object
+     *
+     * \return Value of the property
+     *
+     * \throw NullObject object is invalid
+     * \throw ForbiddenRead property is not readable
+     */
+    Value get(const UserObject& object) const;
+
+    /**
+     * \brief Set the current value of the property for a given object
+     *
+     * \param object Object
+     * \param value New value to assign to the property
+     *
+     * \throw NullObject \a object is invalid
+     * \throw ForbiddenWrite property is not writable
+     * \throw BadType \a value can't be converted to the property's type
+     */
+    void set(const UserObject& object, const Value& value) const;
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+
+protected:
+
+    template <typename T> friend class ClassBuilder;
+    friend class UserObject;
+
+    /**
+     * \brief Construct the property from its description
+     *
+     * \param name Name of the property
+     * \param type Type of the property
+     */
+    Property(const std::string& name, Type type);
+
+    /**
+     * \brief Do the actual reading of the value
+     *
+     * This function is a pure virtual which has to be implemented in derived classes.
+     *
+     * \param object Object
+     *
+     * \return Value of the property
+     */
+    virtual Value getValue(const UserObject& object) const = 0;
+
+    /**
+     * \brief Do the actual writing of the value
+     *
+     * This function is a pure virtual which has to be implemented in derived classes.
+     *
+     * \param object Object
+     * \param value New value to assign to the property
+     */
+    virtual void setValue(const UserObject& object, const Value& value) const = 0;
+
+    /**
+     * \brief Check if the property can be read
+     *
+     * \return True if the property can be read, false otherwise
+     */
+    virtual bool isReadable() const;
+
+    /**
+     * \brief Check if the property can be written
+     *
+     * \return True if the property can be written, false otherwise
+     */
+    virtual bool isWritable() const;
+
+private:
+
+    std::string m_name; ///< Name of the property
+    Type m_type; ///< Type of the property
+    detail::Getter<bool> m_readable; ///< Accessor to get the readable state of the property
+    detail::Getter<bool> m_writable; ///< Accessor to get the writable state of the property
+};
+
+} // namespace camp
+
+
+#endif // CAMP_PROPERTY_HPP
diff --git a/include/camp/qt/qlist.hpp b/include/camp/qt/qlist.hpp
new file mode 100644
index 0000000..a72f36a
--- /dev/null
+++ b/include/camp/qt/qlist.hpp
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QLIST_HPP
+#define CAMP_QT_QLIST_HPP
+
+
+#include <camp/arraymapper.hpp>
+#include <QList>
+
+
+namespace camp_ext
+{
+/*
+ * \brief Specialization of ArrayMapper for QList
+ */
+ template <typename T>
+ struct ArrayMapper<QList<T> >
+ {
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return true;
+    }
+
+    static std::size_t size(const QList<T>& arr)
+    {
+        return static_cast<std::size_t>(arr.size());
+    }
+
+    static const T& get(const QList<T>& arr, std::size_t index)
+    {
+        return arr[static_cast<int>(index)];
+    }
+
+    static void set(QList<T>& arr, std::size_t index, const T& value)
+    {
+        arr[static_cast<int>(index)] = value;
+    }
+
+    static void insert(QList<T>& arr, std::size_t before, const T& value)
+    {
+        arr.insert(static_cast<int>(before), value);
+    }
+
+    static void remove(QList<T>& arr, std::size_t index)
+    {
+        arr.removeAt(static_cast<int>(index));
+    }
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QLIST_HPP
diff --git a/include/camp/qt/qstring.hpp b/include/camp/qt/qstring.hpp
new file mode 100644
index 0000000..094ac42
--- /dev/null
+++ b/include/camp/qt/qstring.hpp
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QSTRING_HPP
+#define CAMP_QT_QSTRING_HPP
+
+
+#include <camp/valuemapper.hpp>
+#include <QString>
+#include <string>
+
+
+namespace camp_ext
+{
+/**
+ * \brief Value mapper for QString
+ *
+ * This class tells CAMP how to handle QString as a string type
+ */
+template <>
+struct ValueMapper<QString>
+{
+    /**
+     * \brief CAMP type associated to QString
+     */
+    static const int type = camp::stringType;
+
+    /**
+     * \brief Convert from QString to std::string
+     *
+     * \param source Source QString instance to convert
+     *
+     * \return \a source converted to a std::string
+     */
+    static std::string to(const QString& source)
+    {
+        return source.toStdString();
+    }
+
+    /**
+     * \brief Convert from any type to QString
+     *
+     * We simply reuse ValueMapper<std::string>.
+     *
+     * \param source Source value to convert
+     *
+     * \return \a source converted to a QString
+     */
+    template <typename T>
+    static QString from(const T& source)
+    {
+        return QString::fromStdString(ValueMapper<std::string>::from(source));
+    }
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QSTRING_HPP
diff --git a/include/camp/qt/qt.hpp b/include/camp/qt/qt.hpp
new file mode 100644
index 0000000..6756075
--- /dev/null
+++ b/include/camp/qt/qt.hpp
@@ -0,0 +1,42 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QT_HPP
+#define CAMP_QT_QT_HPP
+
+
+/**
+ * This file extends CAMP for the Qt library; it contains all the mappings needed to
+ * make Qt work seamlessly with CAMP:
+ * - QString is declared as a string type
+ * - QVector and QList are declared as array types
+ * - QMapper maps Qt properties to CAMP properties
+ */
+
+#include <camp/qt/qstring.hpp>
+#include <camp/qt/qvector.hpp>
+#include <camp/qt/qlist.hpp>
+#include <camp/qt/qtmapper.hpp>
+
+
+#endif // CAMP_QT_QT_HPP
diff --git a/include/camp/qt/qtfunction.hpp b/include/camp/qt/qtfunction.hpp
new file mode 100644
index 0000000..63d5319
--- /dev/null
+++ b/include/camp/qt/qtfunction.hpp
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QTFUNCTION_HPP
+#define CAMP_QT_QTFUNCTION_HPP
+
+
+#include <camp/qt/qthelper.hpp>
+#include <camp/function.hpp>
+#include <camp/userobject.hpp>
+#include <camp/value.hpp>
+#include <QMetaMethod>
+#include <QVariant>
+#include <QString>
+
+
+namespace camp_ext
+{
+/**
+ * \brief Specialization of camp::Function implemented using a Qt method
+ *
+ * This class is instanciated and returned by QtMapper<T>.
+ *
+ * \sa QtMapper
+ */
+template <typename T>
+class QtFunction : public camp::Function
+{
+public:
+
+    /**
+     * \brief Construct the function from a QMetaMethod
+     *
+     * \param metaMethod Qt meta method
+     */
+    QtFunction(const QMetaMethod& metaMethod)
+        : camp::Function(functionName(metaMethod), returnType(metaMethod), argTypes(metaMethod))
+        , m_metaMethod(metaMethod)
+    {
+    }
+
+    /**
+     * \see Function::execute
+     */
+    virtual camp::Value execute(const camp::UserObject& object, const camp::Args& args) const
+    {
+        QVariant value(QtHelper::variantType(QMetaType::type(m_metaMethod.typeName())));
+        QGenericReturnArgument ret(m_metaMethod.typeName(), value.data());
+
+        switch (args.count())
+        {
+            case 0:
+            {
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret);
+                break;
+            }
+
+            case 1:
+            {
+                QVariant arg1 = QtHelper::valueToVariant(args[0]);
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret
+                                  , QGenericArgument(arg1.typeName(), arg1.data()));
+                break;
+            }
+
+            case 2:
+            {
+                QVariant arg1 = QtHelper::valueToVariant(args[0]);
+                QVariant arg2 = QtHelper::valueToVariant(args[1]);
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret
+                                  , QGenericArgument(arg1.typeName(), arg1.data())
+                                  , QGenericArgument(arg2.typeName(), arg2.data()));
+                break;
+            }
+
+            case 3:
+            {
+                QVariant arg1 = QtHelper::valueToVariant(args[0]);
+                QVariant arg2 = QtHelper::valueToVariant(args[1]);
+                QVariant arg3 = QtHelper::valueToVariant(args[2]);
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret
+                                  , QGenericArgument(arg1.typeName(), arg1.data())
+                                  , QGenericArgument(arg2.typeName(), arg2.data())
+                                  , QGenericArgument(arg3.typeName(), arg3.data()));
+                break;
+            }
+
+            case 4:
+            {
+                QVariant arg1 = QtHelper::valueToVariant(args[0]);
+                QVariant arg2 = QtHelper::valueToVariant(args[1]);
+                QVariant arg3 = QtHelper::valueToVariant(args[2]);
+                QVariant arg4 = QtHelper::valueToVariant(args[3]);
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret
+                                  , QGenericArgument(arg1.typeName(), arg1.data())
+                                  , QGenericArgument(arg2.typeName(), arg2.data())
+                                  , QGenericArgument(arg3.typeName(), arg3.data())
+                                  , QGenericArgument(arg4.typeName(), arg4.data()));
+                break;
+            }
+
+            case 5:
+            {
+                QVariant arg1 = QtHelper::valueToVariant(args[0]);
+                QVariant arg2 = QtHelper::valueToVariant(args[1]);
+                QVariant arg3 = QtHelper::valueToVariant(args[2]);
+                QVariant arg4 = QtHelper::valueToVariant(args[3]);
+                QVariant arg5 = QtHelper::valueToVariant(args[4]);
+                m_metaMethod.invoke(object.get<T*>(), Qt::DirectConnection, ret
+                                  , QGenericArgument(arg1.typeName(), arg1.data())
+                                  , QGenericArgument(arg2.typeName(), arg2.data())
+                                  , QGenericArgument(arg3.typeName(), arg3.data())
+                                  , QGenericArgument(arg4.typeName(), arg4.data())
+                                  , QGenericArgument(arg5.typeName(), arg5.data()));
+                break;
+            }
+        }
+
+        return QtHelper::variantToValue(value);
+    }
+
+private:
+
+    /**
+     * \brief Extract the name of a meta method
+     *
+     * \param metaMethod Qt meta method
+     *
+     * \return Name of the meta method
+     */
+    static std::string functionName(const QMetaMethod& metaMethod)
+    {
+        QString signature = metaMethod.signature();
+        return signature.left(signature.indexOf('(')).toStdString();
+    }
+
+    /**
+     * \brief Extract the return type of a meta method
+     *
+     * \param metaMethod Qt meta method
+     *
+     * \return Return type of the meta method
+     */
+    static camp::Type returnType(const QMetaMethod& metaMethod)
+    {
+        return QtHelper::type(metaMethod.typeName());
+    }
+
+    /**
+     * \brief Extract the arguments types of a meta method
+     *
+     * \param metaMethod Qt meta method
+     *
+     * \return Arguments types of the meta method
+     */
+    static std::vector<camp::Type> argTypes(const QMetaMethod& metaMethod)
+    {
+        std::vector<camp::Type> types;
+
+        QList<QByteArray> args = metaMethod.parameterTypes();
+        Q_FOREACH(QByteArray arg, args)
+        {
+            types.push_back(QtHelper::type(arg));
+        }
+
+        return types;
+    }
+
+private:
+
+    QMetaMethod m_metaMethod; ///< Internal Qt method
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QTFUNCTION_HPP
diff --git a/include/camp/qt/qthelper.hpp b/include/camp/qt/qthelper.hpp
new file mode 100644
index 0000000..5a82809
--- /dev/null
+++ b/include/camp/qt/qthelper.hpp
@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QTHELPER_HPP
+#define CAMP_QT_QTHELPER_HPP
+
+
+#include <camp/value.hpp>
+#include <QVariant>
+
+
+namespace camp_ext
+{
+/**
+ * \brief Utility class to perform various conversions between CAMP and Qt
+ */
+class QtHelper
+{
+public:
+
+    /**
+     * \brief Extract the CAMP type of a Qt type in string form
+     *
+     * \param typeName Qt type
+     *
+     * \return Corresponding CAMP type
+     */
+    static camp::Type type(const char* typeName)
+    {
+        return type(variantType(QMetaType::type(typeName)));
+    }
+
+    /**
+     * \brief Convert a QVariant type to a CAMP type
+     *
+     * \param theType Source QVariant type to convert
+     *
+     * \return \a theType converted to a camp::Type
+     */
+    static camp::Type type(QVariant::Type theType)
+    {
+        // We add an extra conversion to QVariant::Type because variant.type() may return metatypes
+        // that do not exist in QVariant (such as QMetaType::Long which is considered a user type)
+        switch (variantType(theType))
+        {
+            case QVariant::Invalid:   return camp::noType;
+            case QVariant::Bool:      return camp::boolType;
+            case QVariant::Char:      return camp::intType;
+            case QVariant::Int:       return camp::intType;
+            case QVariant::LongLong:  return camp::intType;
+            case QVariant::UInt:      return camp::intType;
+            case QVariant::ULongLong: return camp::intType;
+            case QVariant::Double:    return camp::realType;
+            case QVariant::String:    return camp::stringType;
+            default:                  return camp::noType;
+        }
+    }
+
+    /**
+     * \brief Map a Qt metatype to a QVariant type
+     *
+     * \param metaType Source metatype to map
+     *
+     * \return \a type converted to a WVariant::Type
+     */
+    static QVariant::Type variantType(int metaType)
+    {
+        switch (metaType)
+        {
+            case QMetaType::Void:         return QVariant::Invalid;
+            case QMetaType::Bool:         return QVariant::Bool;
+            case QMetaType::Int:          return QVariant::Int;
+            case QMetaType::UInt:         return QVariant::UInt;
+            case QMetaType::Double:       return QVariant::Double;
+            case QMetaType::QChar:        return QVariant::Char;
+            case QMetaType::QString:      return QVariant::String;
+            case QMetaType::QByteArray:   return QVariant::ByteArray;
+            case QMetaType::VoidStar:     return QVariant::Invalid;
+            case QMetaType::Long:         return QVariant::Int;
+            case QMetaType::LongLong:     return QVariant::LongLong;
+            case QMetaType::Short:        return QVariant::Int;
+            case QMetaType::Char:         return QVariant::Char;
+            case QMetaType::ULong:        return QVariant::UInt;
+            case QMetaType::ULongLong:    return QVariant::ULongLong;
+            case QMetaType::UShort:       return QVariant::UInt;
+            case QMetaType::UChar:        return QVariant::Char;
+            case QMetaType::Float:        return QVariant::Double;
+            case QMetaType::QObjectStar:  return QVariant::UserType;
+            case QMetaType::QWidgetStar:  return QVariant::UserType;
+            case QMetaType::QCursor:      return QVariant::Cursor;
+            case QMetaType::QDate:        return QVariant::Date;
+            case QMetaType::QSize:        return QVariant::Size;
+            case QMetaType::QTime:        return QVariant::Time;
+            case QMetaType::QVariantList: return QVariant::UserType;
+            case QMetaType::QPolygon:     return QVariant::Polygon;
+            case QMetaType::QColor:       return QVariant::Color;
+            case QMetaType::QSizeF:       return QVariant::SizeF;
+            case QMetaType::QRectF:       return QVariant::RectF;
+            case QMetaType::QLine:        return QVariant::Line;
+            case QMetaType::QTextLength:  return QVariant::TextLength;
+            case QMetaType::QStringList:  return QVariant::StringList;
+            case QMetaType::QVariantMap:  return QVariant::UserType;
+            case QMetaType::QVariantHash: return QVariant::UserType;
+            case QMetaType::QIcon:        return QVariant::Icon;
+            case QMetaType::QPen:         return QVariant::Pen;
+            case QMetaType::QLineF:       return QVariant::LineF;
+            case QMetaType::QTextFormat:  return QVariant::TextFormat;
+            case QMetaType::QRect:        return QVariant::Rect;
+            case QMetaType::QPoint:       return QVariant::Point;
+            case QMetaType::QUrl:         return QVariant::Url;
+            case QMetaType::QRegExp:      return QVariant::RegExp;
+            case QMetaType::QDateTime:    return QVariant::DateTime;
+            case QMetaType::QPointF:      return QVariant::UserType;
+            case QMetaType::QPalette:     return QVariant::Palette;
+            case QMetaType::QFont:        return QVariant::Font;
+            case QMetaType::QBrush:       return QVariant::Brush;
+            case QMetaType::QRegion:      return QVariant::Region;
+            case QMetaType::QBitArray:    return QVariant::BitArray;
+            case QMetaType::QImage:       return QVariant::Image;
+            case QMetaType::QKeySequence: return QVariant::KeySequence;
+            case QMetaType::QSizePolicy:  return QVariant::SizePolicy;
+            case QMetaType::QPixmap:      return QVariant::Pixmap;
+            case QMetaType::QLocale:      return QVariant::Locale;
+            case QMetaType::QBitmap:      return QVariant::Bitmap;
+            case QMetaType::QMatrix:      return QVariant::Matrix;
+            case QMetaType::QTransform:   return QVariant::Transform;
+            case QMetaType::User:         return QVariant::UserType;
+            default:                      return QVariant::UserType;
+        }
+    }
+
+    /**
+     * \brief Convert a CAMP value to a QVariant
+     *
+     * \param value Source camp::Value to convert
+     *
+     * \return \a value converted to a QVariant
+     */
+    static QVariant valueToVariant(const camp::Value& value)
+    {
+        switch (value.type())
+        {
+            default:
+            case camp::noType:     return QVariant();
+            case camp::boolType:   return QVariant(value.to<bool>());
+            case camp::intType:    return QVariant(value.to<int>());
+            case camp::realType:   return QVariant(value.to<double>());
+            case camp::stringType: return QVariant(value.to<QString>());
+            case camp::enumType:   return QVariant(value.to<int>());
+            case camp::userType:   return QVariant();
+        }
+    }
+
+    /**
+     * \brief Convert a QVariant to a CAMP value
+     *
+     * \param variant Source QVariant to convert
+     *
+     * \return \a variant converted to a camp::Value
+     */
+    static camp::Value variantToValue(const QVariant& variant)
+    {
+        // We add an extra conversion to QVariant::Type because variant.type() may return metatypes
+        // that do not exist in QVariant (such as QMetaType::Long which is considered a user type)
+        switch (variantType(variant.type()))
+        {
+            default:
+            case QVariant::Invalid:   return camp::Value();
+            case QVariant::Bool:      return camp::Value(variant.toBool());
+            case QVariant::Char:      return camp::Value(variant.toInt());
+            case QVariant::Int:       return camp::Value(variant.toInt());
+            case QVariant::LongLong:  return camp::Value(variant.toLongLong());
+            case QVariant::UInt:      return camp::Value(variant.toUInt());
+            case QVariant::ULongLong: return camp::Value(variant.toULongLong());
+            case QVariant::Double:    return camp::Value(variant.toDouble());
+            case QVariant::String:    return camp::Value(variant.toString());
+        }
+    }
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QTHELPER_HPP
diff --git a/include/camp/qt/qtmapper.hpp b/include/camp/qt/qtmapper.hpp
new file mode 100644
index 0000000..712d65c
--- /dev/null
+++ b/include/camp/qt/qtmapper.hpp
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QTMAPPER_HPP
+#define CAMP_QT_QTMAPPER_HPP
+
+
+#include <camp/qt/qtsimpleproperty.hpp>
+#include <camp/qt/qtfunction.hpp>
+#include <camp/function.hpp>
+#include <QMetaObject>
+#include <QMetaMethod>
+
+
+namespace camp_ext
+{
+/**
+ * \brief Mapper for Qt properties
+ *
+ * This class tells CAMP how to build metaproperties and metafunctions from Qt's metatypes.
+ *
+ * This mapper is not complete due to some limitations of either CAMP or Qt:
+ * \li enum properties are not mapped using camp::EnumProperty, but camp::SimpleProperty
+ * \li arrays and user defined classes are not supported for meta-properties
+ * \li arrays, user defined enums and classes are not supported for meta-functions
+ */
+template <typename T>
+class QtMapper
+{
+public:
+
+    /**
+     * \brief Return the number of properties to map
+     *
+     * \return Number of properties
+     */
+    static std::size_t propertyCount()
+    {
+        int count = 0;
+        for (int i = 0; i < T::staticMetaObject.propertyCount(); ++i)
+        {
+            // Discard incompatible types
+            if (filter(T::staticMetaObject.property(i)))
+                count++;
+        }
+
+        return count;
+    }
+
+    /**
+     * \brief Map a property
+     *
+     * \param index Index of the property to map
+     *
+     * \return index-th property mapped to a camp::Property
+     */
+    static camp::Property* property(std::size_t index)
+    {
+        int prop = 0;
+        int count = 0;
+        for (prop = 0; count <= static_cast<int>(index); ++prop)
+        {
+            // Discard incompatible types
+            if (filter(T::staticMetaObject.property(prop)))
+                count++;
+        }
+
+        return new QtSimpleProperty<T>(T::staticMetaObject.property(prop - 1));
+    }
+
+    /**
+     * \brief Return the number of functions to map
+     *
+     * \return Number of functions
+     */
+    static std::size_t functionCount()
+    {
+        int count = 0;
+        for (int i = 0; i < T::staticMetaObject.methodCount(); ++i)
+        {
+            // Discard incompatible types
+            if (filter(T::staticMetaObject.method(i)))
+                count++;
+        }
+
+        return count;
+    }
+
+    /**
+     * \brief Map a function
+     *
+     * \param index Index of the function to map
+     *
+     * \return index-th function mapped to a camp::function
+     */
+    static camp::Function* function(std::size_t index)
+    {
+        int func = 0;
+        int count = 0;
+        for (func = 0; count <= static_cast<int>(index); ++func)
+        {
+            // Discard incompatible types
+            if (filter(T::staticMetaObject.method(func)))
+                count++;
+        }
+
+        return new QtFunction<T>(T::staticMetaObject.method(func - 1));
+    }
+
+private:
+
+    /**
+     * \brief Check if a property is mappable to CAMP
+     *
+     * \param property Property to check
+     *
+     * \return True if the property can be bound to CAMP
+     */
+    static bool filter(const QMetaProperty& property)
+    {
+        return QtHelper::type(property.type()) != camp::noType
+               || property.isEnumType();
+    }
+
+    /**
+     * \brief Check if a function is mappable to CAMP
+     *
+     * \param function Function to check
+     *
+     * \return True if the function can be bound to CAMP
+     */
+    static bool filter(const QMetaMethod& function)
+    {
+        // Check return type
+        if ((QtHelper::type(function.typeName()) == camp::noType)
+            && QMetaType::type(function.typeName()) != QMetaType::Void) // void maps to camp::noType but is a valid return type
+        {
+            return false;
+        }
+
+        // Check parameters types
+        QList<QByteArray> args = function.parameterTypes();
+        Q_FOREACH(QByteArray arg, args)
+        {
+            if (QtHelper::type(arg) == camp::noType)
+                return false;
+        }
+
+        return true;
+    }
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QTMAPPER_HPP
diff --git a/include/camp/qt/qtsimpleproperty.hpp b/include/camp/qt/qtsimpleproperty.hpp
new file mode 100644
index 0000000..0b36ebf
--- /dev/null
+++ b/include/camp/qt/qtsimpleproperty.hpp
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QTSIMPLEPROPERTY_HPP
+#define CAMP_QT_QTSIMPLEPROPERTY_HPP
+
+
+#include <camp/qt/qthelper.hpp>
+#include <camp/simpleproperty.hpp>
+#include <camp/userobject.hpp>
+#include <camp/value.hpp>
+#include <QMetaProperty>
+#include <QVariant>
+
+
+namespace camp_ext
+{
+/**
+ * \brief Specialization of camp::SimpleProperty implemented using a Qt property
+ *
+ * This class is instanciated and returned by QtMapper<T>.
+ *
+ * \sa QtMapper
+ */
+template <typename T>
+class QtSimpleProperty : public camp::SimpleProperty
+{
+public:
+
+    /**
+     * \brief Construct the property from a QMetaProperty
+     *
+     * \param metaProperty Qt meta property
+     */
+    QtSimpleProperty(const QMetaProperty& metaProperty)
+        : camp::SimpleProperty(metaProperty.name(), metaProperty.isEnumType() ? camp::enumType : QtHelper::type(metaProperty.type()))
+        , m_metaProperty(metaProperty)
+    {
+    }
+
+    /**
+     * \brief Get the value of the property for the given object
+     *
+     * \param object Object to read
+     *
+     * \return Current value of the property
+     */
+    virtual camp::Value getValue(const camp::UserObject& object) const
+    {
+        return QtHelper::variantToValue(m_metaProperty.read(object.get<T*>()));
+    }
+
+    /**
+     * \brief Set the value of the property for the given object
+     *
+     * \param object Object to write
+     * \param value New value of the property
+     */
+    virtual void setValue(const camp::UserObject& object, const camp::Value& value) const
+    {
+        m_metaProperty.write(object.get<T*>(), QtHelper::valueToVariant(value));
+    }
+
+    /**
+     * \brief Check if the property is readable
+     *
+     * \return True if the property is readable, false otherwise
+     */
+    virtual bool isReadable() const
+    {
+        return m_metaProperty.isReadable();
+    }
+
+    /**
+     * \brief Check if the property is writable
+     *
+     * \return True if the property is writable, false otherwise
+     */
+    virtual bool isWritable() const
+    {
+        return m_metaProperty.isWritable();
+    }
+
+private:
+
+    QMetaProperty m_metaProperty; ///< Internal Qt property
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QTSIMPLEPROPERTY_HPP
diff --git a/include/camp/qt/qvector.hpp b/include/camp/qt/qvector.hpp
new file mode 100644
index 0000000..8982e9c
--- /dev/null
+++ b/include/camp/qt/qvector.hpp
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_QT_QVECTOR_HPP
+#define CAMP_QT_QVECTOR_HPP
+
+
+#include <camp/arraymapper.hpp>
+#include <QVector>
+
+
+namespace camp_ext
+{
+/*
+ * \brief Specialization of ArrayMapper for QVector
+ */
+ template <typename T>
+ struct ArrayMapper<QVector<T> >
+ {
+    typedef T ElementType;
+
+    static bool dynamic()
+    {
+        return true;
+    }
+
+    static std::size_t size(const QVector<T>& arr)
+    {
+        return static_cast<std::size_t>(arr.size());
+    }
+
+    static const T& get(const QVector<T>& arr, std::size_t index)
+    {
+        return arr[static_cast<int>(index)];
+    }
+
+    static void set(QVector<T>& arr, std::size_t index, const T& value)
+    {
+        arr[static_cast<int>(index)] = value;
+    }
+
+    static void insert(QVector<T>& arr, std::size_t before, const T& value)
+    {
+        arr.insert(static_cast<int>(before), value);
+    }
+
+    static void remove(QVector<T>& arr, std::size_t index)
+    {
+        arr.remove(static_cast<int>(index));
+    }
+};
+
+} // namespace camp_ext
+
+
+#endif // CAMP_QT_QVECTOR_HPP
diff --git a/include/camp/simpleproperty.hpp b/include/camp/simpleproperty.hpp
new file mode 100644
index 0000000..04dfe14
--- /dev/null
+++ b/include/camp/simpleproperty.hpp
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_SIMPLEPROPERTY_HPP
+#define CAMP_SIMPLEPROPERTY_HPP
+
+
+#include <camp/property.hpp>
+
+
+namespace camp
+{
+/**
+ * \brief Base class for all simple types of properties
+ *
+ * This class actually does nothing more than its base, it's just a way to separate
+ * simple properties from other types.
+ *
+ * \sa ArrayProperty, EnumProperty, ObjectProperty
+ */
+class CAMP_API SimpleProperty : public Property
+{
+public:
+
+    /**
+     * \brief Construct the property from its description
+     *
+     * \param name Name of the property
+     * \param type Type of the property
+     */
+    SimpleProperty(const std::string& name, Type type);
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~SimpleProperty();
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+};
+
+} // namespace camp
+
+
+#endif // CAMP_SIMPLEPROPERTY_HPP
diff --git a/include/camp/tagholder.hpp b/include/camp/tagholder.hpp
new file mode 100644
index 0000000..310f347
--- /dev/null
+++ b/include/camp/tagholder.hpp
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_TAGHOLDER_HPP
+#define CAMP_TAGHOLDER_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/detail/getter.hpp>
+#include <camp/value.hpp>
+#include <boost/shared_ptr.hpp>
+#include <map>
+
+
+namespace camp
+{
+template <typename T> class ClassBuilder;
+class UserObject;
+
+/**
+ * \brief Defines objects that hold a set of tags
+ *
+ * TagHolder defines an interface for accessing custom tags stored into instances.
+ *
+ * A tag is an identifier which can be of any supported type (it is stored in a camp::Value).
+ * It can also be associated to a value, either constant (static tags) or evaluated each
+ * time the tag is requested (dynamic tags).
+ *
+ * \code
+ * // Check tag existence
+ * bool scriptable = tagHolder.hasTag("scriptable");
+ *
+ * // Retrieve static tag
+ * int category = tagHolder.tag("category");
+ *
+ * // Retrieve dynamic tag whose value depends on an object's state
+ * bool hidden = tagHolder.tag("hidden", object);
+ * \endcode
+ */
+class CAMP_API TagHolder
+{
+public:
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~TagHolder();
+
+    /**
+     * \brief Get the total number of tags stored in the object
+     *
+     * \return Number of tags
+     */
+    std::size_t tagCount() const;
+
+    /**
+     * \brief Get a tag by its index
+     *
+     * \param index Index of the tag to retrieve
+     *
+     * \return index-th tag
+     *
+     * \throw OutOfRange index is out of range
+     */
+    const Value& tagId(std::size_t index) const;
+
+    /**
+     * \brief Check the existence of a tag
+     *
+     * \param id Identifier of the tag to check
+     *
+     * \return True if the tag exists, false otherwise
+     */
+    bool hasTag(const Value& id) const;
+
+    /**
+     * \brief Get the value associated to a tag
+     *
+     * \param id Identifier of the tag to get
+     *
+     * \return Value associated to the tag, or Value::nothing if the tag doesn't exist
+     */
+    const Value& tag(const Value& id) const;
+
+    /**
+     * \brief Get the value associated to a dynamic tag
+     *
+     * \param id Identifier of the tag to get
+     * \param object User object for which to get the tag value 
+     *
+     * \return Value associated to the tag for \a object, or Value::nothing if the tag doesn't exist
+     */
+    Value tag(const Value& id, const UserObject& object) const;
+
+protected:
+
+    /**
+     * \brief Default constructor
+     */
+    TagHolder();
+
+private:
+
+    template <typename T> friend class ClassBuilder;
+
+    typedef std::map<Value, detail::Getter<Value> > TagsTable;
+
+    TagsTable m_tags; ///< Table of tags / values
+};
+
+} // namespace camp
+
+
+#endif // CAMP_TAGHOLDER_HPP
diff --git a/include/camp/type.hpp b/include/camp/type.hpp
new file mode 100644
index 0000000..7d92cf6
--- /dev/null
+++ b/include/camp/type.hpp
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_TYPE_HPP
+#define CAMP_TYPE_HPP
+
+
+#include <string>
+#include <cassert>
+
+
+namespace camp
+{
+/**
+ * \brief Special empty type associated to \c noType
+ *
+ * This type is mainly used when writing custom \c Value visitors
+ */
+struct NoType
+{
+};
+
+/**
+ * \brief Enumeration of abstract types supported by CAMP
+ *
+ * \sa ValueMapper
+ */
+enum Type
+{
+    noType,     ///< No type has been defined yet
+    boolType,   ///< Boolean type (bool)
+    intType,    ///< Integer types (unsigned/signed char short int long)
+    realType,   ///< Real types (float, double)
+    stringType, ///< String types (char*, std::string)
+    enumType,   ///< Enumerated types
+    arrayType,  ///< Array types (std::vector, std::list, T[])
+    userType    ///< User-defined classes
+};
+
+} // namespace camp
+
+
+#endif // CAMP_TYPE_HPP
diff --git a/include/camp/userobject.hpp b/include/camp/userobject.hpp
new file mode 100644
index 0000000..e618046
--- /dev/null
+++ b/include/camp/userobject.hpp
@@ -0,0 +1,313 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_USEROBJECT_HPP
+#define CAMP_USEROBJECT_HPP
+
+
+#include <camp/args.hpp>
+#include <camp/classcast.hpp>
+#include <camp/errors.hpp>
+#include <camp/detail/objecttraits.hpp>
+#include <camp/detail/objectholder.hpp>
+#include <boost/operators.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <string>
+
+
+namespace camp
+{
+class Property;
+class UserProperty;
+class Value;
+class ParentObject;
+
+/**
+ * \brief Wrapper to manipulate user objects in the CAMP system
+ *
+ * camp::UserObject is an abstract representation of object instances, which can safely
+ * be passed to and manipulated by all the entities in CAMP.
+ *
+ * \sa EnumObject
+ */
+class CAMP_API UserObject : boost::totally_ordered<UserObject>
+{
+public:
+
+    /**
+     * \brief Default constructor
+     *
+     * Constructs an empty/invalid object
+     */
+    UserObject();
+
+    /**
+     * \brief Construct the user object from an instance
+     *
+     * This constructor is equivalent to calling UserObject::ref(object),
+     * i.e. the object is stored by reference.
+     *
+     * \param object Instance to store in the user object
+     */
+    template <typename T>
+    UserObject(const T& object);
+
+    template<typename T>
+    UserObject(const T& object, std::string type);
+
+    /**
+     * \brief Construct the user object from a parent object and a member property
+     *
+     * This constructor allows to create user objects that are accessed through a property
+     * of another user object, and that cannot be stored in memory.
+     *
+     * \param parent Parent user object
+     * \param member Member of \a parent used to access the actual object
+     */
+    UserObject(const UserObject& parent, const UserProperty& member);
+
+    /**
+     * \brief Copy constructor
+     *
+     * \param copy Instance to copy
+     */
+    UserObject(const UserObject& copy);
+
+    /**
+     * \brief Retrieve the instance stored in the user object
+     *
+     * The template parameter T is the type to convert the instance to.
+     * T must be compatible with the original type of the instance.
+     *
+     * \return Reference to the instance of the stored object
+     *
+     * \throw NullObject the stored object is invalid
+     * \throw ClassNotFound T has not metaclass
+     * \throw ClassUnrelated the type of the object is not compatible with T
+     */
+    template <typename T>
+    typename detail::ObjectTraits<T>::RefReturnType get() const;
+
+    /**
+     * \brief Retrieve the address of the stored object
+     *
+     * This function must be used with caution, as the returned address
+     * may not be what you expect it to be!
+     *
+     * \return Pointer to the stored object
+     */
+    void* pointer() const;
+
+    /**
+     * \brief Retrieve the metaclass of the stored instance
+     *
+     * \return Reference to the instance's metaclass
+     *
+     * \throw NullObject the stored object has no metaclass
+     */
+    const Class& getClass() const;
+
+    /**
+     * \brief Get the value of an object's property
+     *
+     * This function is defined for convenience, it is a shortcut
+     * for <tt>object.getClass().property(name).get(object);</tt>
+     *
+     * \param property Name of the property to get
+     *
+     * \return Current value of the property
+     *
+     * \throw PropertyNotFound \a property is not a property of the object
+     * \throw ForbiddenRead \a property is not readable
+     */
+    Value get(const std::string& property) const;
+
+    /**
+     * \brief Set the value of an object's property
+     *
+     * This function is defined for convenience, it is a shortcut
+     * for <tt>object.getClass().property(name).set(object, value);</tt>
+     *
+     * \param property Name of the property to set
+     * \param value Value to set
+     *
+     * \throw PropertyNotFound \a property is not a property of the object
+     * \throw ForbiddenWrite \a property is not writable
+     * \throw BadType \a value can't be converted to the property's type
+     */
+    void set(const std::string& property, const Value& value) const;
+
+    /**
+     * \brief Call an object's function
+     *
+     * This function is defined for convenience, it is a shortcut
+     * for <tt>object.getClass().function(name).call(object, args);</tt>
+     *
+     * \param function Name of the function to call
+     * \param args Arguments to pass to the function
+     *
+     * \return Value returned by the function
+     *
+     * \throw FunctionNotFound \a function is not a function of the object class
+     * \throw ForbiddenCall \a function is not callable
+     * \throw NotEnoughArguments too few arguments are provided
+     * \throw BadArgument one of the arguments can't be converted to the requested type
+     */
+    Value call(const std::string& function, const Args& args = Args::empty) const;
+
+    /**
+     * \brief Assignment operator
+     *
+     * \param other User object to assign
+     *
+     * \return Reference to this
+     */
+    UserObject& operator=(const UserObject& other);
+
+    /**
+     * \brief Operator == to compare equality between two user objects
+     *
+     * Two user objects are equal if their metaclasses and pointers are both equal
+     *
+     * \param other User object to compare with this
+     *
+     * \return True if both user objects are the same, false otherwise
+     */
+    bool operator==(const UserObject& other) const;
+
+    /**
+     * \brief Operator < to compare two user objects
+     *
+     * \param other User object to compare with this
+     *
+     * \return True if this < other
+     */
+    bool operator<(const UserObject& other) const;
+
+public:
+
+    /**
+     * \brief Special UserObject instance representing an empty object
+     */
+    static const UserObject nothing;
+
+    /**
+     * \brief Construct a user object from a reference to an object
+     *
+     * This functions is equivalent to calling UserObject(object).
+     *
+     * \param object Instance to store in the user object
+     *
+     * \return UserObject containing a reference to \a  object
+     */
+    template <typename T>
+    static UserObject ref(T& object);
+
+    /**
+     * \brief Construct a user object from a const reference to an object
+     *
+     * This functions is NOT equivalent to calling UserObject(object).
+     *
+     * \param object Instance to store in the user object
+     *
+     * \return UserObject containing a const reference to \a object
+     */
+    template <typename T>
+    static UserObject ref(const T& object);
+
+    /**
+     * \brief Construct a user object with a copy of an object
+     *
+     * This functions is NOT equivalent to calling UserObject(object).
+     *
+     * \param object Instance to store in the user object
+     *
+     * \return UserObject containing a copy of \a object
+     */
+    template <typename T>
+    static UserObject copy(const T& object);
+
+private:
+
+    friend class Property;
+
+    /**
+     * \brief Assign a new value to a property of the object
+     *
+     * This functions is meant to be used only by Property, and
+     * is needed for proper propagation of the modification to the
+     * parent objects.
+     *
+     * \param property Property to modify
+     * \param value New value to assign
+     */
+    void set(const Property& property, const Value& value) const;
+
+    /**
+     * \brief Recursively set a property
+     *
+     * See the description of UserObject::set(property, value).
+     *
+     * \param object Object to modify
+     * \param property Property to set when the recursion is over
+     * \param value Value to assign when the recursion is over
+     */
+    void cascadeSet(const UserObject& object, const Property& property, const Value& value) const;
+
+private:
+
+    const Class* m_class; ///< Metaclass of the stored object
+    boost::shared_ptr<detail::AbstractObjectHolder> m_holder; ///< Optional abstract holder storing the object
+    boost::scoped_ptr<ParentObject> m_parent; ///< Optional parent object
+    const UserObject* m_child; ///< Optional pointer to the child object (m_parent.object.m_child == this)
+};
+
+
+/**
+ * \brief Structure holding the informations about a parent object
+ *
+ * A parent object is composed of a <object, property> pair.
+ */
+class ParentObject : boost::noncopyable
+{
+public:
+
+    /**
+     * \brief Default constructor
+     */
+    ParentObject(const UserObject& obj, const UserProperty& mem) : object(obj), member(mem) {}
+
+    UserObject object; ///< Parent object
+    const UserProperty& member; ///< Member of the parent giving access to the child object
+    UserObject lastValue; ///< Last value of the object (stored here for persistency)
+};
+
+
+} // namespace camp
+
+#include <camp/userobject.inl>
+
+
+#endif // CAMP_USEROBJECT_HPP
diff --git a/include/camp/userobject.inl b/include/camp/userobject.inl
new file mode 100644
index 0000000..1ed29c9
--- /dev/null
+++ b/include/camp/userobject.inl
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+UserObject::UserObject(const T& object)
+    : m_class(&classByObject(object))
+    , m_holder()
+    , m_parent()
+    , m_child(0)
+{
+    typedef detail::ObjectTraits<T&> Traits;
+    typedef detail::ObjectHolderByRef<typename Traits::DataType> Holder;
+
+    m_holder.reset(new Holder(Traits::getPointer(const_cast<T&>(object))));
+}
+
+//-------------------------------------------------------------------------------------------------
+template<typename T>
+UserObject::UserObject(const T& object, std::string type)
+    : m_class(&classByName(type))
+    , m_holder()
+    , m_parent()
+    , m_child(0)
+{
+    typedef detail::ObjectTraits<T&> Traits;
+    typedef detail::ObjectHolderByRef<typename Traits::DataType> Holder;
+
+    m_holder.reset(new Holder(Traits::getPointer(const_cast<T&>(object))));
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+typename detail::ObjectTraits<T>::RefReturnType UserObject::get() const
+{
+    // Make sure that we have a valid internal object
+    void* ptr = pointer();
+    if (!ptr)
+        CAMP_ERROR(NullObject(m_class));
+
+    // Get the metaclass of T (we use classByTypeSafe because it may not exist)
+    const Class* targetClass = classByTypeSafe<T>();
+    if (!targetClass)
+        CAMP_ERROR(ClassNotFound("unknown"));
+
+    // Apply the proper offset to the pointer (solves multiple inheritance issues)
+    ptr = classCast(ptr, *m_class, *targetClass);
+
+    return detail::ObjectTraits<T>::get(ptr);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+UserObject UserObject::ref(T& object)
+{
+    return UserObject(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+UserObject UserObject::ref(const T& object)
+{
+    typedef detail::ObjectTraits<const T&> Traits;
+    typedef detail::ObjectHolderByConstRef<typename Traits::DataType> Holder;
+
+    UserObject userObject;
+    userObject.m_class = &classByObject(object);
+    userObject.m_holder.reset(new Holder(Traits::getPointer(object)));
+
+    return userObject;
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+UserObject UserObject::copy(const T& object)
+{
+    typedef detail::ObjectTraits<const T&> Traits;
+    typedef detail::ObjectHolderByCopy<typename Traits::DataType> Holder;
+
+    UserObject userObject;
+    userObject.m_class = &classByType<T>();
+    userObject.m_holder.reset(new Holder(Traits::getPointer(object)));
+
+    return userObject;
+}
+
+} // namespace camp
diff --git a/include/camp/userproperty.hpp b/include/camp/userproperty.hpp
new file mode 100644
index 0000000..67a4bfd
--- /dev/null
+++ b/include/camp/userproperty.hpp
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_USERPROPERTY_HPP
+#define CAMP_USERPROPERTY_HPP
+
+
+#include <camp/property.hpp>
+
+
+namespace camp
+{
+class Class;
+
+/**
+ * \brief Specialized type of property for user types
+ *
+ */
+class CAMP_API UserProperty : public Property
+{
+public:
+
+    /**
+     * \brief Construct the property from its description
+     *
+     * \param name Name of the property
+     * \param propClass Eumeration the property is bound to
+     */
+    UserProperty(const std::string& name, const Class& propClass);
+
+    /**
+     * \brief Destructor
+     */
+    virtual ~UserProperty();
+
+    /**
+     * \brief Get the owner class
+     *
+     * \return Class the property is bound to
+     */
+    const Class& getClass() const;
+
+    /**
+     * \brief Accept the visitation of a ClassVisitor
+     *
+     * \param visitor Visitor to accept
+     */
+    virtual void accept(ClassVisitor& visitor) const;
+
+private:
+
+    const Class* m_class; ///< Owner class of the property
+};
+
+} // namespace camp
+
+
+#endif // CAMP_ENUMPROPERTY_HPP
diff --git a/include/camp/value.hpp b/include/camp/value.hpp
new file mode 100644
index 0000000..8d35abb
--- /dev/null
+++ b/include/camp/value.hpp
@@ -0,0 +1,228 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_VALUE_HPP
+#define CAMP_VALUE_HPP
+
+
+#include <camp/config.hpp>
+#include <camp/type.hpp>
+#include <camp/enumobject.hpp>
+#include <camp/userobject.hpp>
+#include <camp/valuemapper.hpp>
+#include <camp/detail/valueimpl.hpp>
+#include <boost/operators.hpp>
+#include <iosfwd>
+#include <string>
+
+// Visual C++ produces some unnecessary warnings with boost/variant.hpp
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable: 4100) // "assignment operator could not be generated"
+    #pragma warning(disable: 4512) // "unreferenced formal parameter"
+#endif
+
+#include <boost/variant.hpp>
+
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif
+
+
+namespace camp
+{
+/**
+ * \brief Variant class which is used to wrap values in the CAMP system
+ *
+ * The Value class can store any type of variable, and supports conversion
+ * to any type compatible with the stored type.
+ *
+ * \code
+ * camp::Value v1 = true;
+ * camp::Value v2 = 10;
+ * camp::Value v3 = "24.5";
+ * camp::Value v4 = myObject;
+ *
+ * bool        b = v1; // b == true
+ * std::string s = v2; // s == "10"
+ * float       f = v3; // f == 24.5
+ * MyObject    o = v4; // o == myObject
+ * \endcode
+ *
+ * It also supports unary and binary visitation for type-safe processing
+ * depending on the stored type.
+ *
+ * \remark The set of supported types can be extended by specializing the
+ * camp_ext::ValueMapper template.
+ *
+ * \sa ValueVisitor, camp_ext::ValueMapper
+ */
+class CAMP_API Value : boost::totally_ordered<Value>
+{
+public:
+
+    /**
+     * \brief Default constructor, constructs a null value
+     */
+    Value();
+
+    /**
+     * \brief Copy constructor
+     *
+     * \param other Value to copy
+     */
+    Value(const Value& other);
+
+    /**
+     * \brief Construct the value from a variable of type T
+     *
+     * \param val Value to store
+     */
+    template <typename T>
+    Value(const T& val);
+
+    /**
+     * \brief Return the CAMP type of the value
+     *
+     * \return Type of the value
+     */
+    Type type() const;
+
+    /**
+     * \brief Convert the value to the type T
+     *
+     * \return Value converted to T
+     *
+     * \throw BadType the stored value is not convertible to T
+     */
+    template <typename T>
+    T to() const;
+
+    /**
+     * \brief Cast operator to implicitely convert the value to a type T
+     *
+     * \return Value converted to T
+     *
+     * \throw BadType the stored value is not convertible to T
+     */
+    template <typename T>
+    operator T() const;
+
+    /**
+     * \brief Check if the stored value can be converted to a type T
+     *
+     * If this function returns true, then calling to<T>() or operator T() will succeed.
+     *
+     * \return True if conversion is possible, false otherwise
+     */
+    template <typename T>
+    bool isCompatible() const;
+
+    /**
+     * \brief Visit the value with a unary visitor
+     *
+     * Using this function allows to dispatch an operation depending on the stored type.
+     *
+     * \param visitor Visitor to apply (must inherit from ValueVisitor<type_to_return>)
+     *
+     * \return Value returned by the visitor
+     */
+    template <typename T>
+    typename T::result_type visit(T visitor) const;
+
+    /**
+     * \brief Visit the value and another one with a binary visitor
+     *
+     * Using this function allows to dispatch a binary operation depending on the stored type
+     * of both values.
+     *
+     * \param visitor Visitor to apply (must inherit from ValueVisitor<type_to_return>)
+     * \param other Other value to visit
+     *
+     * \return Value returned by the visitor
+     */
+    template <typename T>
+    typename T::result_type visit(T visitor, const Value& other) const;
+
+    /**
+     * \brief Operator == to compare equality between two values
+     *
+     * Two values are equal if their CAMP type and value are equal.
+     * It uses the == operator of the stored type.
+     *
+     * \param other Value to compare with this
+     *
+     * \return True if both values are the same, false otherwise
+     */
+    bool operator==(const Value& other) const;
+
+    /**
+     * \brief Operator < to compare two values
+     *
+     * \param other Value to compare with this
+     *
+     * \return True if this < other
+     */
+    bool operator<(const Value& other) const;
+
+public:
+
+    /**
+     * \brief Special Value instance representing an empty value
+     */
+    static const Value nothing;
+
+private:
+
+    typedef boost::variant<NoType, bool, long, double, std::string, EnumObject, UserObject> Variant;
+
+    Variant m_value; ///< Stored value
+    Type m_type; ///< CAMP type of the value
+};
+
+/**
+ * \brief Overload of operator >> to extract a camp::Value from a standard stream
+ *
+ * \param stream Source input stream
+ * \param value Value to fill
+ *
+ * \return Reference to the input stream
+ */
+CAMP_API std::istream& operator>>(std::istream& stream, Value& value);
+
+/**
+ * \brief Overload of operator << to print a camp::Value into a standard stream
+ *
+ * \param stream Target output stream
+ * \param value Value to print
+ *
+ * \return Reference to the output stream
+ */
+CAMP_API std::ostream& operator<<(std::ostream& stream, const Value& value);
+
+} // namespace camp
+
+#include <camp/value.inl>
+
+
+#endif // CAMP_VALUE_HPP
diff --git a/include/camp/value.inl b/include/camp/value.inl
new file mode 100644
index 0000000..139ab26
--- /dev/null
+++ b/include/camp/value.inl
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+namespace camp
+{
+namespace detail
+{
+/**
+ * \brief Helper structure allowing a shortcut when converting a camp::Value to camp::Value
+ */
+template <typename T>
+struct ValueTo
+{
+    static T convert(const Value& value) {return value.visit(ConvertVisitor<T>());}
+};
+template <>
+struct ValueTo<Value>
+{
+    static Value convert(const Value& value) {return value;}
+};
+
+} // namespace detail
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+Value::Value(const T& val)
+    : m_value(camp_ext::ValueMapper<T>::to(val))
+    , m_type(mapType<T>())
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+T Value::to() const
+{
+    try
+    {
+        return detail::ValueTo<T>::convert(*this);
+    }
+    catch (boost::bad_lexical_cast&)
+    {
+        CAMP_ERROR(BadType(type(), mapType<T>()));
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+Value::operator T() const
+{
+    return to<T>();
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+bool Value::isCompatible() const
+{
+    try
+    {
+        to<T>();
+        return true;
+    }
+    catch (std::exception&)
+    {
+        return false;
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+typename T::result_type Value::visit(T visitor) const
+{
+    return boost::apply_visitor(visitor, m_value);
+}
+
+//-------------------------------------------------------------------------------------------------
+template <typename T>
+typename T::result_type Value::visit(T visitor, const Value& other) const
+{
+    return boost::apply_visitor(visitor, m_value, other.m_value);
+}
+
+} // namespace camp
diff --git a/include/camp/valuemapper.hpp b/include/camp/valuemapper.hpp
new file mode 100644
index 0000000..0c5fd39
--- /dev/null
+++ b/include/camp/valuemapper.hpp
@@ -0,0 +1,405 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_VALUEMAPPER_HPP
+#define CAMP_VALUEMAPPER_HPP
+
+
+#include <camp/enum.hpp>
+#include <camp/enumobject.hpp>
+#include <camp/userobject.hpp>
+#include <camp/arraymapper.hpp>
+#include <camp/errors.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+namespace camp_ext
+{
+    template <typename T, typename C = void> struct ValueMapper;
+}
+
+
+namespace camp
+{
+/**
+ * \brief Map a C++ type to a CAMP type
+ *
+ * This function simply returns the mapping defined by ValueMapper (i.e. \c ValueMapper<T>::type).
+ *
+ * \return CAMP type which T maps to
+ */
+template <typename T>
+Type mapType()
+{
+    return static_cast<Type>(camp_ext::ValueMapper<T>::type);
+}
+
+} // namespace camp
+
+
+namespace camp_ext
+{
+/**
+ * \class ValueMapper
+ *
+ * \brief Template providing a mapping between C++ types/values and CAMP types/values
+ *
+ * ValueMapper<T> defines three things in order to make T fully compliant with the system:
+ *
+ * \li The abstract CAMP type that T is mapped to
+ * \li A function to convert from T to the mapped CAMP type
+ * \li A function to convert from all supported CAMP types to T
+ *
+ * ValueMapper is specialized for every supported type, and can be specialized
+ * for any of your own types in order to extend the system.
+ *
+ * Here is an example of mapping for a custom string class:
+ *
+ * \code
+ * namespace camp_ext
+ * {
+ *     template <>
+ *     struct ValueMapper<MyStringClass>
+ *     {
+ *         // The corresponding CAMP type is "string"
+ *         static const int type = camp::string;
+ *  
+ *         // Convert from MyStringClass to std::string
+ *         static std::string to(const MyStringClass& source)
+ *         {
+ *             return source.to_std_string();
+ *         }
+ * 
+ *         // Convert from any type to MyStringClass
+ *         // Be smart, juste reuse ValueMapper<std::string> :)
+ *         template <typename T>
+ *         static MyStringClass from(const T& source)
+ *         {
+ *             return MyStringClass(ValueMapper<std::string>::from(source));
+ *         }
+ *     };
+ * }
+ * \endcode
+ */
+
+/*
+ * Generic version of ValueMapper -- T doesn't match with any specialization
+ * and is thus treated as a user object
+ */
+template <typename T, typename C>
+struct ValueMapper
+{
+    static const int type = camp::userType;
+    static camp::UserObject to(const T& source) {return camp::UserObject(source);}
+
+    static T from(bool)                           {CAMP_ERROR(camp::BadType(camp::boolType,   camp::mapType<T>()));}
+    static T from(long)                           {CAMP_ERROR(camp::BadType(camp::intType,    camp::mapType<T>()));}
+    static T from(double)                         {CAMP_ERROR(camp::BadType(camp::realType,   camp::mapType<T>()));}
+    static T from(const std::string&)             {CAMP_ERROR(camp::BadType(camp::stringType, camp::mapType<T>()));}
+    static T from(const camp::EnumObject&)        {CAMP_ERROR(camp::BadType(camp::enumType,   camp::mapType<T>()));}
+    static T from(const camp::UserObject& source) {return source.get<T>();}
+};
+
+/*
+ * Specialization of ValueMapper for abstract types
+ */
+template <typename T>
+struct ValueMapper<T, typename boost::enable_if<boost::is_abstract<T> >::type>
+{
+    static const int type = camp::userType;
+    static camp::UserObject to(const T& source) {return camp::UserObject(source);}
+};
+
+/*
+ * Specialization of ValueMapper for booleans
+ */
+template <>
+struct ValueMapper<bool>
+{
+    static const int type = camp::boolType;
+    static bool to(bool source) {return source;}
+
+    static bool from(bool source)                    {return source;}
+    static bool from(long source)                    {return source != 0;}
+    static bool from(double source)                  {return source != 0.;}
+    static bool from(const std::string& source)      
+    {
+        bool result;
+        if(source.compare("true") == 0)
+        {
+            result = true;
+        }
+        else if(source.compare("false") == 0)
+        {
+            result = false;
+        }
+        else
+        {
+            result = ::boost::lexical_cast<bool>(source);
+        }
+        return result;
+    }
+    static bool from(const camp::EnumObject& source) {return source.value() != 0;}
+    static bool from(const camp::UserObject& source) {return source.pointer() != 0;}
+};
+
+/*
+ * Specialization of ValueMapper for integers
+ */
+template <typename T>
+struct ValueMapper<T, typename boost::enable_if_c<boost::is_integral<T>::value
+                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>
+                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>
+                                                 >::type>
+{
+    static const int type = camp::intType;
+    static long to(T source) {return static_cast<long>(source);}
+
+    static T from(bool source)                    {return static_cast<T>(source);}
+    static T from(long source)                    {return static_cast<T>(source);}
+    static T from(double source)                  {return static_cast<T>(source);}
+    static T from(const std::string& source)      {return boost::lexical_cast<T>(source);}
+    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}
+    static T from(const camp::UserObject&)        {CAMP_ERROR(camp::BadType(camp::userType, camp::intType));}
+};
+
+/*
+ * Specialization of ValueMapper for reals
+ */
+template <typename T>
+struct ValueMapper<T, typename boost::enable_if_c<boost::is_float<T>::value
+                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>
+                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>
+                                                 >::type>
+{
+    static const int type = camp::realType;
+    static double to(T source) {return static_cast<double>(source);}
+
+    static T from(bool source)                    {return static_cast<T>(source);}
+    static T from(long source)                    {return static_cast<T>(source);}
+    static T from(double source)                  {return static_cast<T>(source);}
+    static T from(const std::string& source)      {return boost::lexical_cast<T>(source);}
+    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}
+    static T from(const camp::UserObject&)        {CAMP_ERROR(camp::BadType(camp::userType, camp::realType));}
+};
+
+/*
+ * Specialization of ValueMapper for std::string
+ */
+template <>
+struct ValueMapper<std::string>
+{
+    static const int type = camp::stringType;
+    static const std::string& to(const std::string& source) {return source;}
+
+    static std::string from(bool source)                    {return boost::lexical_cast<std::string>(source);}
+    static std::string from(long source)                    {return boost::lexical_cast<std::string>(source);}
+    static std::string from(double source)                  {return boost::lexical_cast<std::string>(source);}
+    static std::string from(const std::string& source)      {return source;}
+    static std::string from(const camp::EnumObject& source) {return source.name();}
+    static std::string from(const camp::UserObject&)        {CAMP_ERROR(camp::BadType(camp::userType, camp::stringType));}
+};
+
+/*
+ * Specialization of ValueMapper for arrays.
+ * No conversion allowed, only type mapping is provided.
+ *
+ * Warning: special case for char[] and const char[], they are strings not arrays
+ */
+template <typename T>
+struct ValueMapper<T, typename boost::enable_if_c<camp::detail::IsArray<T>::value
+                                                  && !boost::is_same<typename camp_ext::ArrayMapper<T>::ElementType, char>::value
+                                                  && !boost::is_same<typename camp_ext::ArrayMapper<T>::ElementType, const char>::value
+                                                 >::type>
+{
+    static const int type = camp::arrayType;
+};
+
+/*
+ * Specializations of ValueMapper for char arrays.
+ * Conversion to char[N] is disabled (can't return an array).
+ */
+template <int N>
+struct ValueMapper<char[N]>
+{
+    static const int type = camp::stringType;
+    static std::string to(const char source[N]) {return std::string(source);}
+};
+template <int N>
+struct ValueMapper<const char[N]>
+{
+    static const int type = camp::stringType;
+    static std::string to(const char source[N]) {return std::string(source);}
+};
+
+/*
+ * Specialization of ValueMapper for enum types
+ */
+template <typename T>
+struct ValueMapper<T, typename boost::enable_if_c<boost::is_enum<T>::value
+                                                  && !boost::is_const<T>::value // to avoid conflict with ValueMapper<const T>
+                                                  && !boost::is_reference<T>::value // to avoid conflict with ValueMapper<T&>
+                                                 >::type>
+{
+    static const int type = camp::enumType;
+    static camp::EnumObject to(T source) {return camp::EnumObject(source);}
+
+    static T from(bool source)                    {return static_cast<T>(static_cast<long>(source));}
+    static T from(long source)                    {return static_cast<T>(source);}
+    static T from(double source)                  {return static_cast<T>(static_cast<long>(source));}
+    static T from(const camp::EnumObject& source) {return static_cast<T>(source.value());}
+    static T from(const camp::UserObject&)        {CAMP_ERROR(camp::BadType(camp::userType, camp::enumType));}
+
+    // The string -> enum conversion involves a little more work:
+    // we try two different conversions (as a name and as a value)
+    static T from(const std::string& source)
+    {
+        // Get the metaenum of T, if any
+        const camp::Enum* metaenum = camp::enumByTypeSafe<T>();
+
+        // First try as a name
+        if (metaenum && metaenum->hasName(source))
+            return static_cast<T>(metaenum->value(source));
+
+        // Then try as a number
+        long value = boost::lexical_cast<long>(source);
+        if (!metaenum || metaenum->hasValue(value))
+            return static_cast<T>(value);
+
+        // Not a valid enum name or number: throw an error
+        CAMP_ERROR(camp::BadType(camp::stringType, camp::enumType));
+    }
+};
+
+/*
+ * Specialization of ValueMapper for EnumObject
+ */
+template <>
+struct ValueMapper<camp::EnumObject>
+{
+    static const int type = camp::enumType;
+    static const camp::EnumObject& to(const camp::EnumObject& source) {return source;}
+    static const camp::EnumObject& from(const camp::EnumObject& source) {return source;}
+
+    static camp::UserObject from(bool)                    {CAMP_ERROR(camp::BadType(camp::boolType,   camp::enumType));}
+    static camp::UserObject from(long)                    {CAMP_ERROR(camp::BadType(camp::intType,    camp::enumType));}
+    static camp::UserObject from(double)                  {CAMP_ERROR(camp::BadType(camp::realType,   camp::enumType));}
+    static camp::UserObject from(const std::string&)      {CAMP_ERROR(camp::BadType(camp::stringType, camp::enumType));}
+    static camp::UserObject from(const camp::UserObject&) {CAMP_ERROR(camp::BadType(camp::enumType,   camp::enumType));}
+};
+
+/*
+ * Specialization of ValueMapper for UserObject
+ */
+template <>
+struct ValueMapper<camp::UserObject>
+{
+    static const int type = camp::userType;
+    static const camp::UserObject& to(const camp::UserObject& source) {return source;}
+    static const camp::UserObject& from(const camp::UserObject& source) {return source;}
+
+    static camp::UserObject from(bool)                    {CAMP_ERROR(camp::BadType(camp::boolType,   camp::userType));}
+    static camp::UserObject from(long)                    {CAMP_ERROR(camp::BadType(camp::intType,    camp::userType));}
+    static camp::UserObject from(double)                  {CAMP_ERROR(camp::BadType(camp::realType,   camp::userType));}
+    static camp::UserObject from(const std::string&)      {CAMP_ERROR(camp::BadType(camp::stringType, camp::userType));}
+    static camp::UserObject from(const camp::EnumObject&) {CAMP_ERROR(camp::BadType(camp::enumType,   camp::userType));}
+};
+
+/*
+ * Specialization of ValueMapper for const T& -- just forward to ValueMapper<T>
+ */
+template <typename T>
+struct ValueMapper<const T&> : public ValueMapper<T>
+{
+};
+
+/*
+ * Specialization of ValueMapper for const T -- just forward to ValueMapper<T>
+ */
+template <typename T>
+struct ValueMapper<const T> : public ValueMapper<T>
+{
+};
+
+/*
+ * Specialization of ValueMapper for void.
+ * Conversion to void should never happen, the only aim of this
+ * specialization is to define the proper type mapping.
+ */
+template <>
+struct ValueMapper<void>
+{
+    static const int type = camp::noType;
+};
+
+/*
+ * Specialization of ValueMapper for NoType.
+ * Conversion to NoType should never happen, the only aim of this
+ * specialization is to define the proper mapped type.
+ */
+template <>
+struct ValueMapper<camp::NoType>
+{
+    static const int type = camp::noType;
+};
+
+/*
+ * Specialization of ValueMapper for non-const references.
+ * Conversions to non-const references are disabled (can't return a temporary by reference)
+ */
+template <typename T>
+struct ValueMapper<T&> : public ValueMapper<T>
+{
+    template <typename U>
+    static T& from(const U&)
+    {
+        // If you get this error, it means you're trying to cast
+        // a camp::Value to a non-const reference type, which is not allowed
+        return U::CONVERSION_TO_NON_CONST_REFERENCE_IS_NOT_ALLOWED();
+    }
+};
+
+/*
+ * Specialization of ValueMapper for const char*.
+ * Conversions to const char* are disabled (can't return a pointer to a temporary)
+ */
+template <>
+struct ValueMapper<const char*>
+{
+    static const int type = camp::stringType;
+    static std::string to(const char* source) {return std::string(source);}
+
+    template <typename T>
+    static const char* from(const T&)
+    {
+        // If you get this error, it means you're trying to cast
+        // a camp::Value to a const char*, which is not allowed
+        return T::CONVERSION_TO_CONST_CHAR_PTR_IS_NOT_ALLOWED();
+    }
+};
+
+} // namespace camp_ext
+
+#endif // CAMP_VALUEMAPPER_HPP
diff --git a/include/camp/valuevisitor.hpp b/include/camp/valuevisitor.hpp
new file mode 100644
index 0000000..05435eb
--- /dev/null
+++ b/include/camp/valuevisitor.hpp
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_VALUEVISITOR_HPP
+#define CAMP_VALUEVISITOR_HPP
+
+
+#include <boost/variant/static_visitor.hpp>
+
+
+namespace camp
+{
+/**
+ * \brief Base class for writing custom Value visitors
+ *
+ * A value visitor acts like compile-time dispatchers which automatically
+ * calls the function which matches the actual type of the stored value.
+ * This is a more direct and straight-forward approach than using a runtime switch,
+ * based on value.type() and then converting to the proper type.
+ * It also gives access to enum and user objects, which can give useful informations with
+ * no knowledge about the actual C++ class or enum.
+ *
+ * The template parameter T is the type returned by the visitor.
+ *
+ * To handle one of the possible types of the value, just write the corresponding \c operator() function.
+ * Here is the list of the mapping between CAMP types and their corresponding C++ types:
+ *
+ * \li camp::noType --> camp::NoType
+ * \li camp::boolType --> bool
+ * \li camp::intType --> long
+ * \li camp::realType --> double
+ * \li camp::stringType --> std::string
+ * \li camp::enumType --> camp::EnumObject
+ * \li camp::userType --> camp::UserObject
+ *
+ * Here an example of a unary visitor which creates an editor for the value based on its type
+ * \code
+ * struct EditorFactory : public ValueVisitor<PropertyEditor*>
+ * {
+ *     PropertyEditor* operator()(bool value)
+ *     {
+ *         return new BooleanEditor(value);
+ *     }
+ * 
+ *     PropertyEditor* operator()(long value)
+ *     {
+ *         return new IntegerEditor(value);
+ *     }
+ * 
+ *     PropertyEditor* operator()(double value)
+ *     {
+ *         return new RealEditor(value);
+ *     }
+ * 
+ *     PropertyEditor* operator()(const std::string& value)
+ *     {
+ *         return new StringEditor(value);
+ *     }
+ * 
+ *     PropertyEditor* operator()(const camp::EnumObject& value)
+ *     {
+ *         return new EnumEditor(value);
+ *     }
+ * 
+ *     PropertyEditor* operator()(const camp::UserObject& value)
+ *     {
+ *         return new UserEditor(value);
+ *     }
+ * };
+ * 
+ * camp::Value value(5.4);
+ * PropertyEditor* editor = value.visit(EditorFactory());
+ * \endcode
+ */
+template <typename T = void>
+class ValueVisitor : public boost::static_visitor<T>
+{
+
+};
+
+} // namespace camp
+
+
+#endif // CAMP_VALUEVISITOR_HPP
diff --git a/src/args.cpp b/src/args.cpp
new file mode 100644
index 0000000..5f69605
--- /dev/null
+++ b/src/args.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/args.hpp>
+#include <camp/value.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+const Args Args::empty;
+
+//-------------------------------------------------------------------------------------------------
+Args::Args()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+Args::Args(const Value& a0)
+{
+    m_values.push_back(a0);
+}
+
+//-------------------------------------------------------------------------------------------------
+Args::Args(const Value& a0, const Value& a1)
+{
+    m_values.push_back(a0);
+    m_values.push_back(a1);
+}
+
+//-------------------------------------------------------------------------------------------------
+Args::Args(const Value& a0, const Value& a1, const Value& a2)
+{
+    m_values.push_back(a0);
+    m_values.push_back(a1);
+    m_values.push_back(a2);
+}
+
+//-------------------------------------------------------------------------------------------------
+Args::Args(const Value& a0, const Value& a1, const Value& a2, const Value& a3)
+{
+    m_values.push_back(a0);
+    m_values.push_back(a1);
+    m_values.push_back(a2);
+    m_values.push_back(a3);
+}
+
+//-------------------------------------------------------------------------------------------------
+Args::Args(const Value& a0, const Value& a1, const Value& a2, const Value& a3, const Value& a4)
+{
+    m_values.push_back(a0);
+    m_values.push_back(a1);
+    m_values.push_back(a2);
+    m_values.push_back(a3);
+    m_values.push_back(a4);
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Args::count() const
+{
+    return m_values.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Value& Args::operator[](std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_values.size())
+        CAMP_ERROR(OutOfRange(index, m_values.size()));
+
+    return m_values[index];
+}
+
+//-------------------------------------------------------------------------------------------------
+Args Args::operator+(const Value& arg) const
+{
+    Args newArgs(*this);
+    newArgs += arg;
+
+    return newArgs;
+}
+
+//-------------------------------------------------------------------------------------------------
+Args& Args::operator+=(const Value& arg)
+{
+    m_values.push_back(arg);
+
+    return *this;
+}
+
+} // namespace camp
diff --git a/src/arrayproperty.cpp b/src/arrayproperty.cpp
new file mode 100644
index 0000000..39a2c2a
--- /dev/null
+++ b/src/arrayproperty.cpp
@@ -0,0 +1,168 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/arrayproperty.hpp>
+#include <camp/classvisitor.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+ArrayProperty::ArrayProperty(const std::string& name, Type elementType, bool dynamic)
+    : Property(name, arrayType)
+    , m_elementType(elementType)
+    , m_dynamic(dynamic)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ArrayProperty::~ArrayProperty()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+Type ArrayProperty::elementType() const
+{
+    return m_elementType;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool ArrayProperty::dynamic() const
+{
+    return m_dynamic;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t ArrayProperty::size(const UserObject& object) const
+{
+    // Check if the property is readable
+    if (!readable(object))
+        CAMP_ERROR(ForbiddenRead(name()));
+
+    return getSize(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::resize(const UserObject& object, std::size_t newSize) const
+{
+    // Check if the array is dynamic
+    if (!dynamic())
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the property is writable
+    if (!writable(object))
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    setSize(object, newSize);
+}
+
+//-------------------------------------------------------------------------------------------------
+Value ArrayProperty::get(const UserObject& object, std::size_t index) const
+{
+    // Check if the property is readable
+    if (!readable(object))
+        CAMP_ERROR(ForbiddenRead(name()));
+
+    // Make sure that the index is not out of range
+    std::size_t range = size(object);
+    if (index >= range)
+        CAMP_ERROR(OutOfRange(index, range));
+
+    return getElement(object, index);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::set(const UserObject& object, std::size_t index, const Value& value) const
+{
+    // Check if the property is writable
+    if (!writable(object))
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the index is in range
+    std::size_t range = size(object);
+    if (index >= range)
+        CAMP_ERROR(OutOfRange(index, range));
+
+    return setElement(object, index, value);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::insert(const UserObject& object, std::size_t before, const Value& value) const
+{
+    // Check if the array is dynamic
+    if (!dynamic())
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the property is writable
+    if (!writable(object))
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the index is in range
+    std::size_t range = size(object) + 1;
+    if (before >= range)
+        CAMP_ERROR(OutOfRange(before, range));
+
+    return insertElement(object, before, value);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::remove(const UserObject& object, std::size_t index) const
+{
+    // Check if the array is dynamic
+    if (!dynamic())
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the property is writable
+    if (!writable(object))
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Check if the index is in range
+    std::size_t range = size(object);
+    if (index >= range)
+        CAMP_ERROR(OutOfRange(index, range));
+
+    return removeElement(object, index);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+//-------------------------------------------------------------------------------------------------
+Value ArrayProperty::getValue(const UserObject& object) const
+{
+    // Return first element
+    return get(object, 0);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ArrayProperty::setValue(const UserObject& object, const Value& value) const
+{
+    // Set first element
+    set(object, 0, value);
+}
+
+} // namespace camp
diff --git a/src/camptype.cpp b/src/camptype.cpp
new file mode 100644
index 0000000..b57f46c
--- /dev/null
+++ b/src/camptype.cpp
@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+
+#include <camp/camptype.hpp>
+#include <camp/detail/classmanager.hpp>
+#include <camp/detail/enummanager.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+void ensureTypeRegistered(const char* id, void (*registerFunc)())
+{
+    if (registerFunc
+        && !ClassManager::instance().classExists(id)
+        && !EnumManager::instance().enumExists(id))
+    {
+        registerFunc();
+    }
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/src/class.cpp b/src/class.cpp
new file mode 100644
index 0000000..3b4ef1b
--- /dev/null
+++ b/src/class.cpp
@@ -0,0 +1,227 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/class.hpp>
+#include <camp/errors.hpp>
+#include <camp/userobject.hpp>
+#include <camp/detail/classmanager.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+const std::string& Class::name() const
+{
+    return m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Class::baseCount() const
+{
+    return m_bases.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& Class::base(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_bases.size())
+        CAMP_ERROR(OutOfRange(index, m_bases.size()));
+
+    return *m_bases[index].base;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Class::functionCount() const
+{
+    return m_functions.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Class::hasFunction(const std::string& name) const
+{
+    const FunctionNameIndex& names = m_functions.get<Name>();
+
+    return names.find(name) != names.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Function& Class::function(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_functions.size())
+        CAMP_ERROR(OutOfRange(index, m_functions.size()));
+
+    return *m_functions[index];
+}
+
+//-------------------------------------------------------------------------------------------------
+const Function& Class::function(const std::string& name) const
+{
+    const FunctionNameIndex& names = m_functions.get<Name>();
+
+    FunctionNameIndex::const_iterator it = names.find(name);
+    if (it == names.end())
+        CAMP_ERROR(FunctionNotFound(name, m_name));
+
+    return **it;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Class::propertyCount() const
+{
+    return m_properties.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Class::hasProperty(const std::string& name) const
+{
+    const PropertyNameIndex& names = m_properties.get<Name>();
+
+    return names.find(name) != names.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Property& Class::property(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_properties.size())
+        CAMP_ERROR(OutOfRange(index, m_properties.size()));
+
+    return *m_properties[index];
+}
+
+//-------------------------------------------------------------------------------------------------
+const Property& Class::property(const std::string& name) const
+{
+    const PropertyNameIndex& names = m_properties.get<Name>();
+
+    PropertyNameIndex::const_iterator it = names.find(name);
+    if (it == names.end())
+        CAMP_ERROR(PropertyNotFound(name, m_name));
+
+    return **it;
+}
+
+//-------------------------------------------------------------------------------------------------
+UserObject Class::construct(const Args& args) const
+{
+    // Search an arguments match among the list of available constructors
+    ConstructorList::const_iterator end = m_constructors.end();
+    for (ConstructorList::const_iterator it = m_constructors.begin();
+         it != end;
+         ++it)
+    {
+        Constructor& constructor = **it;
+        if (constructor.matches(args))
+        {
+            // Match found: use the constructor to create the new instance
+            return constructor.create(args);
+        }
+    }
+
+    // No match found
+    return UserObject::nothing;
+}
+
+//-------------------------------------------------------------------------------------------------
+void Class::destroy(const UserObject& object) const
+{
+    m_destructor(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+void Class::visit(ClassVisitor& visitor) const
+{
+    // First visit properties
+    for (PropertyTable::const_iterator it = m_properties.begin(); it != m_properties.end(); ++it)
+    {
+        (*it)->accept(visitor);
+    }
+
+    // Then visit functions
+    for (FunctionTable::const_iterator it = m_functions.begin(); it != m_functions.end(); ++it)
+    {
+        (*it)->accept(visitor);
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void* Class::applyOffset(void* pointer, const Class& target) const
+{
+    // Special case for null pointers: don't apply offset to leave them null
+    if (!pointer)
+        return pointer;
+
+    // Check target as a base class of this
+    int offset = baseOffset(target);
+    if (offset != -1)
+        return static_cast<void*>(static_cast<char*>(pointer) + offset);
+
+    // Check target as a derived class of this
+    offset = target.baseOffset(*this);
+    if (offset != -1)
+        return static_cast<void*>(static_cast<char*>(pointer) - offset);
+
+    // No match found, target is not a base class nor a derived class of this
+    CAMP_ERROR(ClassUnrelated(name(), target.name()));
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Class::operator==(const Class& other) const
+{
+    return m_name == other.m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Class::operator!=(const Class& other) const
+{
+    return m_name != other.m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+Class::Class(const std::string& name)
+    : m_name(name)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+int Class::baseOffset(const Class& base) const
+{
+    // Check self
+    if (&base == this)
+        return 0;
+
+    // Search base in the base classes
+    BaseList::const_iterator end = m_bases.end();
+    for (BaseList::const_iterator it = m_bases.begin(); it != end; ++it)
+    {
+        int offset = it->base->baseOffset(base);
+        if (offset != -1)
+            return offset + it->offset;
+    }
+
+    return -1;
+}
+
+} // namespace camp
diff --git a/src/classcast.cpp b/src/classcast.cpp
new file mode 100644
index 0000000..6d81697
--- /dev/null
+++ b/src/classcast.cpp
@@ -0,0 +1,36 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/classcast.hpp>
+#include <camp/class.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+void* classCast(void* pointer, const Class& sourceClass, const Class& targetClass)
+{
+    return sourceClass.applyOffset(pointer, targetClass);
+}
+
+} // namespace camp
diff --git a/src/classmanager.cpp b/src/classmanager.cpp
new file mode 100644
index 0000000..b5a4144
--- /dev/null
+++ b/src/classmanager.cpp
@@ -0,0 +1,147 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/detail/classmanager.hpp>
+#include <camp/class.hpp>
+#include <camp/errors.hpp>
+#include <camp/observer.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+ClassManager& ClassManager::instance()
+{
+    static ClassManager manager;
+    return manager;
+}
+
+//-------------------------------------------------------------------------------------------------
+Class& ClassManager::addClass(const std::string& name, const std::string& id)
+{
+    const IdIndex&   ids   = m_classes.get<Id>();
+    const NameIndex& names = m_classes.get<Name>();
+
+    // First make sure that the class doesn't already exist
+    if ((ids.find(id) != ids.end()) || (names.find(name) != names.end()))
+        CAMP_ERROR(ClassAlreadyCreated(name, id));
+
+    // Create the new class
+    boost::shared_ptr<Class> newClass(new Class(name));
+
+    // Insert it into the table
+    ClassInfo info;
+    info.id = id;
+    info.name = name;
+    info.classPtr = newClass;
+    m_classes.insert(info);
+
+    // Notify observers
+    notifyClassAdded(*newClass);
+
+    return *newClass;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t ClassManager::count() const
+{
+    return m_classes.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& ClassManager::getByIndex(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_classes.size())
+        CAMP_ERROR(OutOfRange(index, m_classes.size()));
+
+    ClassTable::const_iterator it = m_classes.begin();
+    std::advance(it, index);
+
+    return *it->classPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& ClassManager::getByName(const std::string& name) const
+{
+    const NameIndex& names = m_classes.get<Name>();
+
+    NameIndex::const_iterator it = names.find(name);
+    if (it == names.end())
+        CAMP_ERROR(ClassNotFound(name));
+
+    return *it->classPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& ClassManager::getById(const std::string& id) const
+{
+    const IdIndex& ids = m_classes.get<Id>();
+
+    IdIndex::const_iterator it = ids.find(id);
+    if (it == ids.end())
+        CAMP_ERROR(ClassNotFound(id));
+
+    return *it->classPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class* ClassManager::getByIdSafe(const std::string& id) const
+{
+    const IdIndex& ids = m_classes.get<Id>();
+
+    IdIndex::const_iterator it = ids.find(id);
+    if (it == ids.end())
+        return 0;
+
+    return &*it->classPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool ClassManager::classExists(const std::string& id) const
+{
+    const IdIndex& ids = m_classes.get<Id>();
+
+    return ids.find(id) != ids.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassManager::ClassManager()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassManager::~ClassManager()
+{
+    // Notify observers
+    for (ClassTable::const_iterator it = m_classes.begin(); it != m_classes.end(); ++it)
+    {
+        notifyClassRemoved(*it->classPtr);
+    }
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/src/classvisitor.cpp b/src/classvisitor.cpp
new file mode 100644
index 0000000..4c119d1
--- /dev/null
+++ b/src/classvisitor.cpp
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/classvisitor.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+ClassVisitor::~ClassVisitor()
+{
+    // Nothing to do
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const Property&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const SimpleProperty&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const ArrayProperty&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const EnumProperty&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const UserProperty&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void ClassVisitor::visit(const Function&)
+{
+    // The default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassVisitor::ClassVisitor()
+{
+    // Nothing to do
+}
+
+} // namespace camp
diff --git a/src/enum.cpp b/src/enum.cpp
new file mode 100644
index 0000000..8e7d9a0
--- /dev/null
+++ b/src/enum.cpp
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/enum.hpp>
+#include <camp/errors.hpp>
+#include <camp/detail/enummanager.hpp>
+#include <algorithm>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+const std::string& Enum::name() const
+{
+    return m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Enum::size() const
+{
+    return m_pairs.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum::Pair& Enum::pair(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_pairs.size())
+        CAMP_ERROR(OutOfRange(index, m_pairs.size()));
+
+    return m_pairs[index];
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Enum::hasName(const std::string& name) const
+{
+    const NameIndex& names = m_pairs.get<Name>();
+
+    return names.find(name) != names.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Enum::hasValue(long value) const
+{
+    const ValueIndex& values = m_pairs.get<Val>();
+
+    return values.find(value) != values.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+const std::string& Enum::name(long value) const
+{
+    const ValueIndex& values = m_pairs.get<Val>();
+
+    ValueIndex::const_iterator it = values.find(value);
+    if (it == values.end())
+        CAMP_ERROR(EnumValueNotFound(value, name()));
+
+    return it->name;
+}
+
+//-------------------------------------------------------------------------------------------------
+long Enum::value(const std::string& name) const
+{
+    const NameIndex& names = m_pairs.get<Name>();
+
+    NameIndex::const_iterator it = names.find(name);
+    if (it == names.end())
+        CAMP_ERROR(EnumNameNotFound(name, m_name));
+
+    return it->value;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Enum::operator==(const Enum& other) const
+{
+    return m_name == other.m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Enum::operator!=(const Enum& other) const
+{
+    return m_name != other.m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+Enum::Enum(const std::string& name)
+    : m_name(name)
+{
+}
+
+} // namespace camp
diff --git a/src/enumbuilder.cpp b/src/enumbuilder.cpp
new file mode 100644
index 0000000..d9a9374
--- /dev/null
+++ b/src/enumbuilder.cpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/enumbuilder.hpp>
+#include <camp/enum.hpp>
+#include <cassert>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+EnumBuilder::EnumBuilder(Enum& target)
+    : m_target(&target)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumBuilder& EnumBuilder::value(const std::string& name, long value)
+{
+    assert(!m_target->hasName(name));
+    assert(!m_target->hasValue(value));
+
+    Enum::Pair pair;
+    pair.name = name;
+    pair.value = value;
+    m_target->m_pairs.push_back(pair);
+
+    return *this;
+}
+
+} // namespace camp
diff --git a/src/enummanager.cpp b/src/enummanager.cpp
new file mode 100644
index 0000000..dddf431
--- /dev/null
+++ b/src/enummanager.cpp
@@ -0,0 +1,147 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/detail/enummanager.hpp>
+#include <camp/enum.hpp>
+#include <camp/errors.hpp>
+#include <camp/observer.hpp>
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+EnumManager& EnumManager::instance()
+{
+    static EnumManager manager;
+    return manager;
+}
+
+//-------------------------------------------------------------------------------------------------
+Enum& EnumManager::addClass(const std::string& name, const std::string& id)
+{
+    const IdIndex&   ids   = m_enums.get<Id>();
+    const NameIndex& names = m_enums.get<Name>();
+
+    // First make sure that the enum doesn't already exist
+    if ((ids.find(id) != ids.end()) || (names.find(name) != names.end()))
+        CAMP_ERROR(EnumAlreadyCreated(name, id));
+
+    // Create the new class
+    boost::shared_ptr<Enum> newEnum(new Enum(name));
+
+    // Insert it into the table
+    EnumInfo info;
+    info.id = id;
+    info.name = name;
+    info.enumPtr = newEnum;
+    m_enums.insert(info);
+
+    // Notify observers
+    notifyEnumAdded(*newEnum);
+
+    return *newEnum;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t EnumManager::count() const
+{
+    return m_enums.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum& EnumManager::getByIndex(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_enums.size())
+        CAMP_ERROR(OutOfRange(index, m_enums.size()));
+
+    EnumTable::const_iterator it = m_enums.begin();
+    std::advance(it, index);
+
+    return *it->enumPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum& EnumManager::getByName(const std::string& name) const
+{
+    const NameIndex& names = m_enums.get<Name>();
+
+    NameIndex::const_iterator it = names.find(name);
+    if (it == names.end())
+        CAMP_ERROR(EnumNotFound(name));
+
+    return *it->enumPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum& EnumManager::getById(const std::string& id) const
+{
+    const IdIndex& ids = m_enums.get<Id>();
+
+    IdIndex::const_iterator it = ids.find(id);
+    if (it == ids.end())
+        CAMP_ERROR(EnumNotFound(id));
+
+    return *it->enumPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum* EnumManager::getByIdSafe(const std::string& id) const
+{
+    const IdIndex& ids = m_enums.get<Id>();
+
+    IdIndex::const_iterator it = ids.find(id);
+    if (it == ids.end())
+        return 0;
+
+    return &*it->enumPtr;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool EnumManager::enumExists(const std::string& id) const
+{
+    const IdIndex& ids = m_enums.get<Id>();
+
+    return ids.find(id) != ids.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumManager::EnumManager()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumManager::~EnumManager()
+{
+    // Notify observers
+    for (EnumTable::const_iterator it = m_enums.begin(); it != m_enums.end(); ++it)
+    {
+        notifyEnumRemoved(*it->enumPtr);
+    }
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/src/enumobject.cpp b/src/enumobject.cpp
new file mode 100644
index 0000000..f5e869c
--- /dev/null
+++ b/src/enumobject.cpp
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/enumobject.hpp>
+#include <camp/enum.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+long EnumObject::value() const
+{
+    return m_value;
+}
+
+//-------------------------------------------------------------------------------------------------
+const std::string& EnumObject::name() const
+{
+    return m_enum->name(m_value);
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum& EnumObject::getEnum() const
+{
+    return *m_enum;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool EnumObject::operator==(const EnumObject& other) const
+{
+    return (m_enum == other.m_enum) && (m_value == other.m_value);
+}
+
+//-------------------------------------------------------------------------------------------------
+bool EnumObject::operator<(const EnumObject& other) const
+{
+    if (m_enum != other.m_enum)
+    {
+        return m_enum < other.m_enum;
+    }
+    else
+    {
+        return m_value < other.m_value;
+    }
+}
+
+} // namespace camp
diff --git a/src/enumproperty.cpp b/src/enumproperty.cpp
new file mode 100644
index 0000000..9e772a4
--- /dev/null
+++ b/src/enumproperty.cpp
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/enumproperty.hpp>
+#include <camp/classvisitor.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+EnumProperty::EnumProperty(const std::string& name, const Enum& propEnum)
+    : Property(name, enumType)
+    , m_enum(&propEnum)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumProperty::~EnumProperty()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+const Enum& EnumProperty::getEnum() const
+{
+    return *m_enum;
+}
+
+//-------------------------------------------------------------------------------------------------
+void EnumProperty::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+} // namespace camp
diff --git a/src/error.cpp b/src/error.cpp
new file mode 100644
index 0000000..a8ff069
--- /dev/null
+++ b/src/error.cpp
@@ -0,0 +1,53 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/error.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+Error::~Error() throw()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+const char* Error::what() const throw()
+{
+    return m_message.c_str();
+}
+
+//-------------------------------------------------------------------------------------------------
+const char* Error::where() const throw()
+{
+    return m_location.c_str();
+}
+
+//-------------------------------------------------------------------------------------------------
+Error::Error(const std::string& message)
+    : m_message(message)
+    , m_location("")
+{
+}
+
+} // namespace camp
diff --git a/src/errors.cpp b/src/errors.cpp
new file mode 100644
index 0000000..faed4dd
--- /dev/null
+++ b/src/errors.cpp
@@ -0,0 +1,156 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/errors.hpp>
+#include <camp/class.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+BadType::BadType(Type provided, Type expected)
+    : Error("value of type " + typeName(provided) + " couldn't be converted to type " + typeName(expected))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+BadType::BadType(const std::string& message)
+    : Error(message)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+std::string BadType::typeName(Type type)
+{
+    switch (type)
+    {
+        case noType:     return "none";
+        case boolType:   return "boolean";
+        case intType:    return "integer";
+        case realType:   return "real";
+        case stringType: return "string";
+        case enumType:   return "enum";
+        case arrayType:  return "array";
+        case userType:   return "user";
+        default:         return "unknown";
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+BadArgument::BadArgument(Type provided, Type expected, std::size_t index, const std::string& functionName)
+    : BadType("the argument #" + str(index) + " of function " + functionName +
+              " couldn't be converted from type " + typeName(provided) + " to type " + typeName(expected))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassAlreadyCreated::ClassAlreadyCreated(const std::string& name, const std::string& type)
+    : Error("a metaclass named " + name + ", or bound to the type " + type + " already exists")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassNotFound::ClassNotFound(const std::string& name)
+    : Error("the metaclass " + name + " couldn't be found")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ClassUnrelated::ClassUnrelated(const std::string& sourceClass, const std::string& requestedClass)
+    : Error("failed to convert from " + sourceClass + " to " + requestedClass + ": it is not a base nor a derived")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumAlreadyCreated::EnumAlreadyCreated(const std::string& name, const std::string& type)
+    : Error("a metaenum named " + name + ", or bound to the type " + type + " already exists")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumNameNotFound::EnumNameNotFound(const std::string& name, const std::string& enumName)
+    : Error("the value " + name + " couldn't be found in metaenum " + enumName)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumNotFound::EnumNotFound(const std::string& name)
+    : Error("the metaenum " + name + " couldn't be found")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+EnumValueNotFound::EnumValueNotFound(long value, const std::string& enumName)
+    : Error("the value " + str(value) + " couldn't be found in metaenum " + enumName)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ForbiddenCall::ForbiddenCall(const std::string& functionName)
+    : Error("the function " + functionName + " is not callable")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ForbiddenRead::ForbiddenRead(const std::string& propertyName)
+    : Error("the property " + propertyName + " is not readable")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+ForbiddenWrite::ForbiddenWrite(const std::string& propertyName)
+    : Error("the property " + propertyName + " is not writable")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+FunctionNotFound::FunctionNotFound(const std::string& name, const std::string& className)
+    : Error("the function " + name + " couldn't be found in metaclass " + className)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+NotEnoughArguments::NotEnoughArguments(const std::string& functionName, std::size_t provided, std::size_t expected)
+    : Error("not enough arguments for calling " + functionName + " - provided " + str(provided) + ", expected " + str(expected))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+NullObject::NullObject(const Class* objectClass)
+    : Error("trying to use a null metaobject of class " + (objectClass ? objectClass->name() : "unknown"))
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+OutOfRange::OutOfRange(std::size_t index, std::size_t size)
+    : Error("the index (" + str(index) + ") is out of the allowed range [0, " + str(size - 1) + "]")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+PropertyNotFound::PropertyNotFound(const std::string& name, const std::string& className)
+    : Error("the property " + name + " couldn't be found in metaclass " + className)
+{
+}
+
+} // namespace camp
diff --git a/src/function.cpp b/src/function.cpp
new file mode 100644
index 0000000..204c3f4
--- /dev/null
+++ b/src/function.cpp
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/function.hpp>
+#include <camp/classvisitor.hpp>
+#include <camp/errors.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+Function::~Function()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+const std::string& Function::name() const
+{
+    return m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t Function::argCount() const
+{
+    return m_argTypes.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+Type Function::returnType() const
+{
+    return m_returnType;
+}
+
+//-------------------------------------------------------------------------------------------------
+Type Function::argType(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_argTypes.size())
+        CAMP_ERROR(OutOfRange(index, m_argTypes.size()));
+
+    return m_argTypes[index];
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Function::callable(const UserObject& object) const
+{
+    return m_callable.get(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+Value Function::call(const UserObject& object, const Args& args) const
+{
+    // Check if the function is callable
+    if (!callable(object))
+        CAMP_ERROR(ForbiddenCall(name()));
+
+    // Check the number of arguments
+    if (args.count() < m_argTypes.size())
+        CAMP_ERROR(NotEnoughArguments(name(), args.count(), m_argTypes.size()));
+
+    // Execute the function
+    return execute(object, args);
+}
+
+//-------------------------------------------------------------------------------------------------
+void Function::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+//-------------------------------------------------------------------------------------------------
+Function::Function(const std::string& name, Type returnType, const std::vector<Type>& argTypes)
+    : m_name(name)
+    , m_returnType(returnType)
+    , m_argTypes(argTypes)
+    , m_callable(true)
+{
+}
+
+} // namespace camp
diff --git a/src/observer.cpp b/src/observer.cpp
new file mode 100644
index 0000000..075657d
--- /dev/null
+++ b/src/observer.cpp
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/observer.hpp>
+#include <camp/detail/classmanager.hpp>
+#include <camp/detail/enummanager.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+Observer::~Observer()
+{
+    // Nothing to do
+}
+
+//-------------------------------------------------------------------------------------------------
+void Observer::classAdded(const Class&)
+{
+    // Default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void Observer::classRemoved(const Class&)
+{
+    // Default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void Observer::enumAdded(const Enum&)
+{
+    // Default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+void Observer::enumRemoved(const Enum&)
+{
+    // Default implementation does nothing
+}
+
+//-------------------------------------------------------------------------------------------------
+Observer::Observer()
+{
+    // Nothing to do
+}
+
+//-------------------------------------------------------------------------------------------------
+CAMP_API void addObserver(Observer* observer)
+{
+    detail::ClassManager::instance().addObserver(observer);
+    detail::EnumManager::instance().addObserver(observer);
+}
+
+//-------------------------------------------------------------------------------------------------
+CAMP_API void removeObserver(Observer* observer)
+{
+    detail::ClassManager::instance().removeObserver(observer);
+    detail::EnumManager::instance().removeObserver(observer);
+}
+
+} // namespace camp
diff --git a/src/observernotifier.cpp b/src/observernotifier.cpp
new file mode 100644
index 0000000..009d021
--- /dev/null
+++ b/src/observernotifier.cpp
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/detail/observernotifier.hpp>
+#include <camp/observer.hpp>
+#include <cassert>
+
+
+namespace camp
+{
+namespace detail
+{
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::addObserver(Observer* observer)
+{
+    assert(observer != 0);
+
+    m_observers.insert(observer);
+}
+
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::removeObserver(Observer* observer)
+{
+    m_observers.erase(observer);
+}
+
+//-------------------------------------------------------------------------------------------------
+ObserverNotifier::ObserverNotifier()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::notifyClassAdded(const Class& theClass)
+{
+    for (ObserverSet::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
+    {
+        (*it)->classAdded(theClass);
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::notifyClassRemoved(const Class& theClass)
+{
+    for (ObserverSet::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
+    {
+        (*it)->classRemoved(theClass);
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::notifyEnumAdded(const Enum& theEnum)
+{
+    for (ObserverSet::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
+    {
+        (*it)->enumAdded(theEnum);
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void ObserverNotifier::notifyEnumRemoved(const Enum& theEnum)
+{
+    for (ObserverSet::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
+    {
+        (*it)->enumRemoved(theEnum);
+    }
+}
+
+} // namespace detail
+
+} // namespace camp
diff --git a/src/outofrange.cpp b/src/outofrange.cpp
new file mode 100644
index 0000000..002009d
--- /dev/null
+++ b/src/outofrange.cpp
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/outofrange.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+OutOfRange::OutOfRange(std::size_t index, std::size_t size)
+    : Error("the index (" + str(index) + ") is out of the allowed range [0, " + str(size - 1) + "]")
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+OutOfRange::~OutOfRange() throw()
+{
+}
+
+} // namespace camp
diff --git a/src/property.cpp b/src/property.cpp
new file mode 100644
index 0000000..c9081b0
--- /dev/null
+++ b/src/property.cpp
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/property.hpp>
+#include <camp/errors.hpp>
+#include <camp/classvisitor.hpp>
+#include <camp/userobject.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+Property::~Property()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+const std::string& Property::name() const
+{
+    return m_name;
+}
+
+//-------------------------------------------------------------------------------------------------
+Type Property::type() const
+{
+    return m_type;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Property::readable(const UserObject& object) const
+{
+    return isReadable() && m_readable.get(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Property::writable(const UserObject& object) const
+{
+    return isWritable() && m_writable.get(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+Value Property::get(const UserObject& object) const
+{
+    // Check if the property is readable
+    if (!readable(object))
+        CAMP_ERROR(ForbiddenRead(name()));
+
+    return getValue(object);
+}
+
+//-------------------------------------------------------------------------------------------------
+void Property::set(const UserObject& object, const Value& value) const
+{
+    // Check if the property is writable
+    if (!writable(object))
+        CAMP_ERROR(ForbiddenWrite(name()));
+
+    // Here we don't call setValue directly, we rather let the user object do it
+    // and add any processing needed for proper propagation of the modification
+    object.set(*this, value);
+}
+
+//-------------------------------------------------------------------------------------------------
+void Property::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Property::isReadable() const
+{
+    return true;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Property::isWritable() const
+{
+    return true;
+}
+
+//-------------------------------------------------------------------------------------------------
+Property::Property(const std::string& name, Type type)
+    : m_name(name)
+    , m_type(type)
+    , m_readable(true)
+    , m_writable(true)
+{
+}
+
+} // namespace camp
diff --git a/src/simpleproperty.cpp b/src/simpleproperty.cpp
new file mode 100644
index 0000000..c963c45
--- /dev/null
+++ b/src/simpleproperty.cpp
@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/simpleproperty.hpp>
+#include <camp/classvisitor.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+SimpleProperty::SimpleProperty(const std::string& name, Type type)
+    : Property(name, type)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+SimpleProperty::~SimpleProperty()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+void SimpleProperty::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+} // namespace camp
diff --git a/src/tagholder.cpp b/src/tagholder.cpp
new file mode 100644
index 0000000..c305980
--- /dev/null
+++ b/src/tagholder.cpp
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/tagholder.hpp>
+#include <camp/value.hpp>
+#include <camp/errors.hpp>
+#include <algorithm>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+TagHolder::~TagHolder()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+std::size_t TagHolder::tagCount() const
+{
+    return m_tags.size();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Value& TagHolder::tagId(std::size_t index) const
+{
+    // Make sure that the index is not out of range
+    if (index >= m_tags.size())
+        CAMP_ERROR(OutOfRange(index, m_tags.size()));
+
+    TagsTable::const_iterator it = m_tags.begin();
+    std::advance(it, index);
+
+    return it->first;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool TagHolder::hasTag(const Value& id) const
+{
+    return m_tags.find(id) != m_tags.end();
+}
+
+//-------------------------------------------------------------------------------------------------
+const Value& TagHolder::tag(const Value& id) const
+{
+    TagsTable::const_iterator it = m_tags.find(id);
+    if (it != m_tags.end())
+        return it->second.get();
+
+    return Value::nothing;
+}
+
+//-------------------------------------------------------------------------------------------------
+Value TagHolder::tag(const Value& id, const UserObject& object) const
+{
+    TagsTable::const_iterator it = m_tags.find(id);
+    if (it != m_tags.end())
+        return it->second.get(object);
+
+    return Value::nothing;
+}
+
+//-------------------------------------------------------------------------------------------------
+TagHolder::TagHolder()
+{
+}
+
+} // namespace camp
diff --git a/src/userobject.cpp b/src/userobject.cpp
new file mode 100644
index 0000000..6b1ea2f
--- /dev/null
+++ b/src/userobject.cpp
@@ -0,0 +1,244 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/userobject.hpp>
+#include <camp/userproperty.hpp>
+#include <camp/class.hpp>
+#include <camp/function.hpp>
+#include <camp/property.hpp>
+
+
+namespace camp
+{
+const UserObject UserObject::nothing;
+
+//-------------------------------------------------------------------------------------------------
+UserObject::UserObject()
+    : m_class(0)
+    , m_holder()
+    , m_parent()
+    , m_child(0)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+UserObject::UserObject(const UserObject& parent, const UserProperty& member)
+    : m_class(&member.getClass())
+    , m_holder()
+    , m_parent(new ParentObject(parent, member))
+    , m_child(0)
+{
+    m_parent->object.m_child = this;
+}
+
+//-------------------------------------------------------------------------------------------------
+UserObject::UserObject(const UserObject& copy)
+    : m_class(copy.m_class)
+    , m_holder(copy.m_holder)
+    , m_parent(copy.m_parent ? new ParentObject(copy.m_parent->object, copy.m_parent->member) : 0)
+{
+    if (m_parent)
+        m_parent->object.m_child = this;
+}
+
+//-------------------------------------------------------------------------------------------------
+void* UserObject::pointer() const
+{
+    if (m_holder)
+    {
+        return m_holder->object();
+    }
+    else if (m_parent)
+    {
+        // warning: this may not be multi-thread safe,
+        // but it is required to make the returned value persistent
+        m_parent->lastValue = m_parent->member.get(m_parent->object).to<UserObject>();
+        return m_parent->lastValue.pointer();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& UserObject::getClass() const
+{
+    if (m_class)
+    {
+        return *m_class;
+    }
+    else
+    {
+        CAMP_ERROR(NullObject(m_class));
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+Value UserObject::get(const std::string& property) const
+{
+    return getClass().property(property).get(*this);
+}
+
+//-------------------------------------------------------------------------------------------------
+void UserObject::set(const std::string& property, const Value& value) const
+{
+    getClass().property(property).set(*this, value);
+}
+
+//-------------------------------------------------------------------------------------------------
+Value UserObject::call(const std::string& function, const Args& args) const
+{
+    return getClass().function(function).call(*this, args);
+}
+
+//-------------------------------------------------------------------------------------------------
+UserObject& UserObject::operator=(const UserObject& other)
+{
+    boost::scoped_ptr<ParentObject> parent(other.m_parent ? new ParentObject(other.m_parent->object, other.m_parent->member) : 0);
+
+    m_class = other.m_class;
+    m_holder = other.m_holder;
+    m_parent.swap(parent);
+    m_child = 0;
+
+    if (m_parent)
+        m_parent->object.m_child = this;
+
+    return *this;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool UserObject::operator==(const UserObject& other) const
+{
+    if (m_holder && other.m_holder)
+    {
+        return m_holder->object() == other.m_holder->object();
+    }
+    else if (m_parent && other.m_parent)
+    {
+        return (&m_parent->member == &other.m_parent->member) && (m_parent->object == other.m_parent->object);
+    }
+    else if (!m_class && !other.m_class)
+    {
+        // Both are UserObject::nothing
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+bool UserObject::operator<(const UserObject& other) const
+{
+    if (m_holder)
+    {
+        if (other.m_holder)
+        {
+            return m_holder->object() < other.m_holder->object();
+        }
+        else
+        {
+            return other.m_parent != 0;
+        }
+    }
+    else if (m_parent)
+    {
+        if (other.m_parent)
+        {
+            if (&m_parent->member != &other.m_parent->member)
+                return &m_parent->member < &other.m_parent->member;
+            else
+                return m_parent->object < other.m_parent->object;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        return other.m_holder || other.m_parent;
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void UserObject::set(const Property& property, const Value& value) const
+{
+    if (m_holder)
+    {
+        // Just forward to the property, no extra processing required
+        property.setValue(*this, value);
+    }
+    else if (m_parent)
+    {
+        // Find the root object
+        const UserObject* root = this;
+        while (root->m_parent->object.m_parent)
+            root = &root->m_parent->object;
+
+        // Launch the recursive process
+        root->cascadeSet(root->m_parent->object, property, value);
+    }
+    else
+    {
+        // Error, null object
+        CAMP_ERROR(NullObject(m_class));
+    }
+}
+
+//-------------------------------------------------------------------------------------------------
+void UserObject::cascadeSet(const UserObject& object, const Property& property, const Value& value) const
+{
+    // @todo Manually check the access (read / write) to the properties,
+    // as we bypass the standard path?
+
+    // Get the temporary object to modify
+    UserObject sub = m_parent->member.getValue(object).to<UserObject>();
+
+    // Make sure that the underlying object is *really* modifiable.
+    // If m_holder was holding a const reference to an object, this will
+    // replace it with a holder storing a copy of the object.
+    detail::AbstractObjectHolder* holder = sub.m_holder->getWritable();
+    bool same = (holder == sub.m_holder.get());
+    if (!same)
+        sub.m_holder.reset(holder);
+
+    if (m_child)
+    {
+        // ...continue to recurse if it's not the actual property to modify
+        m_child->cascadeSet(sub, property, value);
+    }
+    else
+    {
+        // ...apply the value if it's the actual property to modify
+        property.setValue(sub, value);
+    }
+
+    // Assign the modified object back to its parent
+    m_parent->member.setValue(object, sub);
+}
+
+} // namespace camp
diff --git a/src/userproperty.cpp b/src/userproperty.cpp
new file mode 100644
index 0000000..56dde3d
--- /dev/null
+++ b/src/userproperty.cpp
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#include <camp/userproperty.hpp>
+#include <camp/classvisitor.hpp>
+
+
+namespace camp
+{
+//-------------------------------------------------------------------------------------------------
+UserProperty::UserProperty(const std::string& name, const Class& propClass)
+    : Property(name, userType)
+    , m_class(&propClass)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+UserProperty::~UserProperty()
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+const Class& UserProperty::getClass() const
+{
+    return *m_class;
+}
+
+//-------------------------------------------------------------------------------------------------
+void UserProperty::accept(ClassVisitor& visitor) const
+{
+    visitor.visit(*this);
+}
+
+} // namespace camp
diff --git a/src/value.cpp b/src/value.cpp
new file mode 100644
index 0000000..d79df15
--- /dev/null
+++ b/src/value.cpp
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+
+#include <camp/value.hpp>
+#include <iostream>
+
+
+namespace camp
+{
+const Value Value::nothing;
+
+//-------------------------------------------------------------------------------------------------
+Value::Value()
+    : m_value(NoType())
+    , m_type(noType)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+Value::Value(const Value& other)
+    : m_value(other.m_value)
+    , m_type(other.m_type)
+{
+}
+
+//-------------------------------------------------------------------------------------------------
+Type Value::type() const
+{
+    return m_type;
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Value::operator==(const Value& other) const
+{
+    return visit(detail::EqualVisitor(), other);
+}
+
+//-------------------------------------------------------------------------------------------------
+bool Value::operator<(const Value& other) const
+{
+    return visit(detail::LessThanVisitor(), other);
+}
+
+//-------------------------------------------------------------------------------------------------
+std::istream& operator>>(std::istream& stream, Value& value)
+{
+    // Use the string conversion
+    std::string str;
+    if (stream >> str)
+        value = str;
+
+    return stream;
+}
+
+//-------------------------------------------------------------------------------------------------
+std::ostream& operator<<(std::ostream& stream, const Value& value)
+{
+    // Use the string conversion
+    return stream << value.to<std::string>();
+}
+
+} // namespace camp
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..76dd4de
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,96 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+cmake_minimum_required(VERSION 2.6)
+
+# set project's name
+project(CAMP_TEST)
+
+# all source files
+set(CAMP_TEST_SRCS
+    main.cpp
+    arrayproperty.cpp
+    arrayproperty.hpp
+    class.cpp
+    class.hpp
+    enum.cpp
+    enum.hpp
+    enumobject.cpp
+    enumobject.hpp
+    enumproperty.cpp
+    enumproperty.hpp
+    tagholder.cpp
+    tagholder.hpp
+    value.cpp
+    value.hpp
+    property.cpp
+    property.hpp
+    classvisitor.cpp
+    classvisitor.hpp
+    constructor.cpp
+    constructor.hpp
+    mapper.cpp
+    mapper.hpp
+    inheritance.cpp
+    inheritance.hpp
+    userobject.cpp
+    userobject.hpp
+    propertyaccess.cpp
+    propertyaccess.hpp
+    functionaccess.cpp
+    functionaccess.hpp
+)
+
+# find Boost
+find_package(Boost 1.38.0)
+
+# include files search paths
+include_directories(
+    ${CAMP_SOURCE_DIR}/include
+    ${Boost_INCLUDE_DIRS}
+)
+
+# linker search paths
+link_directories(
+    ${CAMP_BINARY_DIR}
+)
+
+# no implicit link to boost.test library
+add_definitions(-DBOOST_TEST_NO_LIB)
+
+# instruct CMake to build an executable from all of the source files
+add_executable(camptest ${CAMP_TEST_SRCS})
+
+# define d suffix on windows
+if(WIN32)
+    set_target_properties(camptest PROPERTIES DEBUG_POSTFIX d)
+endif()
+
+# last thing we have to do is to tell CMake what libraries our executable needs,
+target_link_libraries(camptest camp)
+
+# add the qt subdirectory, but do not build it by default
+if(BUILD_TEST_QT)
+    add_subdirectory(qt)
+endif()
+
diff --git a/test/arrayproperty.cpp b/test/arrayproperty.cpp
new file mode 100644
index 0000000..6fa1b7b
--- /dev/null
+++ b/test/arrayproperty.cpp
@@ -0,0 +1,178 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "arrayproperty.hpp"
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <camp/arrayproperty.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace ArrayPropertyTest;
+
+//-----------------------------------------------------------------------------
+struct ArrayPropertyFixture
+{
+    ArrayPropertyFixture()
+    {
+        const camp::Class& metaclass = camp::classByType<MyClass>();
+        bools   = &static_cast<const camp::ArrayProperty&>(metaclass.property("bools"));
+        ints    = &static_cast<const camp::ArrayProperty&>(metaclass.property("ints"));
+        strings = &static_cast<const camp::ArrayProperty&>(metaclass.property("strings"));
+        objects = &static_cast<const camp::ArrayProperty&>(metaclass.property("objects"));
+    }
+
+    const camp::ArrayProperty* bools;
+    const camp::ArrayProperty* ints;
+    const camp::ArrayProperty* strings;
+    const camp::ArrayProperty* objects;
+    MyClass object;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::ArrayProperty
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(ARRAYPROPERTY, ArrayPropertyFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(bools->type(),   camp::arrayType);
+    BOOST_CHECK_EQUAL(ints->type(),    camp::arrayType);
+    BOOST_CHECK_EQUAL(strings->type(), camp::arrayType);
+    BOOST_CHECK_EQUAL(objects->type(), camp::arrayType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(elementType)
+{
+    BOOST_CHECK_EQUAL(bools->elementType(),   camp::boolType);
+    BOOST_CHECK_EQUAL(ints->elementType(),    camp::intType);
+    BOOST_CHECK_EQUAL(strings->elementType(), camp::stringType);
+    BOOST_CHECK_EQUAL(objects->elementType(), camp::userType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(dynamic)
+{
+    BOOST_CHECK_EQUAL(bools->dynamic(),   false);
+    BOOST_CHECK_EQUAL(ints->dynamic(),    false);
+    BOOST_CHECK_EQUAL(strings->dynamic(), true);
+    BOOST_CHECK_EQUAL(objects->dynamic(), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(size)
+{
+    BOOST_CHECK_EQUAL(bools->size(object),   boost::size(object.bools));
+    BOOST_CHECK_EQUAL(ints->size(object),    object.ints.size());
+    BOOST_CHECK_EQUAL(strings->size(object), object.strings.size());
+    BOOST_CHECK_EQUAL(objects->size(object), object.objects.size());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    BOOST_CHECK_EQUAL(bools->get(object, 0), camp::Value(object.bools[0]));
+    BOOST_CHECK_EQUAL(bools->get(object, 1), camp::Value(object.bools[1]));
+    BOOST_CHECK_THROW(bools->get(object, 2), camp::OutOfRange);
+
+    BOOST_CHECK_EQUAL(ints->get(object, 0), camp::Value(object.ints[0]));
+    BOOST_CHECK_EQUAL(ints->get(object, 1), camp::Value(object.ints[1]));
+    BOOST_CHECK_EQUAL(ints->get(object, 2), camp::Value(object.ints[2]));
+    BOOST_CHECK_THROW(ints->get(object, 3), camp::OutOfRange);
+
+    BOOST_CHECK_EQUAL(strings->get(object, 0), camp::Value(object.strings[0]));
+    BOOST_CHECK_EQUAL(strings->get(object, 1), camp::Value(object.strings[1]));
+    BOOST_CHECK_EQUAL(strings->get(object, 2), camp::Value(object.strings[2]));
+    BOOST_CHECK_EQUAL(strings->get(object, 3), camp::Value(object.strings[3]));
+    BOOST_CHECK_THROW(strings->get(object, 4), camp::OutOfRange);
+
+    std::list<MyType>::const_iterator it = object.objects.begin();
+    BOOST_CHECK_EQUAL(objects->get(object, 0), camp::Value(*boost::next(it, 0)));
+    BOOST_CHECK_EQUAL(objects->get(object, 1), camp::Value(*boost::next(it, 1)));
+    BOOST_CHECK_EQUAL(objects->get(object, 2), camp::Value(*boost::next(it, 2)));
+    BOOST_CHECK_EQUAL(objects->get(object, 3), camp::Value(*boost::next(it, 3)));
+    BOOST_CHECK_EQUAL(objects->get(object, 4), camp::Value(*boost::next(it, 4)));
+    BOOST_CHECK_THROW(objects->get(object, 5), camp::OutOfRange);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    bools->set(object, 1, true);
+    ints->set(object, 1, 20);
+    strings->set(object, 1, "hello");
+    objects->set(object, 1, MyType(8));
+
+    BOOST_CHECK_EQUAL(object.bools[1],   true);
+    BOOST_CHECK_EQUAL(object.ints[1],    20);
+    BOOST_CHECK_EQUAL(object.strings[1], "hello");
+    BOOST_CHECK(*boost::next(object.objects.begin(), 1) == MyType(8));
+
+    BOOST_CHECK_THROW(bools->set(object, 10, true),        camp::OutOfRange);
+    BOOST_CHECK_THROW(ints->set(object, 10, 1),            camp::OutOfRange);
+    BOOST_CHECK_THROW(strings->set(object, 10, "hi"),      camp::OutOfRange);
+    BOOST_CHECK_THROW(objects->set(object, 10, MyType(9)), camp::OutOfRange);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(insert)
+{
+    BOOST_CHECK_THROW(bools->insert(object, 0, true), camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(ints->insert(object, 0, true),  camp::ForbiddenWrite);
+
+    std::size_t stringsSize = object.strings.size();
+    std::size_t objectsSize = object.objects.size();
+
+    strings->insert(object, 1, "bonjour");
+    objects->insert(object, 1, MyType(10));
+
+    BOOST_CHECK_EQUAL(object.strings.size(), stringsSize + 1);
+    BOOST_CHECK_EQUAL(object.objects.size(), objectsSize + 1);
+
+    BOOST_CHECK_EQUAL(object.strings[1], "bonjour");
+    BOOST_CHECK(*boost::next(object.objects.begin(), 1) == MyType(10));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(remove)
+{
+    BOOST_CHECK_THROW(bools->remove(object, 0), camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(ints->remove(object, 0),  camp::ForbiddenWrite);
+
+    std::string string1 = object.strings[1];
+    MyType      object1 = *boost::next(object.objects.begin(), 1);
+
+    std::size_t stringsSize = object.strings.size();
+    std::size_t objectsSize = object.objects.size();
+
+    strings->remove(object, 0);
+    objects->remove(object, 0);
+
+    BOOST_CHECK_EQUAL(object.strings.size(), stringsSize - 1);
+    BOOST_CHECK_EQUAL(object.objects.size(), objectsSize - 1);
+
+    BOOST_CHECK(object.strings.front() == string1);
+    BOOST_CHECK(object.objects.front() == object1);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/arrayproperty.hpp b/test/arrayproperty.hpp
new file mode 100644
index 0000000..b619e0c
--- /dev/null
+++ b/test/arrayproperty.hpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_ARRAYPROPERTY_HPP
+#define CAMPTEST_ARRAYPROPERTY_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <boost/array.hpp>
+#include <list>
+#include <vector>
+
+namespace ArrayPropertyTest
+{
+    struct MyType
+    {
+        MyType(int x_) : x(x_)
+        {
+        }
+
+        bool operator ==(const MyType& other) const
+        {
+            return x == other.x;
+        }
+
+        int x;
+    };
+
+    struct MyClass
+    {
+        MyClass()
+        {
+            bools[0] = true;
+            bools[1] = false;
+
+            ints[0] = -10;
+            ints[1] = 10;
+            ints[2] = 100;
+
+            strings.push_back("string 0");
+            strings.push_back("string 1");
+            strings.push_back("string 2");
+            strings.push_back("string 3");
+
+            objects.push_back(MyType(0));
+            objects.push_back(MyType(1));
+            objects.push_back(MyType(2));
+            objects.push_back(MyType(3));
+            objects.push_back(MyType(4));
+        }
+
+        bool bools[2];
+        boost::array<int, 3> ints;
+        std::vector<std::string> strings;
+        std::list<MyType> objects;
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyType>("ArrayPropertyTest::MyType");
+
+        camp::Class::declare<MyClass>("ArrayPropertyTest::MyClass")
+            .property("bools", &MyClass::bools)
+            .property("ints", &MyClass::ints)
+            .property("strings", &MyClass::strings)
+            .property("objects", &MyClass::objects);
+    }
+}
+
+CAMP_AUTO_TYPE(ArrayPropertyTest::MyType, &ArrayPropertyTest::declare)
+CAMP_AUTO_TYPE(ArrayPropertyTest::MyClass, &ArrayPropertyTest::declare)
+
+#endif // CAMPTEST_ARRAYPROPERTY_HPP
diff --git a/test/class.cpp b/test/class.cpp
new file mode 100644
index 0000000..aaac577
--- /dev/null
+++ b/test/class.cpp
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "class.hpp"
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace ClassTest;
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Class
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_SUITE(CLASS)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(declare)
+{
+    std::size_t count = camp::classCount();
+
+    camp::Class::declare<MyTempClass>("ClassTest::MyTempClass");
+
+    BOOST_CHECK_EQUAL(camp::classCount(), count + 1);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(declareExceptions)
+{
+    // to make sure it is declared
+    camp::classByType<MyClass>();
+
+    BOOST_CHECK_THROW(camp::Class::declare<MyClass>("ClassTest::MyUndeclaredClass"), camp::ClassAlreadyCreated);
+    BOOST_CHECK_THROW(camp::Class::declare<MyUndeclaredClass>("ClassTest::MyClass"), camp::ClassAlreadyCreated);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    MyClass object;
+    MyUndeclaredClass object2;
+
+    BOOST_CHECK_EQUAL(camp::classByName("ClassTest::MyClass").name(), "ClassTest::MyClass");
+    BOOST_CHECK_EQUAL(camp::classByType<MyClass>().name(),            "ClassTest::MyClass");
+    BOOST_CHECK_EQUAL(camp::classByObject(object).name(),             "ClassTest::MyClass");
+    BOOST_CHECK_EQUAL(camp::classByObject(&object).name(),            "ClassTest::MyClass");
+    BOOST_CHECK_EQUAL(camp::classByTypeSafe<MyUndeclaredClass>(),     static_cast<camp::Class*>(0));
+
+    BOOST_CHECK_THROW(camp::classByName("ClassTest::MyUndeclaredClass"), camp::ClassNotFound);
+    BOOST_CHECK_THROW(camp::classByType<MyUndeclaredClass>(),            camp::ClassNotFound);
+    BOOST_CHECK_THROW(camp::classByObject(object2),                      camp::ClassNotFound);
+    BOOST_CHECK_THROW(camp::classByObject(&object2),                     camp::ClassNotFound);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(comparisons)
+{
+    const camp::Class& class1 = camp::classByType<MyClass>();
+    const camp::Class& class2 = camp::classByType<MyClass2>();
+
+    BOOST_CHECK(class1 == class1);
+    BOOST_CHECK(class1 != class2);
+    BOOST_CHECK(class2 != class1);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(properties)
+{
+    const camp::Class& metaclass = camp::classByType<MyClass>();
+
+    BOOST_CHECK_EQUAL(metaclass.propertyCount(), 1U);
+    BOOST_CHECK_EQUAL(metaclass.hasProperty("prop"), true);
+    BOOST_CHECK_EQUAL(metaclass.hasProperty("xxxx"), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(functions)
+{
+    const camp::Class& metaclass = camp::classByType<MyClass>();
+
+    BOOST_CHECK_EQUAL(metaclass.functionCount(), 1U);
+    BOOST_CHECK_EQUAL(metaclass.hasFunction("func"), true);
+    BOOST_CHECK_EQUAL(metaclass.hasFunction("xxxx"), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(inheritance)
+{
+    const camp::Class& derived = camp::classByType<Derived>();
+
+    BOOST_CHECK_EQUAL(derived.baseCount(), 1U);
+    BOOST_CHECK_EQUAL(derived.base(0).name(), "ClassTest::Base");
+    BOOST_CHECK_THROW(derived.base(1), camp::OutOfRange);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(rtti)
+{
+    Base* base    = new Base;
+    Base* derived = new Derived;
+    Base* nortti  = new DerivedNoRtti;
+    Base* nortti2 = new Derived2NoRtti;
+
+    BOOST_CHECK_EQUAL(camp::classByObject(base).name(),     "ClassTest::Base");    // base is really a base
+    BOOST_CHECK_EQUAL(camp::classByObject(*base).name(),    "ClassTest::Base");
+    BOOST_CHECK_EQUAL(camp::classByObject(derived).name(),  "ClassTest::Derived"); // CAMP finds its real type thanks to CAMP_RTTI
+    BOOST_CHECK_EQUAL(camp::classByObject(*derived).name(), "ClassTest::Derived");
+    BOOST_CHECK_EQUAL(camp::classByObject(nortti).name(),   "ClassTest::Base");    // CAMP fails to find its derived type without CAMP_RTTI
+    BOOST_CHECK_EQUAL(camp::classByObject(*nortti).name(),  "ClassTest::Base");
+    BOOST_CHECK_EQUAL(camp::classByObject(nortti2).name(),  "ClassTest::Derived"); // CAMP finds the closest derived type which has CAMP_RTTI
+    BOOST_CHECK_EQUAL(camp::classByObject(*nortti2).name(), "ClassTest::Derived");
+
+    delete nortti2;
+    delete nortti;
+    delete derived;
+    delete base;
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/class.hpp b/test/class.hpp
new file mode 100644
index 0000000..cfd76eb
--- /dev/null
+++ b/test/class.hpp
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_CLASS_HPP
+#define CAMPTEST_CLASS_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+
+namespace ClassTest
+{
+    struct MyTempClass
+    {
+    };
+
+    struct MyUndeclaredClass
+    {
+    };
+
+    struct MyClass
+    {
+        void func() {}
+        int prop;
+    };
+
+    struct MyClass2
+    {
+    };
+
+    struct Base
+    {
+        CAMP_RTTI();
+    };
+
+    struct Derived : Base
+    {
+        CAMP_RTTI();
+    };
+
+    struct DerivedNoRtti : Base
+    {
+    };
+
+    struct Derived2NoRtti : Derived
+    {
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyClass>("ClassTest::MyClass")
+            .property("prop", &MyClass::prop)
+            .function("func", &MyClass::func);
+
+        camp::Class::declare<MyClass2>("ClassTest::MyClass2");
+
+        camp::Class::declare<Base>("ClassTest::Base");
+
+        camp::Class::declare<Derived>("ClassTest::Derived")
+            .base<Base>();
+
+        camp::Class::declare<DerivedNoRtti>("ClassTest::DerivedNoRtti")
+            .base<Base>();
+
+        camp::Class::declare<Derived2NoRtti>("ClassTest::Derived2NoRtti")
+            .base<Derived>();
+    }
+}
+
+CAMP_TYPE(ClassTest::MyUndeclaredClass /* never declared */)
+CAMP_TYPE(ClassTest::MyTempClass /* declared in a test */)
+CAMP_AUTO_TYPE(ClassTest::MyClass, &ClassTest::declare)
+CAMP_AUTO_TYPE(ClassTest::MyClass2, &ClassTest::declare)
+CAMP_AUTO_TYPE(ClassTest::Base, &ClassTest::declare)
+CAMP_AUTO_TYPE(ClassTest::Derived, &ClassTest::declare)
+CAMP_AUTO_TYPE(ClassTest::DerivedNoRtti, &ClassTest::declare)
+CAMP_AUTO_TYPE(ClassTest::Derived2NoRtti, &ClassTest::declare)
+
+#endif // CAMPTEST_CLASS_HPP
diff --git a/test/classvisitor.cpp b/test/classvisitor.cpp
new file mode 100644
index 0000000..c4293d7
--- /dev/null
+++ b/test/classvisitor.cpp
@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "classvisitor.hpp"
+#include <camp/classget.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace ClassVisitorTest;
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::ClassVisitor
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_SUITE(CLASSVISITOR)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(visit)
+{
+    MyClassVisitor visitor;
+    camp::classByType<MyClass>().visit(visitor);
+
+    BOOST_CHECK(visitor.simpleVisited);
+    BOOST_CHECK(visitor.arrayVisited);
+    BOOST_CHECK(visitor.enumVisited);
+    BOOST_CHECK(visitor.userVisited);
+    BOOST_CHECK(visitor.functionVisited);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/classvisitor.hpp b/test/classvisitor.hpp
new file mode 100644
index 0000000..8c2a93d
--- /dev/null
+++ b/test/classvisitor.hpp
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_CLASSVISITOR_HPP
+#define CAMPTEST_CLASSVISITOR_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/enum.hpp>
+#include <camp/classvisitor.hpp>
+#include <camp/simpleproperty.hpp>
+#include <camp/arrayproperty.hpp>
+#include <camp/enumproperty.hpp>
+#include <camp/userproperty.hpp>
+#include <camp/function.hpp>
+
+namespace ClassVisitorTest
+{
+    class MyClassVisitor : public camp::ClassVisitor
+    {
+    public:
+
+        MyClassVisitor()
+            : simpleVisited(false)
+            , arrayVisited(false)
+            , enumVisited(false)
+            , userVisited(false)
+            , functionVisited(false)
+        {
+        }
+
+        virtual void visit(const camp::SimpleProperty& property)
+        {
+            simpleVisited = true;
+        }
+
+        virtual void visit(const camp::ArrayProperty& property)
+        {
+            arrayVisited = true;
+        }
+
+        virtual void visit(const camp::EnumProperty& property)
+        {
+            enumVisited = true;
+        }
+
+        virtual void visit(const camp::UserProperty& property)
+        {
+            userVisited = true;
+        }
+
+        virtual void visit(const camp::Function& function)
+        {
+            functionVisited = true;
+        }
+
+        bool simpleVisited;
+        bool arrayVisited;
+        bool enumVisited;
+        bool userVisited;
+        bool functionVisited;
+    };
+
+    enum MyEnum
+    {
+    };
+
+    struct MyType
+    {
+    };
+
+    struct MyClass
+    {
+        int simpleProp;
+        std::string arrayProp[5];
+        MyEnum enumProp;
+        MyType userProp;
+        void function() {}
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("ClassVisitorTest::MyEnum");
+
+        camp::Class::declare<MyType>("ClassVisitorTest::MyType");
+
+        camp::Class::declare<MyClass>("ClassVisitorTest::MyClass")
+            .property("simple", &MyClass::simpleProp)
+            .property("array", &MyClass::arrayProp)
+            .property("enum", &MyClass::enumProp)
+            .property("user", &MyClass::userProp)
+            .function("function", &MyClass::function);
+    }
+}
+
+CAMP_AUTO_TYPE(ClassVisitorTest::MyEnum, &ClassVisitorTest::declare)
+CAMP_AUTO_TYPE(ClassVisitorTest::MyType, &ClassVisitorTest::declare)
+CAMP_AUTO_TYPE(ClassVisitorTest::MyClass, &ClassVisitorTest::declare)
+
+#endif // CAMPTEST_CLASSVISITOR_HPP
diff --git a/test/constructor.cpp b/test/constructor.cpp
new file mode 100644
index 0000000..cf74010
--- /dev/null
+++ b/test/constructor.cpp
@@ -0,0 +1,163 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "constructor.hpp"
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace ConstructorTest;
+
+//-----------------------------------------------------------------------------
+struct ConstructorFixture
+{
+    ConstructorFixture()
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Constructor
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(CONSTRUCTOR, ConstructorFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(invalidConstructions)
+{
+    BOOST_CHECK_EQUAL(metaclass->construct(camp::Args("hello")),         camp::UserObject::nothing);
+    BOOST_CHECK_EQUAL(metaclass->construct(camp::Args(MyType(10))),      camp::UserObject::nothing);
+    BOOST_CHECK_EQUAL(metaclass->construct(camp::Args(two, MyType(10))), camp::UserObject::nothing);
+    BOOST_CHECK_EQUAL(metaclass->construct(camp::Args(5., "hello")),     camp::UserObject::nothing);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(zeroArg)
+{
+    camp::UserObject object = metaclass->construct();
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 0);
+    BOOST_CHECK_CLOSE(instance->r, 0., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "0");
+    BOOST_CHECK_EQUAL(instance->e, zero);
+    BOOST_CHECK_EQUAL(instance->u.x, 0);
+
+    metaclass->destroy(object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(oneArg)
+{
+    camp::UserObject object = metaclass->construct(camp::Args(1)).get<MyClass*>();
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 1);
+    BOOST_CHECK_CLOSE(instance->r, 1., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "1");
+    BOOST_CHECK_EQUAL(instance->e, one);
+    BOOST_CHECK_EQUAL(instance->u.x, 1);
+
+    metaclass->destroy(object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(twoArgs)
+{
+    camp::UserObject object = metaclass->construct(camp::Args(2, 2.));
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 2);
+    BOOST_CHECK_CLOSE(instance->r, 2., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "2");
+    BOOST_CHECK_EQUAL(instance->e, two);
+    BOOST_CHECK_EQUAL(instance->u.x, 2);
+
+    metaclass->destroy(object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(threeArgs)
+{
+    camp::UserObject object = metaclass->construct(camp::Args(3, 3., "3"));
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 3);
+    BOOST_CHECK_CLOSE(instance->r, 3., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "3");
+    BOOST_CHECK_EQUAL(instance->e, three);
+    BOOST_CHECK_EQUAL(instance->u.x, 3);
+
+    metaclass->destroy(object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(fourArgs)
+{
+    camp::UserObject object = metaclass->construct(camp::Args(4, 4., "4", four));
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 4);
+    BOOST_CHECK_CLOSE(instance->r, 4., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "4");
+    BOOST_CHECK_EQUAL(instance->e, four);
+    BOOST_CHECK_EQUAL(instance->u.x, 4);
+
+    metaclass->destroy(object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(fiveArgs)
+{
+    camp::UserObject object = metaclass->construct(camp::Args(5, 5., "5", five, 5));
+
+    BOOST_CHECK(object != camp::UserObject::nothing);
+
+    MyClass* instance = object.get<MyClass*>();
+
+    BOOST_CHECK_EQUAL(instance->l, 5);
+    BOOST_CHECK_CLOSE(instance->r, 5., 1E-5);
+    BOOST_CHECK_EQUAL(instance->s, "5");
+    BOOST_CHECK_EQUAL(instance->e, five);
+    BOOST_CHECK_EQUAL(instance->u.x, 5);
+
+    metaclass->destroy(object);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/constructor.hpp b/test/constructor.hpp
new file mode 100644
index 0000000..d322b8b
--- /dev/null
+++ b/test/constructor.hpp
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_CONSTRUCTOR_HPP
+#define CAMPTEST_CONSTRUCTOR_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/enum.hpp>
+#include <string>
+
+namespace ConstructorTest
+{
+    enum MyEnum
+    {
+        zero  = 0,
+        one   = 1,
+        two   = 2,
+        three = 3,
+        four  = 4,
+        five  = 5
+    };
+
+    struct MyType
+    {
+        MyType(int x_) : x(x_) {}
+        int x;
+    };
+
+    struct MyBase1
+    {
+        MyBase1() : base1("base1") {}
+        virtual ~MyBase1() {}
+        std::string base1;
+    };
+
+    struct MyBase2
+    {
+        MyBase2() : base2("base2") {}
+        virtual ~MyBase2() {}
+        std::string base2;
+    };
+
+    struct MyClass : MyBase1, MyBase2
+    {
+        MyClass() : l(0), r(0.), s("0"), e(zero), u(0) {}
+        MyClass(long l_) : l(l_), r(1.), s("1"), e(one), u(1) {}
+        MyClass(long l_, double r_) : l(l_), r(r_), s("2"), e(two), u(2) {}
+        MyClass(long l_, double r_, std::string s_) : l(l_), r(r_), s(s_), e(three), u(3) {}
+        MyClass(long l_, double r_, std::string s_, MyEnum e_) : l(l_), r(r_), s(s_), e(e_), u(4) {}
+        MyClass(long l_, double r_, std::string s_, MyEnum e_, MyType t_) : l(l_), r(r_), s(s_), e(e_), u(t_) {}
+
+        long l;
+        double r;
+        std::string s;
+        MyEnum e;
+        MyType u;
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("ConstructorTest::MyEnum")
+            .value("zero",  zero)
+            .value("one",   one)
+            .value("two",   two)
+            .value("three", three)
+            .value("four",  four)
+            .value("five",  five);
+
+        camp::Class::declare<MyType>("ConstructorTest::MyType");
+
+        camp::Class::declare<MyBase1>("ConstructorTest::MyBase1");
+        camp::Class::declare<MyBase2>("ConstructorTest::MyBase2");
+
+        camp::Class::declare<MyClass>("ConstructorTest::MyClass")
+            .base<MyBase1>()
+            .base<MyBase2>()
+            .constructor0()
+            .constructor1<long>()
+            .constructor2<long, double>()
+            .constructor3<long, double, std::string>()
+            .constructor4<long, double, std::string, MyEnum>()
+
+            // trying types that don't exactly match those declared
+            .constructor5<unsigned short, float, std::string, MyEnum, int>();
+    }
+}
+
+CAMP_AUTO_TYPE(ConstructorTest::MyEnum, &ConstructorTest::declare)
+CAMP_AUTO_TYPE(ConstructorTest::MyType, &ConstructorTest::declare)
+CAMP_AUTO_TYPE(ConstructorTest::MyBase1, &ConstructorTest::declare)
+CAMP_AUTO_TYPE(ConstructorTest::MyBase2, &ConstructorTest::declare)
+CAMP_AUTO_TYPE(ConstructorTest::MyClass, &ConstructorTest::declare)
+
+#endif // CAMPTEST_CONSTRUCTOR_HPP
diff --git a/test/enum.cpp b/test/enum.cpp
new file mode 100644
index 0000000..7a2ac4b
--- /dev/null
+++ b/test/enum.cpp
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "enum.hpp"
+#include <camp/enumget.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace EnumTest;
+
+//-----------------------------------------------------------------------------
+struct EnumFixture
+{
+    EnumFixture()
+    {
+        metaenum = &camp::enumByType<MyEnum>();
+    }
+
+    const camp::Enum* metaenum;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Enum
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(ENUM, EnumFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(declare)
+{
+    std::size_t count = camp::enumCount();
+
+    camp::Enum::declare<MyTempEnum>("EnumTest::MyTempEnum");
+
+    BOOST_CHECK_EQUAL(camp::enumCount(), count + 1);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(declareExceptions)
+{
+    // to make sure it is declared
+    camp::enumByType<MyEnum>();
+
+    BOOST_CHECK_THROW(camp::Enum::declare<MyEnum>("EnumTest::MyUndeclaredEnum"), camp::EnumAlreadyCreated);
+    BOOST_CHECK_THROW(camp::Enum::declare<MyUndeclaredEnum>("EnumTest::MyEnum"), camp::EnumAlreadyCreated);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    MyEnum object = MyEnum();
+    MyUndeclaredEnum object2 = MyUndeclaredEnum();
+
+    BOOST_CHECK_EQUAL(camp::enumByName("EnumTest::MyEnum").name(), "EnumTest::MyEnum");
+    BOOST_CHECK_EQUAL(camp::enumByType<MyEnum>().name(),           "EnumTest::MyEnum");
+    BOOST_CHECK_EQUAL(camp::enumByObject(object).name(),           "EnumTest::MyEnum");
+    BOOST_CHECK_EQUAL(camp::enumByObject(&object).name(),          "EnumTest::MyEnum");
+    BOOST_CHECK_EQUAL(camp::enumByTypeSafe<MyUndeclaredEnum>(),    static_cast<camp::Enum*>(0));
+
+    BOOST_CHECK_THROW(camp::enumByName("EnumTest::MyUndeclaredEnum"), camp::EnumNotFound);
+    BOOST_CHECK_THROW(camp::enumByType<MyUndeclaredEnum>(),           camp::EnumNotFound);
+    BOOST_CHECK_THROW(camp::enumByObject(object2),                    camp::EnumNotFound);
+    BOOST_CHECK_THROW(camp::enumByObject(&object2),                   camp::EnumNotFound);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(comparisons)
+{
+    BOOST_CHECK(camp::enumByType<MyEnum>()  == camp::enumByType<MyEnum>());
+    BOOST_CHECK(camp::enumByType<MyEnum>()  != camp::enumByType<MyEnum2>());
+    BOOST_CHECK(camp::enumByType<MyEnum2>() != camp::enumByType<MyEnum>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(pairs)
+{
+    BOOST_CHECK_EQUAL(metaenum->size(), 3U);
+
+    BOOST_CHECK_EQUAL(metaenum->pair(0).name, "Zero");
+    BOOST_CHECK_EQUAL(metaenum->pair(0).value, Zero);
+    BOOST_CHECK_EQUAL(metaenum->pair(1).name, "One");
+    BOOST_CHECK_EQUAL(metaenum->pair(1).value, One);
+    BOOST_CHECK_EQUAL(metaenum->pair(2).name, "Two");
+    BOOST_CHECK_EQUAL(metaenum->pair(2).value, Two);
+    BOOST_CHECK_THROW(metaenum->pair(3), camp::OutOfRange);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(values)
+{
+    BOOST_CHECK_EQUAL(metaenum->hasValue(Zero), true);
+    BOOST_CHECK_EQUAL(metaenum->hasValue(One),  true);
+    BOOST_CHECK_EQUAL(metaenum->hasValue(Two),  true);
+    BOOST_CHECK_EQUAL(metaenum->hasValue(100),  false);
+
+    BOOST_CHECK_EQUAL(metaenum->value("Zero"), Zero);
+    BOOST_CHECK_EQUAL(metaenum->value("One"),  One);
+    BOOST_CHECK_EQUAL(metaenum->value("Two"),  Two);
+    BOOST_CHECK_THROW(metaenum->value("xxx"),  camp::EnumNameNotFound);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(names)
+{
+    BOOST_CHECK_EQUAL(metaenum->hasName("Zero"),    true);
+    BOOST_CHECK_EQUAL(metaenum->hasName("One"),     true);
+    BOOST_CHECK_EQUAL(metaenum->hasName("Two"),     true);
+    BOOST_CHECK_EQUAL(metaenum->hasName("Hundred"), false);
+
+    BOOST_CHECK_EQUAL(metaenum->name(Zero), "Zero");
+    BOOST_CHECK_EQUAL(metaenum->name(One),  "One");
+    BOOST_CHECK_EQUAL(metaenum->name(Two),  "Two");
+    BOOST_CHECK_THROW(metaenum->name(100),  camp::EnumValueNotFound);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/enum.hpp b/test/enum.hpp
new file mode 100644
index 0000000..3c8c3cd
--- /dev/null
+++ b/test/enum.hpp
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_ENUM_HPP
+#define CAMPTEST_ENUM_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/enum.hpp>
+
+namespace EnumTest
+{
+    enum MyTempEnum
+    {
+    };
+
+    enum MyUndeclaredEnum
+    {
+    };
+
+    enum MyEnum
+    {
+        Zero = 0,
+        One  = 1,
+        Two  = 2
+    };
+
+    enum MyEnum2
+    {
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("EnumTest::MyEnum")
+            .value("Zero", Zero)
+            .value("One", One)
+            .value("Two", Two);
+
+        camp::Enum::declare<MyEnum2>("EnumTest::MyEnum2");
+    }
+}
+
+CAMP_TYPE(EnumTest::MyUndeclaredEnum /* never declared */)
+CAMP_TYPE(EnumTest::MyTempEnum /* declared during tests */)
+CAMP_AUTO_TYPE(EnumTest::MyEnum, &EnumTest::declare)
+CAMP_AUTO_TYPE(EnumTest::MyEnum2, &EnumTest::declare)
+
+#endif // CAMPTEST_ENUM_HPP
diff --git a/test/enumobject.cpp b/test/enumobject.cpp
new file mode 100644
index 0000000..0715984
--- /dev/null
+++ b/test/enumobject.cpp
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "enumobject.hpp"
+#include <camp/enumget.hpp>
+#include <camp/enumobject.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace EnumObjectTest;
+
+struct EnumObjectFixture
+{
+    EnumObjectFixture()
+        : zero(Zero)
+        , one(One)
+        , two(Two)
+    {
+    }
+
+    camp::EnumObject zero;
+    camp::EnumObject one;
+    camp::EnumObject two;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::EnumObject
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(ENUMOBJECT, EnumObjectFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(error)
+{
+    // The meta-enum of MyUndeclaredEnum is *not* declared
+
+    BOOST_CHECK_THROW(camp::EnumObject obj(Undeclared), camp::EnumNotFound);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(value)
+{
+    BOOST_CHECK_EQUAL(zero.value(), Zero);
+    BOOST_CHECK_EQUAL(one.value(),  One);
+    BOOST_CHECK_EQUAL(two.value(),  Two);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(name)
+{
+    BOOST_CHECK_EQUAL(zero.name(), "Zero");
+    BOOST_CHECK_EQUAL(one.name(),  "One");
+    BOOST_CHECK_EQUAL(two.name(),  "Two");
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getEnum)
+{
+    BOOST_CHECK(zero.getEnum() == camp::enumByType<MyEnum>());
+    BOOST_CHECK(one.getEnum()  == camp::enumByType<MyEnum>());
+    BOOST_CHECK(two.getEnum()  == camp::enumByType<MyEnum>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(equal)
+{
+    // Setup
+    camp::EnumObject zero2(Zero2);
+    camp::EnumObject one2(One2);
+    camp::EnumObject two2(Two2);
+
+    // Tests
+    BOOST_CHECK_EQUAL(zero == camp::EnumObject(Zero), true);
+    BOOST_CHECK_EQUAL(one  == camp::EnumObject(One),  true);
+    BOOST_CHECK_EQUAL(two  == camp::EnumObject(Two),  true);
+
+    BOOST_CHECK_EQUAL(zero == one,  false);
+    BOOST_CHECK_EQUAL(one  == two,  false);
+    BOOST_CHECK_EQUAL(two  == zero, false);
+
+    BOOST_CHECK_EQUAL(zero == zero2, false); // same value and name, different metaenum
+    BOOST_CHECK_EQUAL(one  == one2,  false);
+    BOOST_CHECK_EQUAL(two  == two2,  false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(lessThan)
+{
+    BOOST_CHECK_EQUAL(zero < zero, false);
+    BOOST_CHECK_EQUAL(zero < one,  true);
+    BOOST_CHECK_EQUAL(zero < two,  true);
+
+    BOOST_CHECK_EQUAL(one < zero, false);
+    BOOST_CHECK_EQUAL(one < one,  false);
+    BOOST_CHECK_EQUAL(one < two,  true);
+
+    BOOST_CHECK_EQUAL(two < zero, false);
+    BOOST_CHECK_EQUAL(two < one,  false);
+    BOOST_CHECK_EQUAL(two < two,  false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/enumobject.hpp b/test/enumobject.hpp
new file mode 100644
index 0000000..22e89ce
--- /dev/null
+++ b/test/enumobject.hpp
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_ENUMOBJECT_HPP
+#define CAMPTEST_ENUMOBJECT_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/enum.hpp>
+
+namespace EnumObjectTest
+{
+    enum MyEnum
+    {
+        Zero = 0,
+        One  = 1,
+        Two  = 2
+    };
+
+    enum MyEnum2
+    {
+        Zero2 = 0,
+        One2  = 1,
+        Two2  = 2
+    };
+
+    enum MyUndeclaredEnum
+    {
+        Undeclared
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("EnumObjectTest::MyEnum")
+            .value("Zero", Zero)
+            .value("One",  One)
+            .value("Two",  Two);
+
+        camp::Enum::declare<MyEnum2>("EnumObjectTest::MyEnum2")
+            .value("Zero", Zero2)
+            .value("One",  One2)
+            .value("Two",  Two2);
+    }
+}
+
+CAMP_TYPE(EnumObjectTest::MyUndeclaredEnum)
+CAMP_AUTO_TYPE(EnumObjectTest::MyEnum, &EnumObjectTest::declare)
+CAMP_AUTO_TYPE(EnumObjectTest::MyEnum2, &EnumObjectTest::declare)
+
+#endif // CAMPTEST_ENUMOBJECT_HPP
diff --git a/test/enumproperty.cpp b/test/enumproperty.cpp
new file mode 100644
index 0000000..f90a91e
--- /dev/null
+++ b/test/enumproperty.cpp
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "enumproperty.hpp"
+#include <camp/classget.hpp>
+#include <camp/enumget.hpp>
+#include <camp/errors.hpp>
+#include <camp/enumproperty.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace EnumPropertyTest;
+
+//-----------------------------------------------------------------------------
+struct EnumPropertyFixture
+{
+    EnumPropertyFixture()
+    {
+        const camp::Class& metaclass = camp::classByType<MyClass>();
+        property = &static_cast<const camp::EnumProperty&>(metaclass.property("x"));
+    }
+
+    const camp::EnumProperty* property;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::EnumProperty
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(ENUMPROPERTY, EnumPropertyFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(property->type(), camp::enumType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getEnum)
+{
+    BOOST_CHECK(property->getEnum() == camp::enumByType<MyEnum>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    BOOST_CHECK_EQUAL(property->get(MyClass(Zero)), camp::Value(Zero));
+    BOOST_CHECK_EQUAL(property->get(MyClass(One)),  camp::Value(One));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    MyClass object(Zero);
+    property->set(object, One);
+
+    BOOST_CHECK_EQUAL(property->get(object), camp::Value(One));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/enumproperty.hpp b/test/enumproperty.hpp
new file mode 100644
index 0000000..a9d4993
--- /dev/null
+++ b/test/enumproperty.hpp
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_ENUMPROPERTY_HPP
+#define CAMPTEST_ENUMPROPERTY_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/enum.hpp>
+#include <camp/class.hpp>
+#include <boost/array.hpp>
+#include <list>
+#include <vector>
+
+namespace EnumPropertyTest
+{
+    enum MyEnum
+    {
+        Zero = 0,
+        One  = 1
+    };
+
+    struct MyClass
+    {
+        MyClass(MyEnum x_) : x(x_)
+        {
+        }
+
+        MyEnum x;
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("EnumPropertyTest::MyEnum");
+
+        camp::Class::declare<MyClass>("EnumPropertyTest::MyClass")
+            .property("x", &MyClass::x);
+    }
+}
+
+CAMP_AUTO_TYPE(EnumPropertyTest::MyEnum, &EnumPropertyTest::declare)
+CAMP_AUTO_TYPE(EnumPropertyTest::MyClass, &EnumPropertyTest::declare)
+
+#endif // CAMPTEST_ENUMPROPERTY_HPP
diff --git a/test/function.cpp b/test/function.cpp
new file mode 100644
index 0000000..546db78
--- /dev/null
+++ b/test/function.cpp
@@ -0,0 +1,221 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "function.hpp"
+#include <camp/classget.hpp>
+#include <camp/enumget.hpp>
+#include <camp/function.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace FunctionTest;
+
+//-----------------------------------------------------------------------------
+struct FunctionFixture
+{
+    FunctionFixture()
+    {
+        const camp::Class& metaclass = camp::classByType<MyClass>();
+        for (int i = 1; i < 23; ++i)
+        {
+            if (i != 14 && i != 17) // remove when fixed
+                functions[i] = &metaclass.function("f" + boost::lexical_cast<std::string>(i));
+        }
+    }
+
+    const camp::Function* functions[23];
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Function
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(FUNCTION, FunctionFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(returnType)
+{
+    BOOST_CHECK_EQUAL(functions[1]->returnType(),  camp::noType);
+    BOOST_CHECK_EQUAL(functions[2]->returnType(),  camp::intType);
+    BOOST_CHECK_EQUAL(functions[3]->returnType(),  camp::stringType);
+    BOOST_CHECK_EQUAL(functions[4]->returnType(),  camp::userType);
+    BOOST_CHECK_EQUAL(functions[5]->returnType(),  camp::userType);
+    BOOST_CHECK_EQUAL(functions[6]->returnType(),  camp::noType);
+    BOOST_CHECK_EQUAL(functions[7]->returnType(),  camp::userType);
+    BOOST_CHECK_EQUAL(functions[8]->returnType(),  camp::noType);
+    BOOST_CHECK_EQUAL(functions[9]->returnType(),  camp::noType);
+    BOOST_CHECK_EQUAL(functions[10]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[11]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[12]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[13]->returnType(), camp::noType);
+    //BOOST_CHECK_EQUAL(functions[14]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[15]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[16]->returnType(), camp::intType);
+    //BOOST_CHECK_EQUAL(functions[17]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[18]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[19]->returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(functions[20]->returnType(), camp::intType);
+    BOOST_CHECK_EQUAL(functions[21]->returnType(), camp::intType);
+    BOOST_CHECK_EQUAL(functions[22]->returnType(), camp::intType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(argCount)
+{
+    BOOST_CHECK_EQUAL(functions[1]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[2]->argCount(),  1);
+    BOOST_CHECK_EQUAL(functions[3]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[4]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[5]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[6]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[7]->argCount(),  1);
+    BOOST_CHECK_EQUAL(functions[8]->argCount(),  0);
+    BOOST_CHECK_EQUAL(functions[9]->argCount(),  1);
+    BOOST_CHECK_EQUAL(functions[10]->argCount(), 2);
+    BOOST_CHECK_EQUAL(functions[11]->argCount(), 3);
+    BOOST_CHECK_EQUAL(functions[12]->argCount(), 4);
+    BOOST_CHECK_EQUAL(functions[13]->argCount(), 5);
+    //BOOST_CHECK_EQUAL(functions[14]->argCount(), 0);
+    BOOST_CHECK_EQUAL(functions[15]->argCount(), 0);
+    BOOST_CHECK_EQUAL(functions[16]->argCount(), 0);
+    //BOOST_CHECK_EQUAL(functions[17]->argCount(), 0);
+    BOOST_CHECK_EQUAL(functions[18]->argCount(), 0);
+    BOOST_CHECK_EQUAL(functions[19]->argCount(), 0);
+    BOOST_CHECK_EQUAL(functions[20]->argCount(), 1);
+    BOOST_CHECK_EQUAL(functions[21]->argCount(), 1);
+    BOOST_CHECK_EQUAL(functions[22]->argCount(), 1);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(argType)
+{
+    BOOST_CHECK_THROW(functions[1]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_EQUAL(functions[2]->argType(0),  camp::intType);
+    BOOST_CHECK_THROW(functions[3]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[4]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[5]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[6]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_EQUAL(functions[7]->argType(0),  camp::userType);
+    BOOST_CHECK_THROW(functions[8]->argType(0),  camp::OutOfRange);
+    BOOST_CHECK_EQUAL(functions[9]->argType(0),  camp::boolType);
+    BOOST_CHECK_EQUAL(functions[10]->argType(0), camp::realType);
+    BOOST_CHECK_EQUAL(functions[10]->argType(1), camp::realType);
+    BOOST_CHECK_EQUAL(functions[11]->argType(0), camp::intType);
+    BOOST_CHECK_EQUAL(functions[11]->argType(1), camp::intType);
+    BOOST_CHECK_EQUAL(functions[11]->argType(2), camp::intType);
+    BOOST_CHECK_EQUAL(functions[12]->argType(0), camp::stringType);
+    BOOST_CHECK_EQUAL(functions[12]->argType(1), camp::stringType);
+    BOOST_CHECK_EQUAL(functions[12]->argType(2), camp::stringType);
+    BOOST_CHECK_EQUAL(functions[12]->argType(3), camp::stringType);
+    BOOST_CHECK_EQUAL(functions[13]->argType(0), camp::enumType);
+    BOOST_CHECK_EQUAL(functions[13]->argType(1), camp::enumType);
+    BOOST_CHECK_EQUAL(functions[13]->argType(2), camp::enumType);
+    BOOST_CHECK_EQUAL(functions[13]->argType(3), camp::enumType);
+    BOOST_CHECK_EQUAL(functions[13]->argType(4), camp::enumType);
+    //BOOST_CHECK_THROW(functions[14]->argType(0), camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[15]->argType(0), camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[16]->argType(0), camp::OutOfRange);
+    //BOOST_CHECK_THROW(functions[17]->argType(0), camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[18]->argType(0), camp::OutOfRange);
+    BOOST_CHECK_THROW(functions[19]->argType(0), camp::OutOfRange);
+    BOOST_CHECK_EQUAL(functions[20]->argType(0), camp::intType);
+    BOOST_CHECK_EQUAL(functions[21]->argType(0), camp::intType);
+    BOOST_CHECK_EQUAL(functions[22]->argType(0), camp::intType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(call)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(functions[1]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[2]->call(object, camp::Args(10)), camp::Value(12));
+    BOOST_CHECK_EQUAL(functions[3]->call(object, camp::Args()), camp::Value("3"));
+    BOOST_CHECK_EQUAL(functions[4]->call(object, camp::Args()).to<MyType>(), MyType(4));
+    BOOST_CHECK_EQUAL(functions[5]->call(object, camp::Args()).to<MyType>(), MyType(5));
+    BOOST_CHECK_EQUAL(functions[6]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[7]->call(object, camp::Args("hi")), camp::Value("hi"));
+    BOOST_CHECK_EQUAL(functions[8]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[9]->call(object, camp::Args(true)), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[10]->call(object, camp::Args(1., 2.f)), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[11]->call(object, camp::Args(1, 2, 3)), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[12]->call(object, camp::Args("1", "2", "3", "4")), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[13]->call(object, camp::Args(Zero, One, Two, Zero, One)), camp::Value::nothing);
+    //BOOST_CHECK_EQUAL(functions[14]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[15]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[16]->call(object, camp::Args()), camp::Value(16));
+    //BOOST_CHECK_EQUAL(functions[17]->call(object, camp::Args(20)), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[18]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[19]->call(object, camp::Args()), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(functions[20]->call(object, camp::Args(10)), camp::Value(10));
+    BOOST_CHECK_EQUAL(functions[21]->call(object, camp::Args(10)), camp::Value(30));
+    BOOST_CHECK_EQUAL(functions[22]->call(object, camp::Args(10)), camp::Value(60));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(callNullObject)
+{
+    BOOST_CHECK_THROW(functions[1]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[3]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[4]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[5]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[6]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[8]->call(camp::UserObject(), camp::Args()),  camp::NullObject);
+    BOOST_CHECK_THROW(functions[15]->call(camp::UserObject(), camp::Args()), camp::NullObject);
+    BOOST_CHECK_THROW(functions[16]->call(camp::UserObject(), camp::Args()), camp::NullObject);
+    BOOST_CHECK_THROW(functions[18]->call(camp::UserObject(), camp::Args()), camp::NullObject);
+    BOOST_CHECK_THROW(functions[19]->call(camp::UserObject(), camp::Args()), camp::NullObject);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(callNotEnoughArguments)
+{
+    MyClass object;
+
+    BOOST_CHECK_THROW(functions[2]->call(object, camp::Args()),                      camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[7]->call(object, camp::Args()),                      camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[9]->call(object, camp::Args()),                      camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[10]->call(object, camp::Args(1.)),                   camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[11]->call(object, camp::Args(1, 2)),                 camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[12]->call(object, camp::Args("1", "2", "3")),        camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[13]->call(object, camp::Args(Zero, One, Two, Zero)), camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[20]->call(object, camp::Args()),                     camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[21]->call(object, camp::Args()),                     camp::NotEnoughArguments);
+    BOOST_CHECK_THROW(functions[22]->call(object, camp::Args()),                     camp::NotEnoughArguments);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(callBadArgument)
+{
+    MyClass object;
+    MyType arg(0);
+
+    BOOST_CHECK_THROW(functions[2]->call(object, camp::Args(arg)),                      camp::BadArgument);
+    BOOST_CHECK_THROW(functions[10]->call(object, camp::Args(arg, arg)),                camp::BadArgument);
+    BOOST_CHECK_THROW(functions[11]->call(object, camp::Args(arg, arg, arg)),           camp::BadArgument);
+    BOOST_CHECK_THROW(functions[12]->call(object, camp::Args(arg, arg, arg, arg)),      camp::BadArgument);
+    BOOST_CHECK_THROW(functions[13]->call(object, camp::Args(arg, arg, arg, arg, arg)), camp::BadArgument);
+    BOOST_CHECK_THROW(functions[20]->call(object, camp::Args(arg)),                     camp::BadArgument);
+    BOOST_CHECK_THROW(functions[21]->call(object, camp::Args(arg)),                     camp::BadArgument);
+    BOOST_CHECK_THROW(functions[22]->call(object, camp::Args(arg)),                     camp::BadArgument);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/function.hpp b/test/function.hpp
new file mode 100644
index 0000000..037b66d
--- /dev/null
+++ b/test/function.hpp
@@ -0,0 +1,177 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_FUNCTION_HPP
+#define CAMPTEST_FUNCTION_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/enum.hpp>
+#include <camp/class.hpp>
+#include <camp/value.hpp>
+#include <boost/shared_ptr.hpp>
+#include <string>
+
+namespace FunctionTest
+{
+    enum MyEnum
+    {
+        Zero = 0,
+        One  = 1,
+        Two  = 2
+    };
+
+    struct MyType
+    {
+        MyType(int x_) : x(x_) {}
+        int x;
+    };
+
+    bool operator==(const MyType& left, const MyType& right) {return left.x == right.x;}
+    bool operator<(const MyType& left, const MyType& right) {return left.x < right.x;}
+    std::ostream& operator<<(std::ostream& stream, const MyType& object) {return stream << object.x;}
+
+    struct MyBase
+    {
+        void f6() {}
+        char padding[10];
+    };
+
+    struct MyClass : MyBase
+    {
+        MyClass()
+            : p1(true)
+            , p2(2)
+            , p3("3")
+            , p4(MyType(4))
+            , p5(MyType(5))
+            , innerPtr(&inner)
+            , innerSmartPtr(new Inner)
+        {
+        }
+
+        bool p1;
+        int p2;
+        std::string p3;
+
+        MyType p4; const MyType& f4() {return p4;}
+        MyType p5; const MyType& f5() const {return p5;}
+        // f6 is inherited
+        camp::Value f7(camp::Value v) {return v;}
+
+        void f8() {}
+        void f9(bool) {}
+        void f10(float, double) {}
+        void f11(short, int, long) {}
+        void f12(const std::string&, std::string, const std::string&, std::string) {}
+        void f13(MyEnum, MyEnum, MyEnum, MyEnum, MyEnum) {}
+
+        struct Inner
+        {
+            void f14() {}
+            void f15() const {}
+            int f16() {return 16;}
+            void f17(int) {}
+            void f18() {}
+            void f19() {}
+        };
+        Inner inner;
+        const Inner& getInner() const {return inner;}
+        Inner* innerPtr;
+        const Inner* getInnerPtr() const {return innerPtr;}
+        boost::shared_ptr<Inner> innerSmartPtr;
+        const boost::shared_ptr<Inner> getInnerSmartPtr() {return innerSmartPtr;}
+
+        int f20(int x) {return x;}
+        int f21(int x, int y) {return x + y;}
+        int f22(int x, int y, int z) {return x + y + z;}
+    };
+
+    void f1(MyClass& object)
+    {
+        object.p1 = true;
+    }
+
+    int f2(MyClass object, int x)
+    {
+        return object.p2 + x;
+    }
+
+    const std::string& f3(const MyClass* object)
+    {
+        return object->p3;
+    }
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("FunctionTest::MyEnum")
+            .value("Zero", Zero)
+            .value("One",  One)
+            .value("Two",  Two);
+
+        camp::Class::declare<MyType>("FunctionTest::MyType");
+
+        camp::Class::declare<MyBase>("FunctionTest::MyBase");
+
+        camp::Class::declare<MyClass>("FunctionTest::MyClass")
+            .base<MyBase>()
+
+            // ***** non-member functions *****
+            .function("f1", &f1) // object by reference
+            .function("f2", &f2) // object by value + parameter
+            .function("f3", &f3) // object by pointer
+
+            // ***** member functions *****
+            .function("f4", &MyClass::f4) // non-const
+            .function("f5", &MyClass::f5) // const
+            .function("f6", &MyClass::f6) // inherited
+            .function("f7", &MyClass::f7) // camp::Value as return and argument types
+
+            // ***** arguments count ******
+            .function("f8",  &MyClass::f8)  // 0 argument
+            .function("f9",  &MyClass::f9)  // 1 argument
+            .function("f10", &MyClass::f10) // 2 arguments
+            .function("f11", &MyClass::f11) // 3 arguments
+            .function("f12", &MyClass::f12) // 4 arguments
+            .function("f13", &MyClass::f13) // 5 arguments
+
+            // ***** nested functions *****
+            // TOFIX .function("f14", &MyClass::Inner::f14, &MyClass::inner)            // object
+            .function("f15", &MyClass::Inner::f15, &MyClass::getInner)         // getter returning an object
+            .function("f16", &MyClass::Inner::f16, &MyClass::innerPtr)         // raw pointer
+            // TOFIX .function("f17", &MyClass::Inner::f17, &MyClass::getInnerPtr)      // getter returning a raw pointer
+            .function("f18", &MyClass::Inner::f18, &MyClass::innerSmartPtr)    // smart pointer
+            .function("f19", &MyClass::Inner::f19, &MyClass::getInnerSmartPtr) // getter returning a smart pointer
+
+            // ***** boost::function *****
+            .function("f20", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f20, _1, _2)))
+            .function("f21", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f21, _1, _2, 20)))
+            .function("f22", boost::function<int (MyClass&, int)>(boost::bind(boost::bind(&MyClass::f22, _1, _2, _3, 30), _1, _2, 20)))
+            ;
+    }
+}
+
+CAMP_AUTO_TYPE(FunctionTest::MyEnum,  &FunctionTest::declare)
+CAMP_AUTO_TYPE(FunctionTest::MyType,  &FunctionTest::declare)
+CAMP_AUTO_TYPE(FunctionTest::MyClass, &FunctionTest::declare)
+CAMP_AUTO_TYPE(FunctionTest::MyBase,  &FunctionTest::declare)
+
+#endif // CAMPTEST_FUNCTION_HPP
diff --git a/test/functionaccess.cpp b/test/functionaccess.cpp
new file mode 100644
index 0000000..db8d868
--- /dev/null
+++ b/test/functionaccess.cpp
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "functionaccess.hpp"
+#include <camp/classget.hpp>
+#include <camp/function.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace FunctionAccessTest;
+
+//-----------------------------------------------------------------------------
+struct FunctionAccessFixture
+{
+    FunctionAccessFixture()
+        : object_t(true)
+        , object_f(false)
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    MyClass object_t;
+    MyClass object_f;
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Function callable
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(FUNCTIONACCESS, FunctionAccessFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(callableStatic)
+{
+    BOOST_CHECK_EQUAL(metaclass->function("f0").callable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->function("f0").callable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->function("f1").callable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f1").callable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f2").callable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f2").callable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f3").callable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->function("f3").callable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->function("f4").callable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f4").callable(object_f), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(callableDynamic)
+{
+    BOOST_CHECK_EQUAL(metaclass->function("f5").callable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f5").callable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->function("f6").callable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f6").callable(object_f), false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functionaccess.hpp b/test/functionaccess.hpp
new file mode 100644
index 0000000..3b573e7
--- /dev/null
+++ b/test/functionaccess.hpp
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_FUNCTIONACCESS_HPP
+#define CAMPTEST_FUNCTIONACCESS_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+
+namespace FunctionAccessTest
+{
+    struct MyClass
+    {
+        MyClass(bool b = true)
+            : m_b(b)
+        {
+        }
+
+        void f() {}
+
+        bool m_b;
+        bool b1() {return true;}
+        bool b2() const {return false;}
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyClass>("FunctionAccessTest::MyClass")
+
+            // ***** constant value *****
+            .function("f0", &MyClass::f).callable(false)
+            .function("f1", &MyClass::f).callable(true)
+
+            // ***** function *****
+            .function("f2", &MyClass::f).callable(&MyClass::b1)
+            .function("f3", &MyClass::f).callable(&MyClass::b2)
+            .function("f4", &MyClass::f).callable(boost::bind(&MyClass::b1, _1))
+            .function("f5", &MyClass::f).callable(&MyClass::m_b)
+            .function("f6", &MyClass::f).callable(boost::function<bool (MyClass&)>(&MyClass::m_b))
+            ;
+    }
+}
+
+CAMP_AUTO_TYPE(FunctionAccessTest::MyClass, &FunctionAccessTest::declare);
+
+#endif // CAMPTEST_FUNCTIONACCESS_HPP
diff --git a/test/inheritance.cpp b/test/inheritance.cpp
new file mode 100644
index 0000000..e0e1719
--- /dev/null
+++ b/test/inheritance.cpp
@@ -0,0 +1,174 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "inheritance.hpp"
+#include <camp/class.hpp>
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace InheritanceTest;
+
+//-----------------------------------------------------------------------------
+struct InheritanceFixture
+{
+    InheritanceFixture()
+    {
+        class1 = &camp::classByType<MyClass1>();
+        class2 = &camp::classByType<MyClass2>();
+        class3 = &camp::classByType<MyClass3>();
+        class4 = &camp::classByType<MyClass4>();
+    }
+
+    const camp::Class* class1;
+    const camp::Class* class2;
+    const camp::Class* class3;
+    const camp::Class* class4;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for inherited metaclasses
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(INHERITANCE, InheritanceFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(regularFunctions)
+{
+    MyClass1 object1;
+    MyClass2 object2;
+    MyClass3 object3;
+    MyClass4 object4;
+
+    BOOST_CHECK_EQUAL(class1->function("f1").call(object1), camp::Value(1));
+    BOOST_CHECK_EQUAL(class3->function("f1").call(object3), camp::Value(1));
+    BOOST_CHECK_EQUAL(class4->function("f1").call(object4), camp::Value(1));
+
+    BOOST_CHECK_EQUAL(class2->function("f2").call(object2), camp::Value(2));
+    BOOST_CHECK_EQUAL(class3->function("f2").call(object3), camp::Value(2));
+    BOOST_CHECK_EQUAL(class4->function("f2").call(object4), camp::Value(2));
+
+    BOOST_CHECK_EQUAL(class3->function("f3").call(object3), camp::Value(3));
+    BOOST_CHECK_EQUAL(class4->function("f3").call(object4), camp::Value(3));
+
+    BOOST_CHECK_EQUAL(class4->function("f4").call(object4), camp::Value(4));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(virtualFunctions)
+{
+    MyClass1 object1;
+    MyClass2 object2;
+    MyClass3 object3;
+    MyClass4 object4;
+
+    BOOST_CHECK_EQUAL(class2->function("virtual").call(object2), camp::Value(20));
+    BOOST_CHECK_EQUAL(class3->function("virtual").call(object3), camp::Value(30));
+    BOOST_CHECK_EQUAL(class4->function("virtual").call(object4), camp::Value(40));
+
+    BOOST_CHECK_EQUAL(class2->function("virtual").call(object2), camp::Value(20));
+    BOOST_CHECK_EQUAL(class2->function("virtual").call(object3), camp::Value(30));
+    BOOST_CHECK_EQUAL(class2->function("virtual").call(object4), camp::Value(40));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(properties)
+{
+    MyClass1 object1;
+    MyClass2 object2;
+    MyClass3 object3;
+    MyClass4 object4;
+
+    BOOST_CHECK_EQUAL(class1->property("p1").get(object1), camp::Value(10));
+    BOOST_CHECK_EQUAL(class3->property("p1").get(object3), camp::Value(10));
+    BOOST_CHECK_EQUAL(class4->property("p1").get(object4), camp::Value(10));
+
+    BOOST_CHECK_EQUAL(class2->property("p2").get(object2), camp::Value(20));
+    BOOST_CHECK_EQUAL(class3->property("p2").get(object3), camp::Value(20));
+    BOOST_CHECK_EQUAL(class4->property("p2").get(object4), camp::Value(20));
+
+    BOOST_CHECK_EQUAL(class3->property("p3").get(object3), camp::Value(30));
+    BOOST_CHECK_EQUAL(class4->property("p3").get(object4), camp::Value(30));
+
+    BOOST_CHECK_EQUAL(class4->property("p4").get(object4), camp::Value(40));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(castWithPointerOffset)
+{
+    MyClass3 object3;
+    MyClass4 object4;
+
+    MyClass2* base3 = &object3;
+    MyClass3* base4 = &object4;
+
+    BOOST_CHECK_EQUAL(class2->property("p2").get(base3), camp::Value(20));
+    BOOST_CHECK_EQUAL(class2->property("p2").get(base4), camp::Value(20));
+
+    BOOST_CHECK_EQUAL(class3->property("p3").get(base3), camp::Value(30));
+    BOOST_CHECK_EQUAL(class3->property("p3").get(base4), camp::Value(30));
+
+    BOOST_CHECK_EQUAL(class4->property("p4").get(base4), camp::Value(40));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(overriddenFunction)
+{
+    MyClass1 object1;
+    MyClass2 object2;
+    MyClass3 object3;
+    MyClass4 object4;
+
+    BOOST_CHECK_EQUAL(class1->function("overridden").call(object1), camp::Value(1));
+    BOOST_CHECK_EQUAL(class2->function("overridden").call(object2), camp::Value(2));
+    BOOST_CHECK_EQUAL(class3->function("overridden").call(object3), camp::Value(3));
+    BOOST_CHECK_EQUAL(class4->function("overridden").call(object4), camp::Value(4));
+
+    BOOST_CHECK_EQUAL(class4->function("overridden").call(object1), camp::Value(4));
+    BOOST_CHECK_EQUAL(class4->function("overridden").call(object2), camp::Value(4));
+    BOOST_CHECK_EQUAL(class4->function("overridden").call(object3), camp::Value(4));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(overriddenProperty)
+{
+    MyClass1 object1;
+    MyClass2 object2;
+    MyClass3 object3;
+    MyClass4 object4;
+
+    // Here, the result should always depend on the metaclass, not the object
+    // (just like in C++ where non-virtual functions are resolved using the static type)
+
+    BOOST_CHECK_EQUAL(class1->property("overridden").get(object1), camp::Value(10));
+    BOOST_CHECK_EQUAL(class2->property("overridden").get(object2), camp::Value(20));
+    BOOST_CHECK_EQUAL(class3->property("overridden").get(object3), camp::Value(30));
+    BOOST_CHECK_EQUAL(class4->property("overridden").get(object4), camp::Value(40));
+
+    BOOST_CHECK_EQUAL(class1->property("overridden").get(object3), camp::Value(10));
+    BOOST_CHECK_EQUAL(class2->property("overridden").get(object3), camp::Value(20));
+
+    BOOST_CHECK_EQUAL(class1->property("overridden").get(object4), camp::Value(10));
+    BOOST_CHECK_EQUAL(class2->property("overridden").get(object4), camp::Value(20));
+    BOOST_CHECK_EQUAL(class3->property("overridden").get(object4), camp::Value(30));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/inheritance.hpp b/test/inheritance.hpp
new file mode 100644
index 0000000..b8b6048
--- /dev/null
+++ b/test/inheritance.hpp
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_INHERITANCE_HPP
+#define CAMPTEST_INHERITANCE_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+
+namespace InheritanceTest
+{
+    struct MyClass1
+    {
+        MyClass1() : p1(10), po1(10) {}
+        virtual ~MyClass1() {}
+        int p1;
+        int f1() const {return 1;}
+        int po1;
+        int fo1() {return 1;}
+        CAMP_RTTI();
+    };
+
+    struct MyClass2
+    {
+        MyClass2() : p2(20), po2(20) {}
+        virtual ~MyClass2() {}
+        int p2;
+        int f2() const {return 2;}
+        virtual int fv() const {return p2;}
+        int po2;
+        int fo2() {return 2;}
+        CAMP_RTTI();
+    };
+
+    struct MyClass3 : public MyClass1, public MyClass2
+    {
+        MyClass3() : p3(30), po3(30) {}
+        virtual ~MyClass3() {}
+        int p3;
+        int f3() const {return 3;}
+        virtual int fv() const {return p3;}
+        int po3;
+        int fo3() {return 3;}
+        CAMP_RTTI();
+    };
+
+    struct MyClass4 : public MyClass3
+    {
+        MyClass4() : p4(40), po4(40) {}
+        virtual ~MyClass4() {}
+        int p4;
+        int f4() const {return 4;}
+        virtual int fv() const {return p4;}
+        int po4;
+        int fo4() {return 4;}
+        CAMP_RTTI();
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyClass1>("InheritanceTest::MyClass1")
+            .function("f1", &MyClass1::f1)
+            .property("p1", &MyClass1::p1)
+            .function("overridden", &MyClass1::fo1)
+            .property("overridden", &MyClass1::po1);
+
+        camp::Class::declare<MyClass2>("InheritanceTest::MyClass2")
+            .function("f2", &MyClass2::f2)
+            .property("p2", &MyClass2::p2)
+            .function("virtual", &MyClass2::fv)
+            .function("overridden", &MyClass2::fo2)
+            .property("overridden", &MyClass2::po2);
+
+        camp::Class::declare<MyClass3>("InheritanceTest::MyClass3")
+            .base<MyClass1>()
+            .base<MyClass2>()
+            .function("f3", &MyClass3::f3)
+            .property("p3", &MyClass3::p3)
+            .function("overridden", &MyClass3::fo3)
+            .property("overridden", &MyClass3::po3);
+
+        camp::Class::declare<MyClass4>("InheritanceTest::MyClass4")
+            .base<MyClass3>()
+            .function("f4", &MyClass4::f4)
+            .property("p4", &MyClass4::p4)
+            .function("overridden", &MyClass4::fo4)
+            .property("overridden", &MyClass4::po4);
+    }
+}
+
+CAMP_AUTO_TYPE(InheritanceTest::MyClass1, &InheritanceTest::declare)
+CAMP_AUTO_TYPE(InheritanceTest::MyClass2, &InheritanceTest::declare)
+CAMP_AUTO_TYPE(InheritanceTest::MyClass3, &InheritanceTest::declare)
+CAMP_AUTO_TYPE(InheritanceTest::MyClass4, &InheritanceTest::declare)
+
+#endif // CAMPTEST_INHERITANCE_HPP
diff --git a/test/main.cpp b/test/main.cpp
new file mode 100644
index 0000000..f7a13ee
--- /dev/null
+++ b/test/main.cpp
@@ -0,0 +1,30 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+// This must be defined once in the entire project
+#define BOOST_TEST_MODULE CAMP test
+
+// This will embed the whole source code of boost.test,
+// so that we don't need to link to it as an external library.
+// Note: to disable that and link to boost.test as a library,
+// simply remove "/included" from the header path below.
+#include <boost/test/included/unit_test.hpp>
diff --git a/test/mapper.cpp b/test/mapper.cpp
new file mode 100644
index 0000000..b0dd8cb
--- /dev/null
+++ b/test/mapper.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "mapper.hpp"
+#include <camp/classget.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace MapperTest;
+
+//-----------------------------------------------------------------------------
+struct MapperFixture
+{
+    MapperFixture()
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for mappers
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(MAPPER, MapperFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(count)
+{
+    BOOST_CHECK_EQUAL(metaclass->propertyCount(), static_cast<std::size_t>(MyClass::propertyCount));
+    BOOST_CHECK_EQUAL(metaclass->functionCount(), static_cast<std::size_t>(MyClass::functionCount));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(types)
+{
+    BOOST_CHECK_EQUAL(metaclass->property(0).type(), camp::intType);
+    BOOST_CHECK_EQUAL(metaclass->function(0).returnType(), camp::stringType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(argCount)
+{
+    BOOST_CHECK_EQUAL(metaclass->function(0).argCount(), 0);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(propertyGet)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(metaclass->property("prop0").get(object), camp::Value(object.prop("prop0")));
+    BOOST_CHECK_EQUAL(metaclass->property("prop1").get(object), camp::Value(object.prop("prop1")));
+    BOOST_CHECK_EQUAL(metaclass->property("prop2").get(object), camp::Value(object.prop("prop2")));
+    BOOST_CHECK_EQUAL(metaclass->property("prop3").get(object), camp::Value(object.prop("prop3")));
+    BOOST_CHECK_EQUAL(metaclass->property("prop4").get(object), camp::Value(object.prop("prop4")));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(propertySet)
+{
+    MyClass object;
+
+    metaclass->property("prop0").set(object, 0);
+    metaclass->property("prop1").set(object, 100);
+    metaclass->property("prop2").set(object, 200);
+    metaclass->property("prop3").set(object, 300);
+    metaclass->property("prop4").set(object, 400);
+
+    BOOST_CHECK_EQUAL(object.prop("prop0"), 0);
+    BOOST_CHECK_EQUAL(object.prop("prop1"), 100);
+    BOOST_CHECK_EQUAL(object.prop("prop2"), 200);
+    BOOST_CHECK_EQUAL(object.prop("prop3"), 300);
+    BOOST_CHECK_EQUAL(object.prop("prop4"), 400);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(functionCall)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(metaclass->function("func0").call(object), camp::Value(object.func("func0")));
+    BOOST_CHECK_EQUAL(metaclass->function("func1").call(object), camp::Value(object.func("func1")));
+    BOOST_CHECK_EQUAL(metaclass->function("func2").call(object), camp::Value(object.func("func2")));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/mapper.hpp b/test/mapper.hpp
new file mode 100644
index 0000000..2b0347f
--- /dev/null
+++ b/test/mapper.hpp
@@ -0,0 +1,148 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_MAPPER_HPP
+#define CAMPTEST_MAPPER_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/simpleproperty.hpp>
+#include <camp/function.hpp>
+#include <map>
+#include <string>
+
+namespace MapperTest
+{
+    struct MyClass
+    {
+        enum
+        {
+            propertyCount = 5,
+            functionCount = 3
+        };
+
+        static std::string property(std::size_t index)
+        {
+            const char* names[] = {"prop0", "prop1", "prop2", "prop3", "prop4"};
+            return names[index];
+        }
+
+        static std::string function(std::size_t index)
+        {
+            const char* names[] = {"func0", "func1", "func2"};
+            return names[index];
+        }
+
+        MyClass()
+        {
+            m_props[property(0)] = 0;
+            m_props[property(1)] = 10;
+            m_props[property(2)] = 20;
+            m_props[property(3)] = 30;
+            m_props[property(4)] = 40;
+        }
+
+        int& prop(const std::string& name)
+        {
+            return m_props[name];
+        }
+
+        std::string func(const std::string& name)
+        {
+            return name + "_called";
+        }
+
+        std::map<std::string, int> m_props;
+    };
+
+    template <typename T>
+    struct MyMapper
+    {
+        std::size_t propertyCount()
+        {
+            return T::propertyCount;
+        }
+
+        camp::Property* property(std::size_t index)
+        {
+            return new MyProperty(T::property(index));
+        }
+
+        std::size_t functionCount()
+        {
+            return T::functionCount;
+        }
+
+        camp::Function* function(std::size_t index)
+        {
+            return new MyFunction(T::function(index));
+        }
+
+        struct MyProperty : public camp::SimpleProperty
+        {
+        public:
+
+            MyProperty(const std::string& name)
+                : camp::SimpleProperty(name, camp::intType)
+            {
+            }
+
+            virtual camp::Value getValue(const camp::UserObject& object) const
+            {
+                T& t = object.get<T>();
+                return t.prop(name());
+            }
+
+            virtual void setValue(const camp::UserObject& object, const camp::Value& value) const
+            {
+                T& t = object.get<T>();
+                t.prop(name()) = value.to<int>();
+            }
+        };
+
+        class MyFunction : public camp::Function
+        {
+        public:
+
+            MyFunction(const std::string& name)
+                : camp::Function(name, camp::stringType)
+            {
+            }
+
+            virtual camp::Value execute(const camp::UserObject& object, const camp::Args&) const
+            {
+                T& t = object.get<T>();
+                return t.func(name());
+            }
+        };
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyClass>("MapperTest::MyClass")
+            .external<MyMapper>();
+    }
+}
+
+CAMP_AUTO_TYPE(MapperTest::MyClass, &MapperTest::declare)
+
+#endif // CAMPTEST_MAPPER_HPP
diff --git a/test/property.cpp b/test/property.cpp
new file mode 100644
index 0000000..80c4ec4
--- /dev/null
+++ b/test/property.cpp
@@ -0,0 +1,251 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "property.hpp"
+#include <camp/classget.hpp>
+#include <camp/enumget.hpp>
+#include <camp/property.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace PropertyTest;
+
+//-----------------------------------------------------------------------------
+struct PropertyFixture
+{
+    PropertyFixture()
+    {
+        const camp::Class& metaclass = camp::classByType<MyClass>();
+        for (int i = 1; i < 25; ++i)
+        {
+            if (i != 7 && i != 8 && i != 22) // remove when fixed
+                properties[i] = &metaclass.property("p" + boost::lexical_cast<std::string>(i));
+        }
+    }
+
+    const camp::Property* properties[25];
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Property
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(PROPERTY, PropertyFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(properties[1]->type(),  camp::boolType);
+    BOOST_CHECK_EQUAL(properties[2]->type(),  camp::intType);
+    BOOST_CHECK_EQUAL(properties[3]->type(),  camp::stringType);
+    BOOST_CHECK_EQUAL(properties[4]->type(),  camp::userType);
+    BOOST_CHECK_EQUAL(properties[5]->type(),  camp::boolType);
+    BOOST_CHECK_EQUAL(properties[6]->type(),  camp::intType);
+    //BOOST_CHECK_EQUAL(properties[7]->type(),  camp::stringType);
+    //BOOST_CHECK_EQUAL(properties[8]->type(),  camp::enumType);
+    BOOST_CHECK_EQUAL(properties[9]->type(),  camp::userType);
+    BOOST_CHECK_EQUAL(properties[10]->type(), camp::boolType);
+    BOOST_CHECK_EQUAL(properties[11]->type(), camp::intType);
+    BOOST_CHECK_EQUAL(properties[12]->type(), camp::stringType);
+    BOOST_CHECK_EQUAL(properties[13]->type(), camp::enumType);
+    BOOST_CHECK_EQUAL(properties[14]->type(), camp::boolType);
+    BOOST_CHECK_EQUAL(properties[15]->type(), camp::intType);
+    BOOST_CHECK_EQUAL(properties[16]->type(), camp::stringType);
+    BOOST_CHECK_EQUAL(properties[17]->type(), camp::userType);
+    BOOST_CHECK_EQUAL(properties[18]->type(), camp::boolType);
+    BOOST_CHECK_EQUAL(properties[19]->type(), camp::intType);
+    BOOST_CHECK_EQUAL(properties[20]->type(), camp::realType);
+    BOOST_CHECK_EQUAL(properties[21]->type(), camp::intType);
+    //BOOST_CHECK_EQUAL(properties[22]->type(), camp::enumType);
+    BOOST_CHECK_EQUAL(properties[23]->type(), camp::stringType);
+    BOOST_CHECK_EQUAL(properties[24]->type(), camp::userType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(name)
+{
+    BOOST_CHECK_EQUAL(properties[1]->name(),  "p1");
+    BOOST_CHECK_EQUAL(properties[2]->name(),  "p2");
+    BOOST_CHECK_EQUAL(properties[3]->name(),  "p3");
+    BOOST_CHECK_EQUAL(properties[4]->name(),  "p4");
+    BOOST_CHECK_EQUAL(properties[5]->name(),  "p5");
+    BOOST_CHECK_EQUAL(properties[6]->name(),  "p6");
+    //BOOST_CHECK_EQUAL(properties[7]->name(),  "p7");
+    //BOOST_CHECK_EQUAL(properties[8]->name(),  "p8");
+    BOOST_CHECK_EQUAL(properties[9]->name(),  "p9");
+    BOOST_CHECK_EQUAL(properties[10]->name(), "p10");
+    BOOST_CHECK_EQUAL(properties[11]->name(), "p11");
+    BOOST_CHECK_EQUAL(properties[12]->name(), "p12");
+    BOOST_CHECK_EQUAL(properties[13]->name(), "p13");
+    BOOST_CHECK_EQUAL(properties[14]->name(), "p14");
+    BOOST_CHECK_EQUAL(properties[15]->name(), "p15");
+    BOOST_CHECK_EQUAL(properties[16]->name(), "p16");
+    BOOST_CHECK_EQUAL(properties[17]->name(), "p17");
+    BOOST_CHECK_EQUAL(properties[18]->name(), "p18");
+    BOOST_CHECK_EQUAL(properties[19]->name(), "p19");
+    BOOST_CHECK_EQUAL(properties[20]->name(), "p20");
+    BOOST_CHECK_EQUAL(properties[21]->name(), "p21");
+    //BOOST_CHECK_EQUAL(properties[22]->name(), "p22");
+    BOOST_CHECK_EQUAL(properties[23]->name(), "p23");
+    BOOST_CHECK_EQUAL(properties[24]->name(), "p24");
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(readable)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(properties[1]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[2]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[3]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[4]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[5]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[6]->readable(object),  true);
+    //BOOST_CHECK_EQUAL(properties[7]->readable(object),  true);
+    //BOOST_CHECK_EQUAL(properties[8]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[9]->readable(object),  true);
+    BOOST_CHECK_EQUAL(properties[10]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[11]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[12]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[13]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[14]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[15]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[16]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[17]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[18]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[19]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[20]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[21]->readable(object), true);
+    //BOOST_CHECK_EQUAL(properties[22]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[23]->readable(object), true);
+    BOOST_CHECK_EQUAL(properties[24]->readable(object), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(writable)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(properties[1]->writable(object),  false);
+    BOOST_CHECK_EQUAL(properties[2]->writable(object),  false);
+    BOOST_CHECK_EQUAL(properties[3]->writable(object),  true);
+    BOOST_CHECK_EQUAL(properties[4]->writable(object),  true);
+    BOOST_CHECK_EQUAL(properties[5]->writable(object),  true);
+    BOOST_CHECK_EQUAL(properties[6]->writable(object),  false);
+    //BOOST_CHECK_EQUAL(properties[7]->writable(object),  true);
+    //BOOST_CHECK_EQUAL(properties[8]->writable(object),  false);
+    BOOST_CHECK_EQUAL(properties[9]->writable(object),  true);
+    BOOST_CHECK_EQUAL(properties[10]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[11]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[12]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[13]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[14]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[15]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[16]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[17]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[18]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[19]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[20]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[21]->writable(object), true);
+    //BOOST_CHECK_EQUAL(properties[22]->writable(object), true);
+    BOOST_CHECK_EQUAL(properties[23]->writable(object), false);
+    BOOST_CHECK_EQUAL(properties[24]->writable(object), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    MyClass object;
+
+    BOOST_CHECK_EQUAL(properties[1]->get(object),  camp::Value(object.p1));
+    BOOST_CHECK_EQUAL(properties[2]->get(object),  camp::Value(object.p2));
+    BOOST_CHECK_EQUAL(properties[3]->get(object),  camp::Value(object.p3));
+    BOOST_CHECK_EQUAL(properties[4]->get(object),  camp::Value(object.p4));
+    BOOST_CHECK_EQUAL(properties[5]->get(object),  camp::Value(object.p5));
+    BOOST_CHECK_EQUAL(properties[6]->get(object),  camp::Value(object.p6));
+    //BOOST_CHECK_EQUAL(properties[7]->get(object),  camp::Value(object.p7_impl));
+    //BOOST_CHECK_EQUAL(properties[8]->get(object),  camp::Value(object.p8_impl));
+    BOOST_CHECK_EQUAL(properties[9]->get(object),  camp::Value(*object.p9));
+    BOOST_CHECK_EQUAL(properties[10]->get(object), camp::Value(object.p10));
+    BOOST_CHECK_EQUAL(properties[11]->get(object), camp::Value(object.p11));
+    BOOST_CHECK_EQUAL(properties[12]->get(object), camp::Value(object.p12));
+    BOOST_CHECK_EQUAL(properties[13]->get(object), camp::Value(object.p13));
+    BOOST_CHECK_EQUAL(properties[14]->get(object), camp::Value(object.inner.p14));
+    BOOST_CHECK_EQUAL(properties[15]->get(object), camp::Value(object.inner.p15));
+    BOOST_CHECK_EQUAL(properties[16]->get(object), camp::Value(object.inner.p16));
+    BOOST_CHECK_EQUAL(properties[17]->get(object), camp::Value(object.inner.p17));
+    BOOST_CHECK_EQUAL(properties[18]->get(object), camp::Value(object.p18));
+    BOOST_CHECK_EQUAL(properties[19]->get(object), camp::Value(object.p19));
+    BOOST_CHECK_EQUAL(properties[20]->get(object), camp::Value(object.p20));
+    BOOST_CHECK_EQUAL(properties[21]->get(object), camp::Value(object.p21));
+    //BOOST_CHECK_EQUAL(properties[22]->get(object), camp::Value(object.p22));
+    BOOST_CHECK_EQUAL(properties[23]->get(object), camp::Value(object.getP23("str")));
+    BOOST_CHECK_EQUAL(properties[24]->get(object), camp::Value(object.p24));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    MyClass object;
+
+    BOOST_CHECK_THROW(properties[1]->set(object, false),  camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[2]->set(object, -2),     camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[6]->set(object, -6),     camp::ForbiddenWrite);
+    //BOOST_CHECK_THROW(properties[8]->set(object, Two),  camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[10]->set(object, false), camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[11]->set(object, -11),   camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[15]->set(object, -15),   camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[16]->set(object, "-16"), camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[18]->set(object, false), camp::ForbiddenWrite);
+    BOOST_CHECK_THROW(properties[23]->set(object, "-23"), camp::ForbiddenWrite);
+
+    properties[3]->set(object,  "-3");
+    properties[4]->set(object,  MyType(-4));
+    properties[5]->set(object,  true);
+    //properties[7]->set(object,  "-7");
+    properties[9]->set(object,  MyType(-9));
+    properties[12]->set(object, "-12");
+    properties[13]->set(object, Zero);
+    properties[14]->set(object, false);
+    properties[17]->set(object, MyType(-17));
+    properties[19]->set(object, -19);
+    properties[20]->set(object, -20.);
+    properties[21]->set(object, -21);
+    //properties[22]->set(object, One);
+    properties[24]->set(object, MyType(-24));
+
+    BOOST_CHECK_EQUAL(object.p3,        "-3");
+    BOOST_CHECK_EQUAL(object.p4,        MyType(-4));
+    BOOST_CHECK_EQUAL(object.p5,        true);
+    //BOOST_CHECK_EQUAL(object.p7,        "-7");
+    BOOST_CHECK_EQUAL(*object.p9,       MyType(-9));
+    BOOST_CHECK_EQUAL(object.p12,       "-12");
+    BOOST_CHECK_EQUAL(object.p13,       Zero);
+    BOOST_CHECK_EQUAL(object.inner.p14, false);
+    BOOST_CHECK_EQUAL(object.inner.p17, MyType(-17));
+    BOOST_CHECK_EQUAL(object.p19,       -19);
+    BOOST_CHECK_EQUAL(object.p20,       -20.);
+    BOOST_CHECK_EQUAL(object.p21,       -21);
+    //BOOST_CHECK_EQUAL(object.p22,       One);
+    BOOST_CHECK_EQUAL(object.p24,       MyType(-24));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/property.hpp b/test/property.hpp
new file mode 100644
index 0000000..8fc83e8
--- /dev/null
+++ b/test/property.hpp
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_PROPERTY_HPP
+#define CAMPTEST_PROPERTY_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/enum.hpp>
+#include <boost/shared_ptr.hpp>
+#include <string>
+
+namespace PropertyTest
+{
+    enum MyEnum
+    {
+        Zero = 0,
+        One  = 1,
+        Two  = 2
+    };
+
+    struct MyType
+    {
+        MyType(int x_) : x(x_) {}
+        int x;
+    };
+
+    bool operator==(const MyType& left, const MyType& right) {return left.x == right.x;}
+    bool operator<(const MyType& left, const MyType& right) {return left.x < right.x;}
+    std::ostream& operator<<(std::ostream& stream, const MyType& object) {return stream << object.x;}
+
+    struct MyClass
+    {
+        MyClass()
+            : p1(true)
+            , p2(2)
+            , p3("3")
+            , p4(MyType(4))
+            , p5(false)
+            , p6(6)
+            , p7_impl("7"), p7(&p7_impl)
+            , p8_impl(One), p8(&p8_impl)
+            , p9(new MyType(9))
+            , p10(true)
+            , p11(11)
+            , p12("12")
+            , p13(Two)
+            , p18(true)
+            , p19(19)
+            , p20(20.)
+            , p21(21)
+            , p22(Two)
+            , p24(MyType(24))
+        {
+        }
+
+        // ***** properties used in non-member functions *****
+        bool p1;
+        int p2;
+        std::string p3;
+        MyType p4;
+
+        // ***** properties used as direct pointer to members *****
+        bool p5;
+        const int p6;
+        std::string p7_impl; std::string* p7;
+        MyEnum p8_impl; const MyEnum* p8;
+        boost::shared_ptr<MyType> p9;
+
+        // ***** member functions *****
+        bool p10; bool getP10() {return p10;}
+        int p11; int getP11() const {return p11;}
+        std::string p12; std::string& getP12() {return p12;}
+        MyEnum p13; MyEnum getP13() const {return p13;} void setP13(MyEnum e) {p13 = e;}
+
+        // ***** nested properties *****
+        struct Inner
+        {
+            Inner() : p14(false), p15(15), p16("16"), p17(MyType(17)) {}
+            bool p14;
+            const int p15;
+            std::string p16; std::string getP16() const {return p16;}
+            MyType p17; const MyType& getP17() const {return p17;} void setP17(MyType t) {p17 = t;}
+        };
+        Inner inner;
+        Inner& getInner() {return inner;}
+
+        // ***** properties used with boost::function *****
+        bool p18;
+        int p19; int& getP19() {return p19;}
+        double p20; double getP20() const {return p20;} void setP20(double d) {p20 = d;}
+
+        // ***** properties used with boost::bind *****
+        int p21;
+        MyEnum p22; MyEnum* getP22() {return &p22;}
+        std::string getP23(const std::string& str) const {return str + "23";}
+        MyType p24; const MyType& getP24() const {return p24;} void setP24(MyType t) {p24 = t;}
+    };
+
+    bool getP1(const MyClass& object) {return object.p1;}
+
+    const int& getP2(MyClass& object) {return object.p2;}
+
+    std::string& getP3(MyClass& object) {return object.p3;}
+
+    const MyType& getP4(const MyClass& object) {return object.p4;}
+    void setP4(MyClass& object, MyType value) {object.p4 = value;}
+
+    int& getP21(MyClass& object) {return object.p21;}
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("PropertyTest::MyEnum")
+            .value("Zero", Zero)
+            .value("One",  One)
+            .value("Two",  Two);
+
+        camp::Class::declare<MyType>("PropertyTest::MyType");
+
+        camp::Class::declare<MyClass>("PropertyTest::MyClass")
+
+            // ***** non-member functions *****
+            .property("p1", &getP1)         // read-only getter (const param)
+            .property("p2", &getP2)         // read-only getter (const return)
+            .property("p3", &getP3)         // read-write getter
+            .property("p4", &getP4, &setP4) // getter + setter
+
+            // ***** pointer to members *****
+            .property("p5", &MyClass::p5) // pointer to read-write member
+            .property("p6", &MyClass::p6) // pointer to const member
+            // TOFIX .property("p7", &MyClass::p7) // pointer to read-write pointer member
+            // TOFIX .property("p8", &MyClass::p8) // pointer to const pointer member
+            .property("p9", &MyClass::p9) // pointer to read-write smart pointer member
+
+            // ***** members functions *****
+            .property("p10", &MyClass::getP10)                   // read-only getter (return by value)
+            .property("p11", &MyClass::getP11)                   // read-only getter (const)
+            .property("p12", &MyClass::getP12)                   // read-write getter
+            .property("p13", &MyClass::getP13, &MyClass::setP13) // read-only getter + write-only setter
+
+            // ***** nested functions *****
+            .property("p14", &MyClass::Inner::p14, &MyClass::getInner)    // pointer to read-write member
+            .property("p15", &MyClass::Inner::p15, &MyClass::inner)       // Pointer to read-only member
+            .property("p16", &MyClass::Inner::getP16, &MyClass::getInner) // read-only getter
+            .property("p17", &MyClass::Inner::getP17,
+                             &MyClass::Inner::setP17, &MyClass::inner)    // read-only getter + write-only setter
+
+            // ***** boost::function *****
+            .property("p18", boost::function<bool (MyClass&)>(&MyClass::p18))    // pointer to read-write member
+            .property("p19", boost::function<int& (MyClass&)>(&MyClass::getP19)) // read-write getter
+            .property("p20", boost::function<double (MyClass&)>(&MyClass::getP20),
+                             boost::function<void (MyClass&, double)>(&MyClass::setP20)) // read-only getter + write-only setter
+
+            // ***** boost::bind *****
+            .property("p21", boost::bind(&getP21, _1))                 // non-member read-write getter
+            // TOFIX .property("p22", boost::bind(&MyClass::getP22, _1))        // read-write getter to pointer
+            .property("p23", boost::bind(&MyClass::getP23, _1, "str")) // read-only getter + extra parameter
+            .property("p24", boost::bind(&MyClass::getP24, _1),
+                             boost::bind(&MyClass::setP24, _1, _2))    // read-only getter + write-only setter
+            ;
+    }
+}
+
+CAMP_AUTO_TYPE(PropertyTest::MyEnum,  &PropertyTest::declare)
+CAMP_AUTO_TYPE(PropertyTest::MyType,  &PropertyTest::declare)
+CAMP_AUTO_TYPE(PropertyTest::MyClass, &PropertyTest::declare)
+
+#endif // CAMPTEST_PROPERTY_HPP
diff --git a/test/propertyaccess.cpp b/test/propertyaccess.cpp
new file mode 100644
index 0000000..fec0720
--- /dev/null
+++ b/test/propertyaccess.cpp
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "propertyaccess.hpp"
+#include <camp/classget.hpp>
+#include <camp/property.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace PropertyAccessTest;
+
+//-----------------------------------------------------------------------------
+struct PropertyAccessFixture
+{
+    PropertyAccessFixture()
+        : object_t(true)
+        , object_f(false)
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    MyClass object_t;
+    MyClass object_f;
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Property readable/writable
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(PROPERTYACCESS, PropertyAccessFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(readableImplicit)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("p8").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p8").readable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p9").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p9").readable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p10").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p10").readable(object_f), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(readableStatic)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("p0").readable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p0").readable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p1").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p1").readable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p2").readable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p2").readable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p3").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p3").readable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p4").readable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p4").readable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p5").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p5").readable(object_f), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(readableDynamic)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("p6").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p6").readable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p7").readable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p7").readable(object_f), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(writableImplicit)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("p8").writable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p8").writable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p9").writable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p9").writable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p10").writable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p10").writable(object_f), true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(writableStatic)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("p0").writable(object_t), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p0").writable(object_f), true);
+    BOOST_CHECK_EQUAL(metaclass->property("p1").writable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p1").writable(object_f), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p2").writable(object_t), false);
+    BOOST_CHECK_EQUAL(metaclass->property("p2").writable(object_f), false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/propertyaccess.hpp b/test/propertyaccess.hpp
new file mode 100644
index 0000000..3097232
--- /dev/null
+++ b/test/propertyaccess.hpp
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_PROPERTYACCESS_HPP
+#define CAMPTEST_PROPERTYACCESS_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+
+namespace PropertyAccessTest
+{
+    struct MyClass
+    {
+        MyClass(bool b = true)
+            : m_b(b)
+        {
+        }
+
+        void set(int x) {p = x;}
+        int get() const {return p;}
+        int& ref() {return p;}
+        int p;
+
+        bool m_b;
+        bool b1() {return true;}
+        bool b2() const {return false;}
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyClass>("PropertyAccessTest::MyClass")
+
+            // ***** constant value *****
+            .property("p0", &MyClass::p).readable(false).writable(true)
+            .property("p1", &MyClass::p).readable(true).writable(false)
+            .property("p2", &MyClass::p).readable(false).writable(false)
+
+            // ***** function *****
+            .property("p3", &MyClass::p).readable(&MyClass::b1)
+            .property("p4", &MyClass::p).readable(&MyClass::b2)
+            .property("p5", &MyClass::p).readable(boost::bind(&MyClass::b1, _1))
+            .property("p6", &MyClass::p).readable(&MyClass::m_b)
+            .property("p7", &MyClass::p).readable(boost::function<bool (MyClass&)>(&MyClass::m_b))
+
+            // ***** implicit - based on the availability of a getter/setter *****
+            .property("p8",  &MyClass::get)
+            .property("p9",  &MyClass::ref)
+            .property("p10", &MyClass::get, &MyClass::set)
+            ;
+    }
+}
+
+CAMP_AUTO_TYPE(PropertyAccessTest::MyClass, &PropertyAccessTest::declare)
+
+#endif // CAMPTEST_PROPERTYACCESS_HPP
diff --git a/test/qt/CMakeLists.txt b/test/qt/CMakeLists.txt
new file mode 100644
index 0000000..030af34
--- /dev/null
+++ b/test/qt/CMakeLists.txt
@@ -0,0 +1,71 @@
+###############################################################################
+##
+## Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+## Contact: Technogerma Systems France Information (contact at technogerma.fr)
+##
+## This file is part of the CAMP library.
+##
+## CAMP is free software: you can redistribute it and/or modify
+## it under the terms of the GNU Lesser General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## CAMP 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 Lesser General Public License for more details.
+## 
+## You should have received a copy of the GNU Lesser General Public License
+## along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+##
+###############################################################################
+
+
+cmake_minimum_required(VERSION 2.6)
+
+# set project's name
+project(CAMP_TEST_QT)
+
+# all source files
+set(CAMP_TEST_QT_SRCS
+    main.cpp
+    functionmapping.cpp
+    functionmapping.hpp
+    propertymapping.cpp
+    propertymapping.hpp
+    qstringmapping.cpp
+)
+
+# find Boost
+find_package(Boost 1.38.0)
+
+# find Qt4
+find_package(Qt4 4.5.0 COMPONENTS QtCore REQUIRED)
+
+# add some useful macros and variables
+# (QT_USE_FILE is a variable defined by find_package( Qt4 ) that contains a path to CMake script)
+include(${QT_USE_FILE})
+
+# this will run moc
+QT4_WRAP_CPP(CAMP_TEST_QT_MOC_SRCS functionmapping.hpp propertymapping.hpp)
+
+# include files search paths
+include_directories(
+    ${CAMP_SOURCE_DIR}/include
+    ${Boost_INCLUDE_DIRS}
+)
+
+# linker search paths
+link_directories(
+    ${CAMP_BINARY_DIR}
+)
+
+# no implicit link to boost.test library
+add_definitions(-DBOOST_TEST_NO_LIB)
+
+# instruct CMake to build an executable from all of the source files
+add_executable(camptest-qt ${CAMP_TEST_QT_SRCS} ${CAMP_TEST_QT_MOC_SRCS})
+
+# last thing we have to do is to tell CMake what libraries our executable needs
+target_link_libraries(camptest-qt camp ${QT_LIBRARIES})
+
diff --git a/test/qt/functionmapping.cpp b/test/qt/functionmapping.cpp
new file mode 100644
index 0000000..9f70603
--- /dev/null
+++ b/test/qt/functionmapping.cpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "functionmapping.hpp"
+#include <camp/class.hpp>
+#include <camp/classget.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace FunctionMappingTest;
+
+//-----------------------------------------------------------------------------
+struct FunctionMappingFixture
+{
+    FunctionMappingFixture()
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    MyClass object;
+    const camp::Class* metaclass;
+};
+
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp_ext::QtMapper (functions)
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(FUNCTIONMAPPING, FunctionMappingFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(name)
+{
+    BOOST_CHECK(metaclass->hasFunction("f1"));
+    BOOST_CHECK(metaclass->hasFunction("f2"));
+    BOOST_CHECK(metaclass->hasFunction("f3"));
+    BOOST_CHECK(metaclass->hasFunction("f4"));
+    BOOST_CHECK(metaclass->hasFunction("f5"));
+    BOOST_CHECK(metaclass->hasFunction("f6"));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(returnType)
+{
+    BOOST_CHECK_EQUAL(metaclass->function("f1").returnType(), camp::noType);
+    BOOST_CHECK_EQUAL(metaclass->function("f2").returnType(), camp::boolType);
+    BOOST_CHECK_EQUAL(metaclass->function("f3").returnType(), camp::intType);
+    BOOST_CHECK_EQUAL(metaclass->function("f4").returnType(), camp::intType);
+    BOOST_CHECK_EQUAL(metaclass->function("f5").returnType(), camp::realType);
+    BOOST_CHECK_EQUAL(metaclass->function("f6").returnType(), camp::stringType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(argumentsCount)
+{
+    BOOST_CHECK_EQUAL(metaclass->function("f1").argCount(), 0);
+    BOOST_CHECK_EQUAL(metaclass->function("f2").argCount(), 1);
+    BOOST_CHECK_EQUAL(metaclass->function("f3").argCount(), 2);
+    BOOST_CHECK_EQUAL(metaclass->function("f4").argCount(), 3);
+    BOOST_CHECK_EQUAL(metaclass->function("f5").argCount(), 4);
+    BOOST_CHECK_EQUAL(metaclass->function("f6").argCount(), 5);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(call)
+{
+    BOOST_CHECK_EQUAL(metaclass->function("f1").call(object), camp::Value::nothing);
+    BOOST_CHECK_EQUAL(metaclass->function("f2").call(object, camp::Args(true)).to<bool>(), true);
+    BOOST_CHECK_EQUAL(metaclass->function("f3").call(object, camp::Args(-1, -9)).to<int>(), -10);
+    BOOST_CHECK_EQUAL(metaclass->function("f4").call(object, camp::Args(1, 4, 15)).to<unsigned long>(), 20);
+    BOOST_CHECK_CLOSE(metaclass->function("f5").call(object, camp::Args(1., 2., 3., .5)).to<double>(), 6.5, 1E-5);
+    BOOST_CHECK_EQUAL(metaclass->function("f6").call(object, camp::Args("h", "e", "l", "l", "o")).to<QString>(), "hello");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/qt/functionmapping.hpp b/test/qt/functionmapping.hpp
new file mode 100644
index 0000000..e410a41
--- /dev/null
+++ b/test/qt/functionmapping.hpp
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_QT_FUNCTIONMAPPING_HPP
+#define CAMPTEST_QT_FUNCTIONMAPPING_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/qt/qt.hpp>
+#include <camp/class.hpp>
+#include <QObject>
+#include <QString>
+#include <iostream>
+
+namespace FunctionMappingTest
+{
+    class MyClass : public QObject
+    {
+        Q_OBJECT
+
+    public slots:
+
+        void f1()
+        {
+        }
+
+        bool f2(bool b)
+        {
+            return b;
+        }
+
+        int f3(int i1, int i2)
+        {
+            return i1 + i2;
+        }
+
+        long f4(long l1, long l2, long l3)
+        {
+            return l1 + l2 + l3;
+        }
+
+        double f5(double d1, double d2, double d3, double d4)
+        {
+            return d1 + d2 + d3 + d4;
+        }
+
+        QString f6(QString s1, QString s2, QString s3, QString s4, QString s5)
+        {
+            return s1 + s2 + s3 + s4 + s5;
+        }
+    };
+
+    inline void declare()
+    {
+        camp::Class::declare<MyClass>("FunctionMappingTest::MyClass")
+            .external<camp_ext::QtMapper>();
+    }
+}
+
+CAMP_AUTO_TYPE_NONCOPYABLE(FunctionMappingTest::MyClass, &FunctionMappingTest::declare);
+
+// To make the boost.test logger happy
+inline std::ostream& operator<<(std::ostream& stream, const QString& string)
+{
+    return stream << string.toStdString();
+}
+
+#endif // CAMPTEST_QT_FUNCTIONMAPPING_HPP
diff --git a/test/qt/main.cpp b/test/qt/main.cpp
new file mode 100644
index 0000000..2485ef3
--- /dev/null
+++ b/test/qt/main.cpp
@@ -0,0 +1,30 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+// This must be defined once in the entire project
+#define BOOST_TEST_MODULE CAMP testqt
+
+// This will embed the whole source code of boost.test,
+// so that we don't need to link to it as an external library.
+// Note: to disable that and link to boost.test as a library,
+// simply remove "/included" from the header path below.
+#include <boost/test/included/unit_test.hpp>
diff --git a/test/qt/propertymapping.cpp b/test/qt/propertymapping.cpp
new file mode 100644
index 0000000..cd5985e
--- /dev/null
+++ b/test/qt/propertymapping.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "propertymapping.hpp"
+#include <camp/class.hpp>
+#include <camp/classget.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace PropertyMappingTest;
+
+//-----------------------------------------------------------------------------
+struct PropertyMappingFixture
+{
+    PropertyMappingFixture()
+    {
+        metaclass = &camp::classByType<MyClass>();
+
+        object.setBool(true);
+        object.setInt(-10);
+        object.setULong(20);
+        object.setDouble(0.55);
+        object.setString("hello");
+        object.setEnum(MyClass::two);
+    }
+
+    MyClass object;
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp_ext::QtMapper (properties)
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(PROPERTYMAPPING, PropertyMappingFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(name)
+{
+    BOOST_CHECK(metaclass->hasProperty("m_bool_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_int_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_ulong_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_double_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_string_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_enum_read"));
+    BOOST_CHECK(metaclass->hasProperty("m_bool"));
+    BOOST_CHECK(metaclass->hasProperty("m_int"));
+    BOOST_CHECK(metaclass->hasProperty("m_ulong"));
+    BOOST_CHECK(metaclass->hasProperty("m_double"));
+    BOOST_CHECK(metaclass->hasProperty("m_string"));
+    BOOST_CHECK(metaclass->hasProperty("m_enum"));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("m_bool_read").type(),   camp::boolType);
+    BOOST_CHECK_EQUAL(metaclass->property("m_int_read").type(),    camp::intType);
+    BOOST_CHECK_EQUAL(metaclass->property("m_ulong_read").type(),  camp::intType);
+    BOOST_CHECK_EQUAL(metaclass->property("m_double_read").type(), camp::realType);
+    BOOST_CHECK_EQUAL(metaclass->property("m_string_read").type(), camp::stringType);
+    BOOST_CHECK_EQUAL(metaclass->property("m_enum_read").type(),   camp::enumType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    BOOST_CHECK_EQUAL(metaclass->property("m_bool_read").get(object).to<bool>(),           true);
+    BOOST_CHECK_EQUAL(metaclass->property("m_int_read").get(object).to<int>(),             -10);
+    BOOST_CHECK_EQUAL(metaclass->property("m_ulong_read").get(object).to<unsigned long>(), 20);
+    BOOST_CHECK_CLOSE(metaclass->property("m_double_read").get(object).to<double>(),       0.55, 1E-5);
+    BOOST_CHECK_EQUAL(metaclass->property("m_string_read").get(object).to<QString>(),      "hello");
+    BOOST_CHECK_EQUAL(metaclass->property("m_enum_read").get(object).to<MyClass::Enum>(),  MyClass::two);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    metaclass->property("m_bool").set(object, false);
+    metaclass->property("m_int").set(object, -2);
+    metaclass->property("m_ulong").set(object, 50);
+    metaclass->property("m_double").set(object, -8.8);
+    metaclass->property("m_string").set(object, "bonjour");
+    metaclass->property("m_enum").set(object, MyClass::three);
+
+    BOOST_CHECK_EQUAL(metaclass->property("m_bool").get(object).to<bool>(),           false);
+    BOOST_CHECK_EQUAL(metaclass->property("m_int").get(object).to<int>(),             -2);
+    BOOST_CHECK_EQUAL(metaclass->property("m_ulong").get(object).to<unsigned long>(), 50);
+    BOOST_CHECK_CLOSE(metaclass->property("m_double").get(object).to<double>(),       -8.8, 1E-5);
+    BOOST_CHECK_EQUAL(metaclass->property("m_string").get(object).to<QString>(),      "bonjour");
+    BOOST_CHECK_EQUAL(metaclass->property("m_enum").get(object).to<MyClass::Enum>(),  MyClass::three);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/qt/propertymapping.hpp b/test/qt/propertymapping.hpp
new file mode 100644
index 0000000..5d13adc
--- /dev/null
+++ b/test/qt/propertymapping.hpp
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_QT_PROPERTYMAPPING_HPP
+#define CAMPTEST_QT_PROPERTYMAPPING_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/qt/qt.hpp>
+#include <QObject>
+#include <QString>
+#include <iostream>
+
+namespace PropertyMappingTest
+{
+    class MyClass : public QObject
+    {
+        Q_OBJECT
+
+    public:
+
+        enum Enum
+        {
+            one   = 1,
+            two   = 2,
+            three = 3
+        };
+        Q_ENUMS(Enum)
+
+    public :
+
+        // read only
+        Q_PROPERTY(bool          m_bool_read   READ getBool)
+        Q_PROPERTY(int           m_int_read    READ getInt)
+        Q_PROPERTY(unsigned long m_ulong_read  READ getULong)
+        Q_PROPERTY(double        m_double_read READ getDouble)
+        Q_PROPERTY(QString       m_string_read READ getString)
+        Q_PROPERTY(Enum          m_enum_read   READ getEnum)
+
+        // read-write
+        Q_PROPERTY(bool          m_bool   READ getBool   WRITE setBool)
+        Q_PROPERTY(int           m_int    READ getInt    WRITE setInt)
+        Q_PROPERTY(unsigned long m_ulong  READ getULong  WRITE setULong)
+        Q_PROPERTY(double        m_double READ getDouble WRITE setDouble)
+        Q_PROPERTY(QString       m_string READ getString WRITE setString)
+        Q_PROPERTY(Enum          m_enum   READ getEnum   WRITE setEnum)
+
+    public :
+
+        bool getBool() const {return m_bool;}
+        void setBool(bool x) {m_bool = x;}
+
+        int getInt() const {return m_int;}
+        void setInt(int x) {m_int = x;}
+
+        unsigned long getULong() const {return m_ulong;}
+        void setULong(unsigned long x) {m_ulong = x;}
+
+        double getDouble() const {return m_double;}
+        void setDouble(double x) {m_double = x;}
+
+        QString getString() const {return m_string;}
+        void setString(QString x) {m_string = x;}
+
+        Enum getEnum() const {return m_enum;}
+        void setEnum(Enum x) {m_enum = x;}
+
+    private :
+
+        bool m_bool;
+        int m_int;
+        unsigned long m_ulong;
+        double m_double;
+        QString m_string;
+        Enum m_enum;
+    };
+
+    inline void declare()
+    {
+        camp::Enum::declare<MyClass::Enum>("PropertyMappingTest::MyClass::Enum")
+            .value("one", MyClass::one)
+            .value("two", MyClass::two)
+            .value("three", MyClass::three);
+
+        camp::Class::declare<MyClass>("PropertyMappingTest::MyClass")
+            .external<camp_ext::QtMapper>();
+    }
+}
+
+CAMP_AUTO_TYPE_NONCOPYABLE(PropertyMappingTest::MyClass, &PropertyMappingTest::declare)
+CAMP_AUTO_TYPE(PropertyMappingTest::MyClass::Enum, &PropertyMappingTest::declare)
+Q_DECLARE_METATYPE(PropertyMappingTest::MyClass::Enum)
+
+// To make the boost.test logger happy
+inline std::ostream& operator<<(std::ostream& stream, const QString& string)
+{
+    return stream << string.toStdString();
+}
+
+#endif // CAMPTEST_QT_PROPERTYMAPPING_HPP
diff --git a/test/qt/qstringmapping.cpp b/test/qt/qstringmapping.cpp
new file mode 100644
index 0000000..2470af8
--- /dev/null
+++ b/test/qt/qstringmapping.cpp
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include <camp/value.hpp>
+#include <camp/qt/qt.hpp>
+#include <boost/test/unit_test.hpp>
+#include <QString>
+
+// To make the boost.test logger happy
+inline std::ostream& operator<<(std::ostream& stream, const QString& string)
+{
+    return stream << string.toStdString();
+}
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp_ext::ValueMapper<QString>
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_SUITE(QSTRING)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    camp::Value value = QString("hello");
+
+    BOOST_CHECK_EQUAL(value.type(), camp::stringType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(conversionsFromQString)
+{
+    camp::Value value = QString("-10");
+
+    BOOST_CHECK_EQUAL(value.to<int>(),         -10);
+    BOOST_CHECK_CLOSE(value.to<double>(),      -10., 1E-5);
+    BOOST_CHECK_EQUAL(value.to<std::string>(), "-10");
+    BOOST_CHECK_EQUAL(value.to<QString>(),     "-10");
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(conversionsToQString)
+{
+    BOOST_CHECK_EQUAL(camp::Value(false).to<QString>(),                QString("0"));
+    BOOST_CHECK_EQUAL(camp::Value(10).to<QString>(),                   QString("10"));
+    BOOST_CHECK_EQUAL(camp::Value(std::string("hello")).to<QString>(), QString("hello"));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/tagholder.cpp b/test/tagholder.cpp
new file mode 100644
index 0000000..7e21a70
--- /dev/null
+++ b/test/tagholder.cpp
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "tagholder.hpp"
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace TagHolderTest;
+
+//-----------------------------------------------------------------------------
+struct TagHolderFixture
+{
+    TagHolderFixture()
+    {
+        metaclass = &camp::classByType<MyClass>();
+    }
+
+    const camp::Class* metaclass;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::TagHolder
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(TAGHOLDER, TagHolderFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(declare)
+{
+    BOOST_CHECK_EQUAL(metaclass->tagCount(), 16);
+    BOOST_CHECK_EQUAL(metaclass->property("prop").tagCount(), 2);
+    BOOST_CHECK_EQUAL(metaclass->function("func").tagCount(), 2);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    BOOST_CHECK_EQUAL(metaclass->hasTag("a"), true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag("b"), true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag("x"), false);
+
+    BOOST_CHECK_NO_THROW(metaclass->tagId(0));
+    BOOST_CHECK_NO_THROW(metaclass->tagId(1));
+    BOOST_CHECK_THROW(metaclass->tagId(100), camp::OutOfRange);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(staticTags)
+{
+    BOOST_CHECK_EQUAL(metaclass->hasTag(true),    true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(10),      true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(5.25),    true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag("hello"), true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(Ten),     true);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(object1), true);
+
+    BOOST_CHECK_EQUAL(metaclass->hasTag(false),   false);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(20),      false);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(8.78),    false);
+    BOOST_CHECK_EQUAL(metaclass->hasTag("hi"),    false);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(One),     false);
+    BOOST_CHECK_EQUAL(metaclass->hasTag(object2), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(staticValues)
+{
+    BOOST_CHECK_EQUAL(metaclass->tag("static1"), camp::Value(true));
+    BOOST_CHECK_EQUAL(metaclass->tag("static2"), camp::Value(10));
+    BOOST_CHECK_EQUAL(metaclass->tag("static3"), camp::Value(5.25));
+    BOOST_CHECK_EQUAL(metaclass->tag("static4"), camp::Value("hello"));
+    BOOST_CHECK_EQUAL(metaclass->tag("static5"), camp::Value(Ten));
+    BOOST_CHECK_EQUAL(metaclass->tag("static6"), camp::Value(object1));
+    BOOST_CHECK_EQUAL(metaclass->tag("xxxxxxx"), camp::Value::nothing);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(dynamicValues)
+{
+    BOOST_CHECK_EQUAL(metaclass->tag("dynamic1", MyClass(10)), camp::Value(10));
+    BOOST_CHECK_EQUAL(metaclass->tag("dynamic2", MyClass(10)), camp::Value("func"));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/tagholder.hpp b/test/tagholder.hpp
new file mode 100644
index 0000000..1ac2b24
--- /dev/null
+++ b/test/tagholder.hpp
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_TAGHOLDER_HPP
+#define CAMPTEST_TAGHOLDER_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <string>
+
+namespace TagHolderTest
+{
+    struct MyClass
+    {
+        MyClass(int x) : prop(x) {}
+        std::string func() {return "func";}
+        int prop;
+    };
+
+    struct MyType
+    {
+        MyType(int x) : prop(x) {}
+        int prop;
+    };
+
+    enum MyEnum
+    {
+        One = 1,
+        Ten = 10
+    };
+
+    MyType object1(1);
+    MyType object2(2);
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("TagHolderTest::MyEnum");
+
+        camp::Class::declare<MyType>("TagHolderTest::MyType");
+
+        camp::Class::declare<MyClass>("TagHolderTest::MyClass")
+            .tag("a")
+            .tag("b", 0)
+            .tag(true)
+            .tag(10)
+            .tag(5.25)
+            .tag("hello")
+            .tag(Ten)
+            .tag(object1)
+            .tag("static1", true)
+            .tag("static2", 10)
+            .tag("static3", 5.25)
+            .tag("static4", "hello")
+            .tag("static5", Ten)
+            .tag("static6", object1)
+            .tag("dynamic1", &MyClass::prop)
+            .tag("dynamic2", &MyClass::func)
+            .property("prop", &MyClass::prop)
+                .tag("a")
+                .tag("b", 0)
+            .function("func", &MyClass::func)
+                .tag("a")
+                .tag("b", 0);
+    }
+}
+
+CAMP_AUTO_TYPE(TagHolderTest::MyClass, &TagHolderTest::declare)
+CAMP_AUTO_TYPE(TagHolderTest::MyType,  &TagHolderTest::declare)
+CAMP_AUTO_TYPE(TagHolderTest::MyEnum,  &TagHolderTest::declare)
+
+#endif // CAMPTEST_TAGHOLDER_HPP
diff --git a/test/userobject.cpp b/test/userobject.cpp
new file mode 100644
index 0000000..6dda009
--- /dev/null
+++ b/test/userobject.cpp
@@ -0,0 +1,216 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "userobject.hpp"
+#include <camp/classget.hpp>
+#include <camp/errors.hpp>
+#include <camp/userobject.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace UserObjectTest;
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::UserObject
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_SUITE(USEROBJECT)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getObject)
+{
+    MyClass object(1);
+    camp::UserObject userObject(object);
+
+    BOOST_CHECK_EQUAL(userObject.get<MyClass>(),         object);
+    BOOST_CHECK_EQUAL(&userObject.get<MyClass>(),        &object);
+    BOOST_CHECK_EQUAL(userObject.get<MyClass&>(),        object);
+    BOOST_CHECK_EQUAL(&userObject.get<MyClass&>(),       &object);
+    BOOST_CHECK_EQUAL(userObject.get<const MyClass&>(),  object);
+    BOOST_CHECK_EQUAL(&userObject.get<const MyClass&>(), &object);
+    BOOST_CHECK_EQUAL(userObject.get<MyClass*>(),        &object);
+    BOOST_CHECK_EQUAL(userObject.get<const MyClass*>(),  &object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getAsBase)
+{
+    MyClass object(2);
+    camp::UserObject userObject(object);
+    MyBase& base = object;
+
+    BOOST_CHECK_EQUAL(userObject.get<MyBase>(),         base);
+    BOOST_CHECK_EQUAL(&userObject.get<MyBase>(),        &base);
+    BOOST_CHECK_EQUAL(userObject.get<MyBase&>(),        base);
+    BOOST_CHECK_EQUAL(&userObject.get<MyBase&>(),       &base);
+    BOOST_CHECK_EQUAL(userObject.get<const MyBase&>(),  base);
+    BOOST_CHECK_EQUAL(&userObject.get<const MyBase&>(), &base);
+    BOOST_CHECK_EQUAL(userObject.get<MyBase*>(),        &base);
+    BOOST_CHECK_EQUAL(userObject.get<const MyBase*>(),  &base);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getFromPointer)
+{
+    MyClass object(3);
+    camp::UserObject userObject(&object);
+
+    BOOST_CHECK_EQUAL(userObject.get<MyClass>(),         object);
+    BOOST_CHECK_EQUAL(&userObject.get<MyClass>(),        &object);
+    BOOST_CHECK_EQUAL(userObject.get<MyClass&>(),        object);
+    BOOST_CHECK_EQUAL(&userObject.get<MyClass&>(),       &object);
+    BOOST_CHECK_EQUAL(userObject.get<const MyClass&>(),  object);
+    BOOST_CHECK_EQUAL(&userObject.get<const MyClass&>(), &object);
+    BOOST_CHECK_EQUAL(userObject.get<MyClass*>(),        &object);
+    BOOST_CHECK_EQUAL(userObject.get<const MyClass*>(),  &object);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(copy)
+{
+    MyClass object(4);
+    camp::UserObject userObject = camp::UserObject::copy(object);
+
+    BOOST_CHECK_EQUAL(userObject.get<MyClass>(), object);  // same value
+    BOOST_CHECK_NE(userObject.get<MyClass*>(),   &object); // different address
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(ref)
+{
+    MyClass object(5);
+    camp::UserObject userObject = camp::UserObject::ref(object);
+
+    BOOST_CHECK_EQUAL(userObject.get<MyClass>(),  object);  // same value
+    BOOST_CHECK_EQUAL(userObject.get<MyClass*>(), &object); // same address
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getClass)
+{
+    MyClass object(6);
+    MyBase base(6);
+    MyBase& objectAsBase = object;
+
+    BOOST_CHECK(camp::UserObject(base).getClass() == camp::classByType<MyBase>());
+    BOOST_CHECK(camp::UserObject(object).getClass() == camp::classByType<MyClass>());
+    BOOST_CHECK(camp::UserObject(objectAsBase).getClass() == camp::classByType<MyClass>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    MyClass object(7);
+    camp::UserObject userObject(object);
+
+    BOOST_CHECK_EQUAL(userObject.get("p"), camp::Value(7));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    MyClass object(0);
+    camp::UserObject userObject(object);
+    userObject.set("p", 8);
+
+    BOOST_CHECK_EQUAL(object.x, 8);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(call)
+{
+    MyClass object(9);
+    camp::UserObject userObject(object);
+
+    BOOST_CHECK_EQUAL(userObject.call("f"), camp::Value(9));
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(assignment)
+{
+    MyClass object1(10);
+    camp::UserObject userObject1(object1);
+    camp::UserObject userObject2;
+    userObject2 = userObject1;
+
+    BOOST_CHECK(userObject1.get<MyClass*>() == userObject2.get<MyClass*>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(equality)
+{
+    MyClass object1(11);
+    MyClass object2(11);
+
+    BOOST_CHECK_EQUAL(camp::UserObject(object1)  == camp::UserObject(object1),  true);
+    BOOST_CHECK_EQUAL(camp::UserObject(object1)  == camp::UserObject(&object1), true);
+    BOOST_CHECK_EQUAL(camp::UserObject(&object1) == camp::UserObject(&object1), true);
+    BOOST_CHECK_EQUAL(camp::UserObject(object1)  == camp::UserObject(object2),  false);
+
+    BOOST_CHECK_EQUAL(camp::UserObject(object1) == camp::UserObject::ref(object1),   true);
+    BOOST_CHECK_EQUAL(camp::UserObject(object1) == camp::UserObject::ref(&object1),  true);
+    BOOST_CHECK_EQUAL(camp::UserObject(object1) == camp::UserObject::copy(object1),  false);
+    BOOST_CHECK_EQUAL(camp::UserObject(object1) == camp::UserObject::copy(&object1), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(nonCopyableClass)
+{
+    // This is a compile check
+    MyNonCopyableClass object;
+    camp::UserObject userObject(object);
+    MyNonCopyableClass& ref = userObject.get<MyNonCopyableClass>();
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(abstractClass)
+{
+    // This is a compile check
+    MyConcreteClass object;
+
+    camp::UserObject userObject1(object);
+    userObject1.get<MyAbstractClass>();
+
+    camp::UserObject userObject2(static_cast<MyAbstractClass&>(object));
+    userObject2.get<MyConcreteClass>();
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(composedObjects)
+{
+    const camp::UserProperty& p1 = static_cast<const camp::UserProperty&>(camp::classByType<Composed1>().property("p"));
+    const camp::UserProperty& p2 = static_cast<const camp::UserProperty&>(camp::classByType<Composed2>().property("p"));
+
+    Composed1 composed1;
+    camp::UserObject composed2(composed1, p1);
+    camp::UserObject composed3(composed2, p2);
+
+    composed3.set("x", 1);
+    BOOST_CHECK_EQUAL(composed1.get().get().x, 1);
+    BOOST_CHECK_EQUAL(composed2.get<Composed2>().get().x, 1);
+    BOOST_CHECK_EQUAL(composed3.get<Composed3>().x, 1);
+
+    composed3.set("x", 2);
+    BOOST_CHECK_EQUAL(composed1.get().get().x, 2);
+    BOOST_CHECK_EQUAL(composed2.get<Composed2>().get().x, 2);
+    BOOST_CHECK_EQUAL(composed3.get<Composed3>().x, 2);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/userobject.hpp b/test/userobject.hpp
new file mode 100644
index 0000000..c61921f
--- /dev/null
+++ b/test/userobject.hpp
@@ -0,0 +1,144 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_USEROBJECT_HPP
+#define CAMPTEST_USEROBJECT_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <boost/noncopyable.hpp>
+#include <ostream>
+
+namespace UserObjectTest
+{
+    struct MyBaseWithPadding
+    {
+        virtual ~MyBaseWithPadding() {}
+        char padding[15];
+    };
+
+    struct MyBase
+    {
+        MyBase(int b_) : b(b_) {}
+        virtual ~MyBase() {}
+        int b;
+        CAMP_RTTI();
+    };
+
+    bool operator==(const MyBase& left, const MyBase& right) 
+    {
+        return left.b == right.b;
+    }
+
+    std::ostream& operator<<(std::ostream& stream, const MyBase& b)
+    {
+        return stream << b.b;
+    }
+
+    struct MyClass : MyBaseWithPadding, MyBase
+    {
+        MyClass(int x_) : MyBase(x_ + 1), x(x_) {}
+        int x;
+        int f() {return x;}
+        CAMP_RTTI();
+    };
+
+    bool operator==(const MyClass& left, const MyClass& right) 
+    {
+        return left.x == right.x;
+    }
+
+    std::ostream& operator<<(std::ostream& stream, const MyClass& m)
+    {
+        return stream << m.x;
+    }
+
+    struct MyNonCopyableClass : boost::noncopyable
+    {
+    };
+
+    struct MyAbstractClass
+    {
+        virtual ~MyAbstractClass() {}
+        virtual void f() = 0;
+        CAMP_RTTI();
+    };
+
+    struct MyConcreteClass : MyAbstractClass
+    {
+        virtual void f() {}
+        CAMP_RTTI();
+    };
+
+    struct Composed3
+    {
+        Composed3(int x_ = -1) : x(x_) {}
+        int x;
+    };
+
+    struct Composed2
+    {
+        Composed3 get() const {return composed;}
+        void set(Composed3 c) {composed = c;}
+        Composed3 composed;
+    };
+
+    struct Composed1
+    {
+        Composed2 get() const {return composed;}
+        void set(Composed2 c) {composed = c;}
+        Composed2 composed;
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyBase>("UserObjectTest::MyBase");
+        camp::Class::declare<MyClass>("UserObjectTest::MyClass")
+            .base<MyBase>()
+            .property("p", &MyClass::x)
+            .function("f", &MyClass::f);
+
+        camp::Class::declare<MyNonCopyableClass>("UserObjectTest::MyNonCopyableClass");
+
+        camp::Class::declare<MyAbstractClass>("UserObjectTest::MyAbstractClass");
+        camp::Class::declare<MyConcreteClass>("UserObjectTest::MyConcreteClass")
+            .base<MyAbstractClass>();
+
+        camp::Class::declare<Composed3>("UserObjectTest::Composed3")
+            .property("x", &Composed3::x);
+        camp::Class::declare<Composed2>("UserObjectTest::Composed2")
+            .property("p", &Composed2::get, &Composed2::set);
+        camp::Class::declare<Composed1>("UserObjectTest::Composed1")
+            .property("p", &Composed1::get, &Composed1::set);
+    }
+}
+
+CAMP_AUTO_TYPE(UserObjectTest::MyBase, &UserObjectTest::declare)
+CAMP_AUTO_TYPE(UserObjectTest::MyClass, &UserObjectTest::declare)
+CAMP_AUTO_TYPE_NONCOPYABLE(UserObjectTest::MyNonCopyableClass, &UserObjectTest::declare)
+CAMP_AUTO_TYPE_NONCOPYABLE(UserObjectTest::MyAbstractClass, &UserObjectTest::declare)
+CAMP_AUTO_TYPE_NONCOPYABLE(UserObjectTest::MyConcreteClass, &UserObjectTest::declare)
+CAMP_AUTO_TYPE(UserObjectTest::Composed3, &UserObjectTest::declare)
+CAMP_AUTO_TYPE(UserObjectTest::Composed2, &UserObjectTest::declare)
+CAMP_AUTO_TYPE(UserObjectTest::Composed1, &UserObjectTest::declare)
+
+#endif // CAMPTEST_USEROBJECT_HPP
diff --git a/test/userproperty.cpp b/test/userproperty.cpp
new file mode 100644
index 0000000..1735744
--- /dev/null
+++ b/test/userproperty.cpp
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "userproperty.hpp"
+#include <camp/classget.hpp>
+#include <camp/userproperty.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace UserPropertyTest;
+
+//-----------------------------------------------------------------------------
+struct UserPropertyFixture
+{
+    UserPropertyFixture()
+    {
+        const camp::Class& metaclass = camp::classByType<MyClass>();
+        property = static_cast<const camp::UserProperty*>(&metaclass.property("prop"));
+    }
+
+    const camp::UserProperty* property;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::UserProperty
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(USERPROPERTY, UserPropertyFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(property->type(), camp::userType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(getClass)
+{
+    BOOST_CHECK(property->getClass() == camp::classByType<MyType>());
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(get)
+{
+    BOOST_CHECK_EQUAL(property->get(MyClass(-1)).to<MyType>().x, -1);
+    BOOST_CHECK_EQUAL(property->get(MyClass(20)).to<MyType>().x, 20);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(set)
+{
+    MyClass object1(1);
+    MyClass object2(10);
+    property->set(object1, MyType(2));
+    property->set(object2, MyType(20));
+
+    // reverse order on purpose (to exhibit memory corruptions)
+    BOOST_CHECK_EQUAL(property->get(object2).to<MyType>().x, 20);
+    BOOST_CHECK_EQUAL(property->get(object1).to<MyType>().x, 2);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/userproperty.hpp b/test/userproperty.hpp
new file mode 100644
index 0000000..974fe71
--- /dev/null
+++ b/test/userproperty.hpp
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_USERPROPERTY_HPP
+#define CAMPTEST_USERPROPERTY_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+
+namespace UserPropertyTest
+{
+    struct MyType
+    {
+        MyType(int x_) : x(x_) {}
+        int x;
+    };
+
+    struct MyClass
+    {
+        MyClass(int x) : prop(x) {}
+        MyType prop;
+    };
+
+    void declare()
+    {
+        camp::Class::declare<MyType>("UserPropertyTest::MyType");
+
+        camp::Class::declare<MyClass>("UserPropertyTest::MyClass")
+            .property("prop", &MyClass::prop);
+    }
+}
+
+CAMP_AUTO_TYPE(UserPropertyTest::MyType, &UserPropertyTest::declare)
+CAMP_AUTO_TYPE(UserPropertyTest::MyClass, &UserPropertyTest::declare)
+
+#endif // CAMPTEST_USERPROPERTY_HPP
diff --git a/test/value.cpp b/test/value.cpp
new file mode 100644
index 0000000..187d6fd
--- /dev/null
+++ b/test/value.cpp
@@ -0,0 +1,530 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#include "value.hpp"
+#include <camp/value.hpp>
+#include <camp/errors.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace ValueTest;
+
+//-----------------------------------------------------------------------------
+struct ValueFixture
+{
+    ValueFixture() : object1(1), object2(1)
+    {
+        noValue      = camp::Value::nothing;
+        boolValue    = true;
+        charValue    = static_cast<char>(1);
+        shortValue   = static_cast<short>(1);
+        intValue     = static_cast<int>(1);
+        longValue    = static_cast<long>(1);
+        ucharValue   = static_cast<unsigned char>(1);
+        ushortValue  = static_cast<unsigned short>(1);
+        uintValue    = static_cast<unsigned int>(1);
+        ulongValue   = static_cast<unsigned long>(1);
+        floatValue   = 1.f;
+        doubleValue  = 1.;
+        cstringValue = "1";
+        stringValue  = std::string("1");
+        enumValue    = One;
+        objectValue  = object1;
+    }
+
+    static bool equivalent(const camp::Value& left, const camp::Value& right)
+    {
+        return !(left < right) && !(right < left);
+    }
+
+    camp::Value noValue;
+    camp::Value boolValue;
+    camp::Value charValue;
+    camp::Value shortValue;
+    camp::Value intValue;
+    camp::Value longValue;
+    camp::Value ucharValue;
+    camp::Value ushortValue;
+    camp::Value uintValue;
+    camp::Value ulongValue;
+    camp::Value floatValue;
+    camp::Value doubleValue;
+    camp::Value cstringValue;
+    camp::Value stringValue;
+    camp::Value enumValue;
+    camp::Value objectValue;
+    MyClass object1;
+    MyClass object2;
+};
+
+//-----------------------------------------------------------------------------
+//                         Tests for camp::Value
+//-----------------------------------------------------------------------------
+BOOST_FIXTURE_TEST_SUITE(VALUE, ValueFixture)
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(type)
+{
+    BOOST_CHECK_EQUAL(noValue.type(),      camp::noType);
+    BOOST_CHECK_EQUAL(boolValue.type(),    camp::boolType);
+    BOOST_CHECK_EQUAL(charValue.type(),    camp::intType);
+    BOOST_CHECK_EQUAL(shortValue.type(),   camp::intType);
+    BOOST_CHECK_EQUAL(intValue.type(),     camp::intType);
+    BOOST_CHECK_EQUAL(longValue.type(),    camp::intType);
+    BOOST_CHECK_EQUAL(ucharValue.type(),   camp::intType);
+    BOOST_CHECK_EQUAL(ushortValue.type(),  camp::intType);
+    BOOST_CHECK_EQUAL(uintValue.type(),    camp::intType);
+    BOOST_CHECK_EQUAL(ulongValue.type(),   camp::intType);
+    BOOST_CHECK_EQUAL(floatValue.type(),   camp::realType);
+    BOOST_CHECK_EQUAL(doubleValue.type(),  camp::realType);
+    BOOST_CHECK_EQUAL(cstringValue.type(), camp::stringType);
+    BOOST_CHECK_EQUAL(stringValue.type(),  camp::stringType);
+    BOOST_CHECK_EQUAL(enumValue.type(),    camp::enumType);
+    BOOST_CHECK_EQUAL(objectValue.type(),  camp::userType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(boolConversions)
+{
+    BOOST_CHECK_EQUAL(boolValue.to<bool>(),           true);
+    BOOST_CHECK_EQUAL(boolValue.to<char>(),           1);
+    BOOST_CHECK_EQUAL(boolValue.to<short>(),          1);
+    BOOST_CHECK_EQUAL(boolValue.to<int>(),            1);
+    BOOST_CHECK_EQUAL(boolValue.to<long>(),           1);
+    BOOST_CHECK_EQUAL(boolValue.to<unsigned char>(),  1);
+    BOOST_CHECK_EQUAL(boolValue.to<unsigned short>(), 1);
+    BOOST_CHECK_EQUAL(boolValue.to<unsigned int>(),   1);
+    BOOST_CHECK_EQUAL(boolValue.to<unsigned long>(),  1);
+    BOOST_CHECK_CLOSE(boolValue.to<float>(),          1.f, 1E-5f);
+    BOOST_CHECK_CLOSE(boolValue.to<double>(),         1., 1E-5);
+    BOOST_CHECK_EQUAL(boolValue.to<std::string>(),    "1");
+    BOOST_CHECK_EQUAL(boolValue.to<MyEnum>(),         One);
+    BOOST_CHECK_THROW(boolValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<char>(),           true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<short>(),          true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<int>(),            true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<long>(),           true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<unsigned char>(),  true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<unsigned short>(), true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<unsigned int>(),   true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<unsigned long>(),  true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<float>(),          true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<double>(),         true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<MyEnum>(),         true);
+    BOOST_CHECK_EQUAL(boolValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(intConversions)
+{
+    BOOST_CHECK_EQUAL(intValue.to<bool>(),           true);
+    BOOST_CHECK_EQUAL(intValue.to<char>(),           1);
+    BOOST_CHECK_EQUAL(intValue.to<short>(),          1);
+    BOOST_CHECK_EQUAL(intValue.to<int>(),            1);
+    BOOST_CHECK_EQUAL(intValue.to<long>(),           1);
+    BOOST_CHECK_EQUAL(intValue.to<unsigned char>(),  1);
+    BOOST_CHECK_EQUAL(intValue.to<unsigned short>(), 1);
+    BOOST_CHECK_EQUAL(intValue.to<unsigned int>(),   1);
+    BOOST_CHECK_EQUAL(intValue.to<unsigned long>(),  1);
+    BOOST_CHECK_CLOSE(intValue.to<float>(),          1.f, 1E-5f);
+    BOOST_CHECK_CLOSE(intValue.to<double>(),         1., 1E-5);
+    BOOST_CHECK_EQUAL(intValue.to<std::string>(),    "1");
+    BOOST_CHECK_EQUAL(intValue.to<MyEnum>(),         One);
+    BOOST_CHECK_THROW(intValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(intValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<char>(),           true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<short>(),          true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<int>(),            true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<long>(),           true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<unsigned char>(),  true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<unsigned short>(), true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<unsigned int>(),   true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<unsigned long>(),  true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<float>(),          true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<double>(),         true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<MyEnum>(),         true);
+    BOOST_CHECK_EQUAL(intValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(doubleConversions)
+{
+    BOOST_CHECK_EQUAL(doubleValue.to<bool>(),           true);
+    BOOST_CHECK_EQUAL(doubleValue.to<char>(),           1);
+    BOOST_CHECK_EQUAL(doubleValue.to<short>(),          1);
+    BOOST_CHECK_EQUAL(doubleValue.to<int>(),            1);
+    BOOST_CHECK_EQUAL(doubleValue.to<long>(),           1);
+    BOOST_CHECK_EQUAL(doubleValue.to<unsigned char>(),  1);
+    BOOST_CHECK_EQUAL(doubleValue.to<unsigned short>(), 1);
+    BOOST_CHECK_EQUAL(doubleValue.to<unsigned int>(),   1);
+    BOOST_CHECK_EQUAL(doubleValue.to<unsigned long>(),  1);
+    BOOST_CHECK_CLOSE(doubleValue.to<float>(),          1.f, 1E-5f);
+    BOOST_CHECK_CLOSE(doubleValue.to<double>(),         1., 1E-5);
+    BOOST_CHECK_EQUAL(doubleValue.to<std::string>(),    "1");
+    BOOST_CHECK_EQUAL(doubleValue.to<MyEnum>(),         One);
+    BOOST_CHECK_THROW(doubleValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<char>(),           true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<short>(),          true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<int>(),            true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<long>(),           true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<unsigned char>(),  true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<unsigned short>(), true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<unsigned int>(),   true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<unsigned long>(),  true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<float>(),          true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<double>(),         true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<MyEnum>(),         true);
+    BOOST_CHECK_EQUAL(doubleValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(stringConversionsOk)
+{
+    BOOST_CHECK_EQUAL(stringValue.to<bool>(),           true);
+    BOOST_CHECK_EQUAL(stringValue.to<char>(),           '1');
+    BOOST_CHECK_EQUAL(stringValue.to<short>(),          1);
+    BOOST_CHECK_EQUAL(stringValue.to<int>(),            1);
+    BOOST_CHECK_EQUAL(stringValue.to<long>(),           1);
+    BOOST_CHECK_EQUAL(stringValue.to<unsigned char>(),  '1');
+    BOOST_CHECK_EQUAL(stringValue.to<unsigned short>(), 1);
+    BOOST_CHECK_EQUAL(stringValue.to<unsigned int>(),   1);
+    BOOST_CHECK_EQUAL(stringValue.to<unsigned long>(),  1);
+    BOOST_CHECK_CLOSE(stringValue.to<float>(),          1.f, 1E-5f);
+    BOOST_CHECK_CLOSE(stringValue.to<double>(),         1., 1E-5);
+    BOOST_CHECK_EQUAL(stringValue.to<std::string>(),    "1");
+    BOOST_CHECK_EQUAL(stringValue.to<MyEnum>(),         One);
+    BOOST_CHECK_THROW(stringValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<char>(),           true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<short>(),          true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<int>(),            true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<long>(),           true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<unsigned char>(),  true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<unsigned short>(), true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<unsigned int>(),   true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<unsigned long>(),  true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<float>(),          true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<double>(),         true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<MyEnum>(),         true);
+    BOOST_CHECK_EQUAL(stringValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(stringConversionsEnumOk)
+{
+    BOOST_CHECK_EQUAL(camp::Value("One").to<MyEnum>(), One);
+    BOOST_CHECK_EQUAL(camp::Value("Two").to<MyEnum>(), Two);
+    BOOST_CHECK_EQUAL(camp::Value("1").to<MyEnum>(),   One);
+    BOOST_CHECK_EQUAL(camp::Value("2").to<MyEnum>(),   Two);
+
+    BOOST_CHECK_EQUAL(camp::Value("One").isCompatible<MyEnum>(), true);
+    BOOST_CHECK_EQUAL(camp::Value("Two").isCompatible<MyEnum>(), true);
+    BOOST_CHECK_EQUAL(camp::Value("1").isCompatible<MyEnum>(),   true);
+    BOOST_CHECK_EQUAL(camp::Value("2").isCompatible<MyEnum>(),   true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(stringConversionsNotOk)
+{
+    camp::Value badStringValue = "not a number";
+
+    BOOST_CHECK_THROW(badStringValue.to<bool>(),           camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<char>(),           camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<short>(),          camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<int>(),            camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<long>(),           camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<unsigned char>(),  camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<unsigned short>(), camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<unsigned int>(),   camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<unsigned long>(),  camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<float>(),          camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<double>(),         camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<MyEnum>(),         camp::BadType);
+    BOOST_CHECK_THROW(badStringValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<bool>(),           false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<char>(),           false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<short>(),          false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<int>(),            false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<long>(),           false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<unsigned char>(),  false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<unsigned short>(), false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<unsigned int>(),   false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<unsigned long>(),  false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<float>(),          false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<double>(),         false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<MyEnum>(),         false);
+    BOOST_CHECK_EQUAL(badStringValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(enumConversions)
+{
+    BOOST_CHECK_EQUAL(enumValue.to<bool>(),           true);
+    BOOST_CHECK_EQUAL(enumValue.to<char>(),           1);
+    BOOST_CHECK_EQUAL(enumValue.to<short>(),          1);
+    BOOST_CHECK_EQUAL(enumValue.to<int>(),            1);
+    BOOST_CHECK_EQUAL(enumValue.to<long>(),           1);
+    BOOST_CHECK_EQUAL(enumValue.to<unsigned char>(),  1);
+    BOOST_CHECK_EQUAL(enumValue.to<unsigned short>(), 1);
+    BOOST_CHECK_EQUAL(enumValue.to<unsigned int>(),   1);
+    BOOST_CHECK_EQUAL(enumValue.to<unsigned long>(),  1);
+    BOOST_CHECK_CLOSE(enumValue.to<float>(),          1.f, 1E-5f);
+    BOOST_CHECK_CLOSE(enumValue.to<double>(),         1., 1E-5);
+    BOOST_CHECK_EQUAL(enumValue.to<std::string>(),    "One");
+    BOOST_CHECK_EQUAL(enumValue.to<MyEnum>(),         One);
+    BOOST_CHECK_THROW(enumValue.to<MyClass>(),        camp::BadType);
+
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<char>(),           true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<short>(),          true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<int>(),            true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<long>(),           true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<unsigned char>(),  true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<unsigned short>(), true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<unsigned int>(),   true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<unsigned long>(),  true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<float>(),          true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<double>(),         true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<std::string>(),    true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<MyEnum>(),         true);
+    BOOST_CHECK_EQUAL(enumValue.isCompatible<MyClass>(),        false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(objectConversions)
+{
+    BOOST_CHECK_EQUAL(objectValue.to<bool>(),             true);
+    BOOST_CHECK_THROW(objectValue.to<char>(),             camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<short>(),            camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<int>(),              camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<long>(),             camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<unsigned char>(),    camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<unsigned short>(),   camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<unsigned int>(),     camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<unsigned long>(),    camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<float>(),            camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<double>(),           camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<std::string>(),      camp::BadType);
+    BOOST_CHECK_THROW(objectValue.to<MyEnum>(),           camp::BadType);
+    BOOST_CHECK_EQUAL(objectValue.to<MyClass>(),          object1);
+    BOOST_CHECK_EQUAL(objectValue.to<camp::UserObject>(), camp::UserObject(object1));
+
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<bool>(),           true);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<char>(),           false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<short>(),          false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<int>(),            false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<long>(),           false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<unsigned char>(),  false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<unsigned short>(), false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<unsigned int>(),   false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<unsigned long>(),  false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<float>(),          false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<double>(),         false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<std::string>(),    false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<MyEnum>(),         false);
+    BOOST_CHECK_EQUAL(objectValue.isCompatible<MyClass>(),        true);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(visitor)
+{
+    Visitor visitor;
+
+    BOOST_CHECK_EQUAL(noValue.visit(visitor),      camp::noType);
+    BOOST_CHECK_EQUAL(boolValue.visit(visitor),    camp::boolType);
+    BOOST_CHECK_EQUAL(charValue.visit(visitor),    camp::intType);
+    BOOST_CHECK_EQUAL(shortValue.visit(visitor),   camp::intType);
+    BOOST_CHECK_EQUAL(intValue.visit(visitor),     camp::intType);
+    BOOST_CHECK_EQUAL(longValue.visit(visitor),    camp::intType);
+    BOOST_CHECK_EQUAL(ucharValue.visit(visitor),   camp::intType);
+    BOOST_CHECK_EQUAL(ushortValue.visit(visitor),  camp::intType);
+    BOOST_CHECK_EQUAL(uintValue.visit(visitor),    camp::intType);
+    BOOST_CHECK_EQUAL(ulongValue.visit(visitor),   camp::intType);
+    BOOST_CHECK_EQUAL(floatValue.visit(visitor),   camp::realType);
+    BOOST_CHECK_EQUAL(doubleValue.visit(visitor),  camp::realType);
+    BOOST_CHECK_EQUAL(cstringValue.visit(visitor), camp::stringType);
+    BOOST_CHECK_EQUAL(stringValue.visit(visitor),  camp::stringType);
+    BOOST_CHECK_EQUAL(enumValue.visit(visitor),    camp::enumType);
+    BOOST_CHECK_EQUAL(objectValue.visit(visitor),  camp::userType);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(equal)
+{
+    BOOST_CHECK_EQUAL(noValue == noValue,     true);
+    BOOST_CHECK_EQUAL(noValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(noValue == intValue,    false);
+    BOOST_CHECK_EQUAL(noValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(noValue == stringValue, false);
+    BOOST_CHECK_EQUAL(noValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(noValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(boolValue == noValue,     false);
+    BOOST_CHECK_EQUAL(boolValue == boolValue,   true);
+    BOOST_CHECK_EQUAL(boolValue == intValue,    false);
+    BOOST_CHECK_EQUAL(boolValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(boolValue == stringValue, false);
+    BOOST_CHECK_EQUAL(boolValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(boolValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(intValue == noValue,     false);
+    BOOST_CHECK_EQUAL(intValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(intValue == intValue,    true);
+    BOOST_CHECK_EQUAL(intValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(intValue == stringValue, false);
+    BOOST_CHECK_EQUAL(intValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(intValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(doubleValue == noValue,     false);
+    BOOST_CHECK_EQUAL(doubleValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(doubleValue == intValue,    false);
+    BOOST_CHECK_EQUAL(doubleValue == doubleValue, true);
+    BOOST_CHECK_EQUAL(doubleValue == stringValue, false);
+    BOOST_CHECK_EQUAL(doubleValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(doubleValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(stringValue == noValue,     false);
+    BOOST_CHECK_EQUAL(stringValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(stringValue == intValue,    false);
+    BOOST_CHECK_EQUAL(stringValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(stringValue == stringValue, true);
+    BOOST_CHECK_EQUAL(stringValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(stringValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(enumValue == noValue,     false);
+    BOOST_CHECK_EQUAL(enumValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(enumValue == intValue,    false);
+    BOOST_CHECK_EQUAL(enumValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(enumValue == stringValue, false);
+    BOOST_CHECK_EQUAL(enumValue == enumValue,   true);
+    BOOST_CHECK_EQUAL(enumValue == objectValue, false);
+
+    BOOST_CHECK_EQUAL(objectValue == noValue,     false);
+    BOOST_CHECK_EQUAL(objectValue == boolValue,   false);
+    BOOST_CHECK_EQUAL(objectValue == intValue,    false);
+    BOOST_CHECK_EQUAL(objectValue == doubleValue, false);
+    BOOST_CHECK_EQUAL(objectValue == stringValue, false);
+    BOOST_CHECK_EQUAL(objectValue == enumValue,   false);
+    BOOST_CHECK_EQUAL(objectValue == objectValue, true);
+
+    BOOST_CHECK_EQUAL(camp::Value(true)    == camp::Value(true),    true);
+    BOOST_CHECK_EQUAL(camp::Value(1)       == camp::Value(1),       true);
+    BOOST_CHECK_EQUAL(camp::Value(1.)      == camp::Value(1.),      true);
+    BOOST_CHECK_EQUAL(camp::Value("1")     == camp::Value("1"),     true);
+    BOOST_CHECK_EQUAL(camp::Value(One)     == camp::Value(One),     true);
+    BOOST_CHECK_EQUAL(camp::Value(object1) == camp::Value(object1), true);
+
+    BOOST_CHECK_EQUAL(camp::Value(true)    == camp::Value(false),   false);
+    BOOST_CHECK_EQUAL(camp::Value(1)       == camp::Value(2),       false);
+    BOOST_CHECK_EQUAL(camp::Value(1.)      == camp::Value(2.),      false);
+    BOOST_CHECK_EQUAL(camp::Value("1")     == camp::Value("2"),     false);
+    BOOST_CHECK_EQUAL(camp::Value(One)     == camp::Value(Two),     false);
+    BOOST_CHECK_EQUAL(camp::Value(object1) == camp::Value(object2), false);
+}
+
+//-----------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(lessThan)
+{
+    BOOST_CHECK_EQUAL(equivalent(noValue, noValue),     true);
+    BOOST_CHECK_EQUAL(equivalent(noValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(noValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(noValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(noValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(noValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(noValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(boolValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, boolValue),   true);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(boolValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(intValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(intValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(intValue, intValue),    true);
+    BOOST_CHECK_EQUAL(equivalent(intValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(intValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(intValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(intValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, doubleValue), true);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(doubleValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(stringValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, stringValue), true);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(stringValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(enumValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, enumValue),   true);
+    BOOST_CHECK_EQUAL(equivalent(enumValue, objectValue), false);
+
+    BOOST_CHECK_EQUAL(equivalent(objectValue, noValue),     false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, boolValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, intValue),    false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, doubleValue), false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, stringValue), false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, enumValue),   false);
+    BOOST_CHECK_EQUAL(equivalent(objectValue, objectValue), true);
+
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(),        camp::Value()),        true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(true),    camp::Value(true)),    true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(1),       camp::Value(1)),       true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(1.),      camp::Value(1.)),      true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value("1"),     camp::Value("1")),     true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(One),     camp::Value(One)),     true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(object1), camp::Value(object1)), true);
+    BOOST_CHECK_EQUAL(equivalent(camp::Value(object1), camp::Value(object2)), false);
+
+    BOOST_CHECK_EQUAL(camp::Value(false) < camp::Value(true), true);
+    BOOST_CHECK_EQUAL(camp::Value(1)     < camp::Value(2),    true);
+    BOOST_CHECK_EQUAL(camp::Value(1.)    < camp::Value(2.),   true);
+    BOOST_CHECK_EQUAL(camp::Value("1")   < camp::Value("2"),  true);
+    BOOST_CHECK_EQUAL(camp::Value(One)   < camp::Value(Two),  true);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/value.hpp b/test/value.hpp
new file mode 100644
index 0000000..bd6cdfe
--- /dev/null
+++ b/test/value.hpp
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+#ifndef CAMPTEST_VALUE_HPP
+#define CAMPTEST_VALUE_HPP
+
+#include <camp/camptype.hpp>
+#include <camp/class.hpp>
+#include <camp/enum.hpp>
+#include <camp/type.hpp>
+#include <camp/valuevisitor.hpp>
+#include <camp/enumobject.hpp>
+#include <camp/userobject.hpp>
+
+namespace ValueTest
+{
+    struct MyClass
+    {
+        MyClass(int x_) : x(x_) {}
+        int x;
+    };
+
+    bool operator==(const MyClass& left, const MyClass& right)
+    {
+        return left.x == right.x;
+    }
+
+    bool operator<(const MyClass& left, const MyClass& right)
+    {
+        return left.x < right.x;
+    }
+
+    std::ostream& operator<<(std::ostream& stream, const MyClass& object)
+    {
+        return stream << object.x;
+    }
+
+    enum MyEnum
+    {
+        One = 1,
+        Two = 2
+    };
+
+    struct Visitor : public camp::ValueVisitor<camp::Type>
+    {
+         camp::Type operator()(camp::NoType)
+         {
+             return camp::noType;
+         }
+
+         camp::Type operator()(bool)
+         {
+             return camp::boolType;
+         }
+         
+         camp::Type operator()(long)
+         {
+             return camp::intType;
+         }
+         
+         camp::Type operator()(double)
+         {
+             return camp::realType;
+         }
+         
+         camp::Type operator()(const std::string&)
+         {
+             return camp::stringType;
+         }
+         
+         camp::Type operator()(const camp::EnumObject&)
+         {
+             return camp::enumType;
+         }
+         
+         camp::Type operator()(const camp::UserObject&)
+         {
+             return camp::userType;
+         }
+    };
+
+    void declare()
+    {
+        camp::Enum::declare<MyEnum>("ValueTest::MyEnum")
+            .value("One", One)
+            .value("Two", Two);
+        camp::Class::declare<MyClass>("ValueTest::MyClass");
+    }
+}
+
+CAMP_AUTO_TYPE(ValueTest::MyClass, &ValueTest::declare)
+CAMP_AUTO_TYPE(ValueTest::MyEnum, &ValueTest::declare)
+
+#endif // CAMPTEST_VALUE_HPP
diff --git a/version.in b/version.in
new file mode 100644
index 0000000..e68d850
--- /dev/null
+++ b/version.in
@@ -0,0 +1,34 @@
+/****************************************************************************
+**
+** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+**
+** This file is part of the CAMP library.
+**
+** CAMP is free software: you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+** 
+** CAMP 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 Lesser General Public License for more details.
+** 
+** You should have received a copy of the GNU Lesser General Public License
+** along with CAMP.  If not, see <http://www.gnu.org/licenses/>.
+**
+****************************************************************************/
+
+
+#ifndef CAMP_VERSION_HPP
+#define CAMP_VERSION_HPP
+
+// Define the version of CAMP.
+// If the version is x.y.z, then CAMP_VERSION is the integer x * 1000000 + y * 1000 + z.
+// CAMP_VERSION_STR is the string representation of the version.
+#define CAMP_VERSION     ((@VERSION_MAJOR@) * 1000000 + (@VERSION_MINOR@) * 1000 + (@VERSION_PATCH@))
+#define CAMP_VERSION_STR "@VERSION_STR@"
+
+#endif // CAMP_VERSION_HPP
+

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/camp.git



More information about the debian-med-commit mailing list