Adding in the spirit Boost stuff

Change-Id: I4f127ce61667243b64081b0aa309028d5077045f
author: Kevin Smith <git@kismith.co.uk> 2013-01-12 18:41:34 (GMT)
committer: Swift Review <review@swift.im> 2013-01-13 10:36:26 (GMT)
commit: f3bc816af1b0d61452de973963e453bf3b3f95a2 (patch)
tree: e895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/spirit/home
parent: 188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff)
download: swift-contrib-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip
swift-contrib-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2
189 files changed, 36937 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex.hpp b/3rdParty/Boost/src/boost/spirit/home/lex.hpp
new file mode 100644
index 0000000..5d95f5b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex.hpp
@@ -0,0 +1,18 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXER_MARCH_22_2007_0929PM)
+#define BOOST_SPIRIT_LEXER_MARCH_22_2007_0929PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/lexer.hpp>
+#include <boost/spirit/home/lex/qi.hpp>
+#include <boost/spirit/home/lex/tokenize_and_parse.hpp>
+#include <boost/spirit/home/lex/tokenize_and_parse_attr.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp
new file mode 100644
index 0000000..edfee0b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp
@@ -0,0 +1,362 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+//  Copyright (c)      2010 Bryce Lelbach
+//  Copyright (c)      2011 Thomas Heller
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_ARGUMENT_JUNE_07_2009_1106AM)
+#define BOOST_SPIRIT_LEX_ARGUMENT_JUNE_07_2009_1106AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+#include <boost/spirit/home/lex/argument_phoenix.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The state_getter is a Phoenix actor used to access the name of the 
+    //  current lexer state by calling get_state_name() on the context (which 
+    //  is the 5th parameter to any lexer semantic actions).
+    //
+    //  This Phoenix actor is invoked whenever the placeholder '_state' is used
+    //  as a rvalue inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ std::cout << _state ];
+    //
+    //  The example shows how to print the lexer state after matching a token
+    //  'identifier'.
+    struct state_getter
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef
+                typename remove_reference<
+                   typename remove_const<
+                        typename mpl::at_c<typename Env::args_type, 4>::type
+                    >::type
+                >::type
+            context_type;
+
+            typedef typename context_type::state_name_type type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return fusion::at_c<4>(env.args()).get_state_name();
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The state_setter is a Phoenix actor used to change the name of the 
+    //  current lexer state by calling set_state_name() on the context (which 
+    //  is the 5th parameter to any lexer semantic actions).
+    //
+    //  This Phoenix actor is invoked whenever the placeholder '_state' is used
+    //  as a lvalue inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ _state = "SOME_LEXER_STATE" ];
+    //
+    //  The example shows how to change the lexer state after matching a token
+    //  'identifier'.
+    template <typename Actor>
+    struct state_setter
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef void type;
+        };
+
+        template <typename Env>
+        void eval(Env const& env) const
+        {
+            typedef
+                typename remove_reference<
+                   typename remove_const<
+                        typename mpl::at_c<typename Env::args_type, 4>::type
+                    >::type
+                >::type
+            context_type;
+
+            typedef typename context_type::state_name_type string;
+
+            fusion::at_c<4>(env.args()).set_state_name(
+                traits::get_c_string(actor_.eval(env)));
+        }
+
+        state_setter(Actor const& actor)
+          : actor_(actor) {}
+
+        // see explanation for this constructor at the end of this file
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+        state_setter(phoenix::actor<state_getter>, Actor const& actor)
+          : actor_(actor) {}
+#endif
+
+        Actor actor_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The value_getter is used to create the _val placeholder, which is a 
+    //  Phoenix actor used to access the value of the current token.
+    //
+    //  This Phoenix actor is invoked whenever the placeholder '_val' is used
+    //  as a rvalue inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ std::cout << _val ];
+    //
+    //  The example shows how to use _val to print the identifier name (which
+    //  is the initial token value).
+    struct value_getter
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef
+                typename remove_reference<
+                   typename remove_const<
+                        typename mpl::at_c<typename Env::args_type, 4>::type
+                    >::type
+                >::type
+            context_type;
+
+            typedef typename context_type::get_value_type type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type 
+        eval(Env const& env) const
+        {
+            return fusion::at_c<4>(env.args()).get_value();
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The value_setter is a Phoenix actor used to change the name of the 
+    //  current lexer state by calling set_state_name() on the context (which 
+    //  is the 5th parameter to any lexer semantic actions).
+    //
+    //  This Phoenix actor is invoked whenever the placeholder '_val' is used
+    //  as a lvalue inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ _val = "identifier" ];
+    //
+    //  The example shows how to change the token value after matching a token
+    //  'identifier'.
+    template <typename Actor>
+    struct value_setter
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef void type;
+        };
+
+        template <typename Env>
+        void eval(Env const& env) const
+        {
+            fusion::at_c<4>(env.args()).set_value(actor_.eval(env));
+        }
+
+        value_setter(Actor const& actor)
+          : actor_(actor) {}
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+        // see explanation for this constructor at the end of this file
+        value_setter(phoenix::actor<value_getter>, Actor const& actor)
+          : actor_(actor) {}
+#endif
+
+        Actor actor_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The eoi_getter is used to create the _eoi placeholder, which is a 
+    //  Phoenix actor used to access the end of input iterator pointing to the 
+    //  end of the underlying input sequence.
+    //
+    //  This actor is invoked whenever the placeholder '_eoi' is used in a
+    //  lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier 
+    //          [ std::cout << construct_<std::string>(_end, _eoi) ];
+    //
+    //  The example shows how to use _eoi to print all remaining input after
+    //  matching a token 'identifier'.
+    struct eoi_getter
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef
+                typename remove_reference<
+                   typename remove_const<
+                        typename mpl::at_c<typename Env::args_type, 4>::type
+                    >::type
+                >::type
+            context_type;
+
+            typedef typename context_type::base_iterator_type const& type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type 
+        eval(Env const& env) const
+        {
+            return fusion::at_c<4>(env.args()).get_eoi();
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // '_start' and '_end' may be used to access the start and the end of 
+    // the matched sequence of the current token
+    typedef phoenix::arg_names::_1_type _start_type;
+    typedef phoenix::arg_names::_2_type _end_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    _start_type const _start = _start_type();
+    _end_type const _end = _end_type();
+#endif
+
+    // We are reusing the placeholder '_pass' to access and change the pass
+    // status of the current match (see support/argument.hpp for its 
+    // definition).
+    // typedef phoenix::arg_names::_3_type _pass_type;
+    using boost::spirit::_pass_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using boost::spirit::_pass;
+#endif
+
+    // '_tokenid' may be used to access and change the tokenid of the current 
+    // token
+    typedef phoenix::arg_names::_4_type _tokenid_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    _tokenid_type const _tokenid = _tokenid_type();
+#endif
+
+    typedef phoenix::actor<value_context> _val_type;
+    typedef phoenix::actor<state_context> _state_type;
+    typedef phoenix::actor<eoi_getter> _eoi_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    // '_val' may be used to access and change the token value of the current
+    // token
+    _val_type const _val = _val_type();
+    // _state may be used to access and change the name of the current lexer 
+    // state
+    _state_type const _state = _state_type();
+    // '_eoi' may be used to access the end of input iterator of the input 
+    // stream used by the lexer to match tokens from
+    _eoi_type const _eoi = _eoi_type();
+#endif
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+namespace boost { namespace phoenix
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The specialization of as_actor_base<> below is needed to convert all
+    //  occurrences of _state in places where it's used as a rvalue into the 
+    //  proper Phoenix actor (spirit::state_getter) accessing the lexer state.
+    template<>
+    struct as_actor_base<actor<spirit::lex::state_context> >
+    {
+        typedef spirit::lex::state_getter type;
+
+        static spirit::lex::state_getter
+        convert(actor<spirit::lex::state_context>)
+        {
+            return spirit::lex::state_getter();
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The specialization of as_composite<> below is needed to convert all
+    //  assignments to _state (places where it's used as a lvalue) into the
+    //  proper Phoenix actor (spirit::state_setter) allowing to change the
+    //  lexer state.
+    template <typename RHS>
+    struct as_composite<assign_eval, actor<spirit::lex::state_context>, RHS>
+    {
+        // For an assignment to _state (a spirit::state_context actor), this
+        // specialization makes Phoenix's compose() function construct a
+        // spirit::state_setter actor from 1. the LHS, a spirit::state_getter
+        // actor (due to the specialization of as_actor_base<> above),
+        // and 2. the RHS actor.
+        // This is why spirit::state_setter needs a constructor which takes
+        // a dummy spirit::state_getter as its first argument in addition
+        // to its real, second argument (the RHS actor).
+        typedef spirit::lex::state_setter<typename as_actor<RHS>::type> type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The specialization of as_actor_base<> below is needed to convert all
+    //  occurrences of _val in places where it's used as a rvalue into the 
+    //  proper Phoenix actor (spirit::value_getter) accessing the token value.
+    template<>
+    struct as_actor_base<actor<spirit::lex::value_context> >
+    {
+        typedef spirit::lex::value_getter type;
+
+        static spirit::lex::value_getter
+        convert(actor<spirit::lex::value_context>)
+        {
+            return spirit::lex::value_getter();
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The specialization of as_composite<> below is needed to convert all
+    //  assignments to _val (places where it's used as a lvalue) into the
+    //  proper Phoenix actor (spirit::value_setter) allowing to change the
+    //  token value.
+    template <typename RHS>
+    struct as_composite<assign_eval, actor<spirit::lex::value_context>, RHS>
+    {
+        // For an assignment to _val (a spirit::value_context actor), this
+        // specialization makes Phoenix's compose() function construct a
+        // spirit::value_setter actor from 1. the LHS, a spirit::value_getter
+        // actor (due to the specialization of as_actor_base<> above),
+        // and 2. the RHS actor.
+        // This is why spirit::value_setter needs a constructor which takes
+        // a dummy spirit::value_getter as its first argument in addition
+        // to its real, second argument (the RHS actor).
+        typedef spirit::lex::value_setter<typename as_actor<RHS>::type> type;
+    };
+}}
+#endif
+
+#undef SPIRIT_DECLARE_ARG
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp
new file mode 100644
index 0000000..da24503
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp
@@ -0,0 +1,251 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c)      2011 Thomas Heller
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_ARGUMENT_PHEONIX_MARCH_25_2011_1841PM)
+#define BOOST_SPIRIT_LEX_ARGUMENT_PHEONIX_MARCH_25_2011_1841PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The value_context is used as a noop Phoenix actor to create the 
+    //  placeholder '_val' (see below). It is a noop actor because it is used
+    //  as a placeholder only, while it is being converted either to a 
+    //  value_getter (if used as a rvalue) or to a value_setter (if used as a 
+    //  lvalue). The conversion is achieved by specializing and overloading a 
+    //  couple of the Phoenix templates from the Phoenix expression composition
+    //  engine (see the end of this file).
+    struct value_context 
+    {
+        typedef mpl::true_ no_nullary;
+
+        typedef unused_type result_type;
+
+        template <typename Env>
+        struct result
+        {
+            typedef unused_type type;
+        };
+
+        template <typename Env>
+        unused_type
+        eval(Env const& env) const
+        {
+            return unused;
+        }
+    };
+
+    // forward declarations
+    struct value_getter;
+    template <typename> struct value_setter;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The state_context is used as a noop Phoenix actor to create the 
+    //  placeholder '_state' (see below). It is a noop actor because it is used
+    //  as a placeholder only, while it is being converted either to a 
+    //  state_getter (if used as a rvalue) or to a state_setter (if used as a 
+    //  lvalue). The conversion is achieved by specializing and overloading a 
+    //  couple of the Phoenix templates from the Phoenix expression composition
+    //  engine (see the end of this file).
+    struct state_context 
+    {
+        typedef mpl::true_ no_nullary;
+
+        typedef unused_type result_type;
+
+        template <typename Env>
+        struct result
+        {
+            typedef unused_type type;
+        };
+
+        template <typename Env>
+        unused_type
+        eval(Env const& env) const
+        {
+            return unused;
+        }
+    };
+
+    // forward declarations
+    struct state_getter;
+    template <typename> struct state_setter;
+    struct eoi_getter;
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef BOOST_SPIRIT_USE_PHOENIX_V3
+
+BOOST_PHOENIX_DEFINE_EXPRESSION(
+    (boost)(spirit)(lex)(value_setter)
+  , (boost::phoenix::meta_grammar)
+)
+
+BOOST_PHOENIX_DEFINE_EXPRESSION(
+    (boost)(spirit)(lex)(state_setter)
+  , (boost::phoenix::meta_grammar)
+)
+
+namespace boost { namespace phoenix
+{
+    namespace result_of
+    {
+        template <>
+        struct is_nullary<custom_terminal<boost::spirit::lex::value_context> >
+          : mpl::false_
+        {};
+    }
+    
+    template <typename Dummy>
+    struct is_custom_terminal<boost::spirit::lex::value_context, Dummy>: mpl::true_ {};
+    
+    template <typename Dummy>
+    struct custom_terminal<boost::spirit::lex::value_context, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<boost::spirit::lex::value_getter()>
+              , proto::call<functional::env(proto::_state)>
+            )
+        >
+    {};
+
+    template <typename Dummy>
+    struct is_nullary::when<spirit::lex::rule::value_setter, Dummy>
+      : proto::make<mpl::false_()>
+    {};
+
+    template <typename Dummy>
+    struct default_actions::when<spirit::lex::rule::value_setter, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<
+                    spirit::lex::value_setter<proto::_child0>(
+                        proto::_child0
+                    )
+                >
+              , _env
+            )
+        >
+    {};
+
+    template <>
+    struct actor<spirit::lex::value_context>
+      : boost::phoenix::actor<proto::terminal<spirit::lex::value_context>::type>
+    {
+        typedef boost::phoenix::actor<
+            proto::terminal<spirit::lex::value_context>::type
+        > base_type;
+
+        actor(base_type const & base = base_type())
+            : base_type(base)
+        {}
+
+        template <typename Expr>
+        typename spirit::lex::expression::value_setter<
+            typename phoenix::as_actor<Expr>::type>::type const
+        operator=(Expr const & expr) const
+        {
+            return
+                spirit::lex::expression::value_setter<
+                    typename phoenix::as_actor<Expr>::type
+                >::make(phoenix::as_actor<Expr>::convert(expr));
+        }
+    };
+    
+    namespace result_of
+    {
+        template <>
+        struct is_nullary<custom_terminal<boost::spirit::lex::state_context> >
+          : mpl::false_
+        {};
+    }
+    
+    template <typename Dummy>
+    struct is_custom_terminal<boost::spirit::lex::state_context, Dummy>: mpl::true_ {};
+    
+    template <typename Dummy>
+    struct custom_terminal<boost::spirit::lex::state_context, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<boost::spirit::lex::state_getter()>
+              , proto::call<functional::env(proto::_state)>
+            )
+        >
+    {};
+
+    template <typename Dummy>
+    struct is_nullary::when<spirit::lex::rule::state_setter, Dummy>
+      : proto::make<mpl::false_()>
+    {};
+
+    template <typename Dummy>
+    struct default_actions::when<spirit::lex::rule::state_setter, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<
+                    spirit::lex::state_setter<proto::_child0>(
+                        proto::_child0
+                    )
+                >
+              , _env
+            )
+        >
+    {};
+
+    template <>
+    struct actor<spirit::lex::state_context>
+      : boost::phoenix::actor<proto::terminal<spirit::lex::state_context>::type>
+    {
+        typedef boost::phoenix::actor<
+            proto::terminal<spirit::lex::state_context>::type
+        > base_type;
+
+        actor(base_type const & base = base_type())
+          : base_type(base)
+        {}
+
+        template <typename Expr>
+        typename spirit::lex::expression::state_setter<
+            typename phoenix::as_actor<Expr>::type>::type const
+        operator=(Expr const & expr) const
+        {
+            return
+                spirit::lex::expression::state_setter<
+                    typename phoenix::as_actor<Expr>::type
+                >::make(phoenix::as_actor<Expr>::convert(expr));
+        }
+    };
+    
+    namespace result_of
+    {
+        template <>
+        struct is_nullary<custom_terminal<boost::spirit::lex::eoi_getter> >
+          : mpl::false_
+        {};
+    }
+    
+    template <typename Dummy>
+    struct is_custom_terminal<boost::spirit::lex::eoi_getter, Dummy>: mpl::true_ {};
+    
+    template <typename Dummy>
+    struct custom_terminal<boost::spirit::lex::eoi_getter, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<boost::spirit::lex::eoi_getter()>
+              , proto::call<functional::env(proto::_state)>
+            )
+        >
+    {};
+}}
+
+#endif // BOOST_SPIRIT_USE_PHOENIX_V3
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/detail/sequence_function.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/detail/sequence_function.hpp
new file mode 100644
index 0000000..0f52da8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/detail/sequence_function.hpp
@@ -0,0 +1,63 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_SEQUENCE_FUNCTION_FEB_28_2007_0249PM)
+#define BOOST_SPIRIT_LEX_SEQUENCE_FUNCTION_FEB_28_2007_0249PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/domain.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+
+namespace boost { namespace spirit { namespace lex { namespace detail
+{
+    template <typename LexerDef, typename String>
+    struct sequence_collect_function
+    {
+        sequence_collect_function(LexerDef& def_, String const& state_
+              , String const& targetstate_)
+          : def(def_), state(state_), targetstate(targetstate_) {}
+
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            component.collect(def, state, targetstate);
+            return false;     // execute for all sequence elements
+        }
+
+        LexerDef& def;
+        String const& state;
+        String const& targetstate;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        sequence_collect_function& operator= (sequence_collect_function const&);
+    };
+
+    template <typename LexerDef>
+    struct sequence_add_actions_function
+    {
+        sequence_add_actions_function(LexerDef& def_)
+          : def(def_) {}
+
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            component.add_actions(def);
+            return false;     // execute for all sequence elements
+        }
+
+        LexerDef& def;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        sequence_add_actions_function& operator= (sequence_add_actions_function const&);
+    };
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/domain.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/domain.hpp
new file mode 100644
index 0000000..e5aec86
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/domain.hpp
@@ -0,0 +1,31 @@
+//  Copyright (c) 2001-2011 Joel de Guzman
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_DOMAIN_MAR_13_2007_0140PM)
+#define BOOST_SPIRIT_LEX_DOMAIN_MAR_13_2007_0140PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/support/info.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    // lex's domain
+    struct domain {};
+
+    // bring in some of spirit parts into spirit::lex
+    using spirit::unused;
+    using spirit::unused_type;
+    using spirit::compile;
+    using spirit::info;
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer.hpp
new file mode 100644
index 0000000..535ec28
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer.hpp
@@ -0,0 +1,21 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXER_MAR_22_2007_1008PM)
+#define BOOST_SPIRIT_LEXER_MAR_22_2007_1008PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/lexer/terminals.hpp>
+#include <boost/spirit/home/lex/lexer/token_def.hpp>
+#include <boost/spirit/home/lex/lexer/char_token_def.hpp>
+#include <boost/spirit/home/lex/lexer/string_token_def.hpp>
+#include <boost/spirit/home/lex/lexer/sequence.hpp>
+#include <boost/spirit/home/lex/lexer/action.hpp>
+#include <boost/spirit/home/lex/lexer/lexer.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/action.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/action.hpp
new file mode 100644
index 0000000..8de0c87
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/action.hpp
@@ -0,0 +1,97 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(SPIRIT_LEX_ACTION_NOV_18_2007_0743PM)
+#define SPIRIT_LEX_ACTION_NOV_18_2007_0743PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/argument.hpp>
+#include <boost/spirit/home/lex/lexer/support_functions.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename Action>
+    struct action : unary_lexer<action<Subject, Action> >
+    {
+        action(Subject const& subject, Action f)
+          : subject(subject), f(f) {}
+
+        template <typename LexerDef, typename String>
+        void collect(LexerDef& lexdef, String const& state
+          , String const& targetstate) const
+        {
+            // collect the token definition information for the token_def 
+            // this action is attached to
+            subject.collect(lexdef, state, targetstate);
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef& lexdef) const
+        {
+            // call to add all actions attached further down the hierarchy 
+            subject.add_actions(lexdef);
+
+            // retrieve the id of the associated token_def and register the 
+            // given semantic action with the lexer instance
+            lexdef.add_action(subject.unique_id(), subject.state(), f);
+        }
+
+        Subject subject;
+        Action f;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        action& operator= (action const&);
+    };
+
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Karma action meta-compiler
+    template <>
+    struct make_component<lex::domain, tag::action>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                remove_const<typename Elements::car_type>::type
+            subject_type;
+
+            typedef typename
+                remove_const<typename Elements::cdr_type::car_type>::type
+            action_type;
+
+            typedef lex::action<subject_type, action_type> type;
+        };
+
+        template <typename Elements>
+        typename result<make_component(Elements, unused_type)>::type
+        operator()(Elements const& elements, unused_type) const
+        {
+            typename result<make_component(Elements, unused_type)>::type
+                result(elements.car, elements.cdr.car);
+            return result;
+        }
+    };
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/char_token_def.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/char_token_def.hpp
new file mode 100644
index 0000000..aaba2e1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/char_token_def.hpp
@@ -0,0 +1,242 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_CHAR_TOKEN_DEF_MAR_28_2007_0626PM)
+#define BOOST_SPIRIT_LEX_CHAR_TOKEN_DEF_MAR_28_2007_0626PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+#include <boost/spirit/home/lex/domain.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables 'x'
+    template <>
+    struct use_terminal<lex::domain, char>
+      : mpl::true_ {};
+
+    // enables "x"
+    template <>
+    struct use_terminal<lex::domain, char[2]>
+      : mpl::true_ {};
+
+    // enables wchar_t
+    template <>
+    struct use_terminal<lex::domain, wchar_t>
+      : mpl::true_ {};
+
+    // enables L"x"
+    template <>
+    struct use_terminal<lex::domain, wchar_t[2]>
+      : mpl::true_ {};
+
+    // enables char_('x'), char_("x")
+    template <typename CharEncoding, typename A0>
+    struct use_terminal<lex::domain
+      , terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<A0> > > 
+      : mpl::true_ {};
+
+    // enables char_('x', ID), char_("x", ID)
+    template <typename CharEncoding, typename A0, typename A1>
+    struct use_terminal<lex::domain
+      , terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<A0, A1> > > 
+      : mpl::true_ {};
+}}
+
+namespace boost { namespace spirit { namespace lex
+{ 
+    // use char_ from standard character set by default
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::standard::char_;
+#endif
+    using spirit::standard::char_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  char_token_def 
+    //      represents a single character token definition
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename CharEncoding = char_encoding::standard
+      , typename IdType = std::size_t>
+    struct char_token_def
+      : primitive_lexer<char_token_def<CharEncoding, IdType> >
+    {
+        typedef typename CharEncoding::char_type char_type;
+
+        char_token_def(char_type ch, IdType const& id) 
+          : ch(ch), id_(id), unique_id_(std::size_t(~0))
+          , token_state_(std::size_t(~0)) 
+        {}
+
+        template <typename LexerDef, typename String>
+        void collect(LexerDef& lexdef, String const& state
+          , String const& targetstate) const
+        {
+            std::size_t state_id = lexdef.add_state(state.c_str());
+
+            // If the following assertion fires you are probably trying to use 
+            // a single char_token_def instance in more than one lexer state. 
+            // This is not possible. Please create a separate token_def instance 
+            // from the same regular expression for each lexer state it needs 
+            // to be associated with.
+            BOOST_ASSERT(
+                (std::size_t(~0) == token_state_ || state_id == token_state_) &&
+                "Can't use single char_token_def with more than one lexer state");
+
+            char_type const* target = targetstate.empty() ? 0 : targetstate.c_str();
+            if (target)
+                lexdef.add_state(target);
+
+            token_state_ = state_id;
+            unique_id_ = lexdef.add_token (state.c_str(), ch, id_, target);
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef&) const {}
+
+        IdType id() const { return id_; }
+        std::size_t unique_id() const { return unique_id_; }
+        std::size_t state() const { return token_state_; }
+
+        char_type ch;
+        mutable IdType id_;
+        mutable std::size_t unique_id_;
+        mutable std::size_t token_state_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Lexer generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename CharEncoding>
+        struct basic_literal
+        {
+            typedef char_token_def<CharEncoding> result_type;
+
+            template <typename Char>
+            result_type operator()(Char ch, unused_type) const
+            {
+                return result_type(ch, ch);
+            }
+
+            template <typename Char>
+            result_type operator()(Char const* str, unused_type) const
+            {
+                return result_type(str[0], str[0]);
+            }
+        };
+    }
+
+    // literals: 'x', "x"
+    template <typename Modifiers>
+    struct make_primitive<char, Modifiers>
+      : detail::basic_literal<char_encoding::standard> {};
+
+    template <typename Modifiers>
+    struct make_primitive<char const(&)[2], Modifiers>
+      : detail::basic_literal<char_encoding::standard> {};
+
+    // literals: L'x', L"x"
+    template <typename Modifiers>
+    struct make_primitive<wchar_t, Modifiers>
+      : detail::basic_literal<char_encoding::standard_wide> {};
+
+    template <typename Modifiers>
+    struct make_primitive<wchar_t const(&)[2], Modifiers>
+      : detail::basic_literal<char_encoding::standard_wide> {};
+
+    // handle char_('x')
+    template <typename CharEncoding, typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<A0>
+        >
+      , Modifiers>
+    {
+        typedef char_token_def<CharEncoding> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args), fusion::at_c<0>(term.args));
+        }
+    };
+
+    // handle char_("x")
+    template <typename CharEncoding, typename Modifiers, typename Char>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<Char(&)[2]>   // single char strings
+        >
+      , Modifiers>
+    {
+        typedef char_token_def<CharEncoding> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            Char ch = fusion::at_c<0>(term.args)[0];
+            return result_type(ch, ch);
+        }
+    };
+
+    // handle char_('x', ID)
+    template <typename CharEncoding, typename Modifiers, typename A0, typename A1>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<A0, A1>
+        >
+      , Modifiers>
+    {
+        typedef char_token_def<CharEncoding> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args), fusion::at_c<1>(term.args));
+        }
+    };
+
+    // handle char_("x", ID)
+    template <typename CharEncoding, typename Modifiers, typename Char, typename A1>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<Char(&)[2], A1>   // single char strings
+        >
+      , Modifiers>
+    {
+        typedef char_token_def<CharEncoding> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)[0], fusion::at_c<1>(term.args));
+        }
+    };
+}}}  // namespace boost::spirit::lex
+
+#endif 
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp
new file mode 100644
index 0000000..93412ce
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp
@@ -0,0 +1,405 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_MAR_13_2007_0145PM)
+#define BOOST_SPIRIT_LEX_LEXER_MAR_13_2007_0145PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/spirit/home/lex/reference.hpp>
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/lexer/token_def.hpp>
+#include <boost/assert.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <string>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////
+        template <typename LexerDef>
+        struct lexer_def_
+          : proto::extends<
+                typename proto::terminal<
+                   lex::reference<lexer_def_<LexerDef> const> 
+                >::type
+              , lexer_def_<LexerDef> >
+          , qi::parser<lexer_def_<LexerDef> >
+          , lex::lexer_type<lexer_def_<LexerDef> >
+        {
+        private:
+            // avoid warnings about using 'this' in constructor
+            lexer_def_& this_() { return *this; }
+
+            typedef typename LexerDef::char_type char_type;
+            typedef typename LexerDef::string_type string_type;
+            typedef typename LexerDef::id_type id_type;
+
+            typedef lex::reference<lexer_def_ const> reference_;
+            typedef typename proto::terminal<reference_>::type terminal_type;
+            typedef proto::extends<terminal_type, lexer_def_> proto_base_type;
+
+            reference_ alias() const
+            {
+                return reference_(*this);
+            }
+
+        public:
+            // Qi interface: metafunction calculating parser attribute type
+            template <typename Context, typename Iterator>
+            struct attribute
+            {
+                //  the return value of a token set contains the matched token 
+                //  id, and the corresponding pair of iterators
+                typedef typename Iterator::base_iterator_type iterator_type;
+                typedef 
+                    fusion::vector2<id_type, iterator_range<iterator_type> > 
+                type;
+            };
+
+            // Qi interface: parse functionality
+            template <typename Iterator, typename Context
+              , typename Skipper, typename Attribute>
+            bool parse(Iterator& first, Iterator const& last
+              , Context& /*context*/, Skipper const& skipper
+              , Attribute& attr) const
+            {
+                qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+                if (first != last) {
+                    typedef typename 
+                        boost::detail::iterator_traits<Iterator>::value_type 
+                    token_type;
+
+                    token_type const& t = *first;
+                    if (token_is_valid(t) && t.state() == first.get_state()) {
+                    // any of the token definitions matched
+                        spirit::traits::assign_to(t, attr);
+                        ++first;
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            // Qi interface: 'what' functionality
+            template <typename Context>
+            info what(Context& /*context*/) const
+            {
+                return info("lexer");
+            }
+
+        private:
+            // allow to use the lexer.self.add("regex1", id1)("regex2", id2);
+            // syntax
+            struct adder
+            {
+                adder(lexer_def_& def_) 
+                  : def(def_) {}
+
+                // Add a token definition based on a single character as given
+                // by the first parameter, the second parameter allows to 
+                // specify the token id to use for the new token. If no token
+                // id is given the character code is used.
+                adder const& operator()(char_type c
+                  , id_type token_id = id_type()) const
+                {
+                    if (id_type() == token_id)
+                        token_id = static_cast<id_type>(c);
+                    def.def.add_token (def.state.c_str(), c, token_id
+                        , def.targetstate.empty() ? 0 : def.targetstate.c_str());
+                    return *this;
+                }
+
+                // Add a token definition based on a character sequence as 
+                // given by the first parameter, the second parameter allows to 
+                // specify the token id to use for the new token. If no token
+                // id is given this function will generate a unique id to be 
+                // used as the token's id.
+                adder const& operator()(string_type const& s
+                  , id_type token_id = id_type()) const
+                {
+                    if (id_type() == token_id)
+                        token_id = def.def.get_next_id();
+                    def.def.add_token (def.state.c_str(), s, token_id
+                        , def.targetstate.empty() ? 0 : def.targetstate.c_str());
+                    return *this;
+                }
+
+                template <typename Attribute>
+                adder const& operator()(
+                    token_def<Attribute, char_type, id_type>& tokdef
+                  , id_type token_id = id_type()) const
+                {
+                    // make sure we have a token id
+                    if (id_type() == token_id) {
+                        if (id_type() == tokdef.id()) {
+                            token_id = def.def.get_next_id();
+                            tokdef.id(token_id);
+                        }
+                        else {
+                            token_id = tokdef.id();
+                        }
+                    }
+                    else { 
+                    // the following assertion makes sure that the token_def
+                    // instance has not been assigned a different id earlier
+                        BOOST_ASSERT(id_type() == tokdef.id() 
+                                  || token_id == tokdef.id());
+                        tokdef.id(token_id);
+                    }
+
+                    def.define(tokdef);
+                    return *this;
+                }
+
+//                 template <typename F>
+//                 adder const& operator()(char_type c, id_type token_id, F act) const
+//                 {
+//                     if (id_type() == token_id)
+//                         token_id = def.def.get_next_id();
+//                     std::size_t unique_id = 
+//                         def.def.add_token (def.state.c_str(), s, token_id);
+//                     def.def.add_action(unique_id, def.state.c_str(), act);
+//                     return *this;
+//                 }
+
+                lexer_def_& def;
+
+            private:
+                // silence MSVC warning C4512: assignment operator could not be generated
+                adder& operator= (adder const&);
+            };
+            friend struct adder;
+
+            // allow to use lexer.self.add_pattern("pattern1", "regex1")(...);
+            // syntax
+            struct pattern_adder
+            {
+                pattern_adder(lexer_def_& def_) 
+                  : def(def_) {}
+
+                pattern_adder const& operator()(string_type const& p
+                  , string_type const& s) const
+                {
+                    def.def.add_pattern (def.state.c_str(), p, s);
+                    return *this;
+                }
+
+                lexer_def_& def;
+
+            private:
+                // silence MSVC warning C4512: assignment operator could not be generated
+                pattern_adder& operator= (pattern_adder const&);
+            };
+            friend struct pattern_adder;
+
+        private:
+            // Helper function to invoke the necessary 2 step compilation
+            // process on token definition expressions
+            template <typename TokenExpr>
+            void compile2pass(TokenExpr const& expr) 
+            {
+                expr.collect(def, state, targetstate);
+                expr.add_actions(def);
+            }
+
+        public:
+            ///////////////////////////////////////////////////////////////////
+            template <typename Expr>
+            void define(Expr const& expr)
+            {
+                compile2pass(compile<lex::domain>(expr));
+            }
+
+            lexer_def_(LexerDef& def_, string_type const& state_
+                  , string_type const& targetstate_ = string_type())
+              : proto_base_type(terminal_type::make(alias()))
+              , add(this_()), add_pattern(this_()), def(def_)
+              , state(state_), targetstate(targetstate_)
+            {}
+
+            // allow to switch states
+            lexer_def_ operator()(char_type const* state) const
+            {
+                return lexer_def_(def, state);
+            }
+            lexer_def_ operator()(char_type const* state
+              , char_type const* targetstate) const
+            {
+                return lexer_def_(def, state, targetstate);
+            }
+            lexer_def_ operator()(string_type const& state
+              , string_type const& targetstate = string_type()) const
+            {
+                return lexer_def_(def, state, targetstate);
+            }
+
+            // allow to assign a token definition expression
+            template <typename Expr>
+            lexer_def_& operator= (Expr const& xpr)
+            {
+                // Report invalid expression error as early as possible.
+                // If you got an error_invalid_expression error message here,
+                // then the expression (expr) is not a valid spirit lex 
+                // expression.
+                BOOST_SPIRIT_ASSERT_MATCH(lex::domain, Expr);
+
+                def.clear(state.c_str());
+                define(xpr);
+                return *this;
+            }
+
+            // explicitly tell the lexer that the given state will be defined
+            // (useful in conjunction with "*")
+            std::size_t add_state(char_type const* state = 0)
+            {
+                return def.add_state(state ? state : def.initial_state().c_str());
+            }
+
+            adder add;
+            pattern_adder add_pattern;
+
+        private:
+            LexerDef& def;
+            string_type state;
+            string_type targetstate;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            lexer_def_& operator= (lexer_def_ const&);
+        };
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+        // allow to assign a token definition expression
+        template <typename LexerDef, typename Expr>
+        inline lexer_def_<LexerDef>&
+        operator+= (lexer_def_<LexerDef>& lexdef, Expr& xpr)
+        {
+            // Report invalid expression error as early as possible.
+            // If you got an error_invalid_expression error message here,
+            // then the expression (expr) is not a valid spirit lex 
+            // expression.
+            BOOST_SPIRIT_ASSERT_MATCH(lex::domain, Expr);
+
+            lexdef.define(xpr);
+            return lexdef;
+        }
+#else
+        // allow to assign a token definition expression
+        template <typename LexerDef, typename Expr>
+        inline lexer_def_<LexerDef>&
+        operator+= (lexer_def_<LexerDef>& lexdef, Expr&& xpr)
+        {
+            // Report invalid expression error as early as possible.
+            // If you got an error_invalid_expression error message here,
+            // then the expression (expr) is not a valid spirit lex 
+            // expression.
+            BOOST_SPIRIT_ASSERT_MATCH(lex::domain, Expr);
+
+            lexdef.define(xpr);
+            return lexdef;
+        }
+#endif
+
+        template <typename LexerDef, typename Expr>
+        inline lexer_def_<LexerDef>& 
+        operator+= (lexer_def_<LexerDef>& lexdef, Expr const& xpr)
+        {
+            // Report invalid expression error as early as possible.
+            // If you got an error_invalid_expression error message here,
+            // then the expression (expr) is not a valid spirit lex 
+            // expression.
+            BOOST_SPIRIT_ASSERT_MATCH(lex::domain, Expr);
+
+            lexdef.define(xpr);
+            return lexdef;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The match_flags flags are used to influence different matching 
+    //  modes of the lexer
+    struct match_flags
+    {
+        enum enum_type 
+        {
+            match_default = 0,          // no flags
+            match_not_dot_newline = 1,  // the regex '.' doesn't match newlines
+            match_icase = 2             // all matching operations are case insensitive
+        };
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This represents a lexer object
+    ///////////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////////
+    // This is the first token id automatically assigned by the library 
+    // if needed
+    enum tokenids 
+    {
+        min_token_id = 0x10000
+    };
+
+    template <typename Lexer>
+    class lexer : public Lexer
+    {
+    private:
+        // avoid warnings about using 'this' in constructor
+        lexer& this_() { return *this; }
+
+        std::size_t next_token_id;   // has to be an integral type
+
+    public:
+        typedef Lexer lexer_type;
+        typedef typename Lexer::id_type id_type;
+        typedef typename Lexer::char_type char_type;
+        typedef typename Lexer::iterator_type iterator_type;
+        typedef lexer base_type;
+
+        typedef detail::lexer_def_<lexer> lexer_def;
+        typedef std::basic_string<char_type> string_type;
+
+        lexer(unsigned int flags = match_flags::match_default
+            , id_type first_id = id_type(min_token_id)) 
+          : lexer_type(flags)
+          , next_token_id(first_id)
+          , self(this_(), lexer_type::initial_state()) 
+        {}
+
+        // access iterator interface
+        template <typename Iterator>
+        iterator_type begin(Iterator& first, Iterator const& last
+                , char_type const* initial_state = 0) const
+            { return this->lexer_type::begin(first, last, initial_state); }
+        iterator_type end() const 
+            { return this->lexer_type::end(); }
+
+        std::size_t map_state(char_type const* state)
+            { return this->lexer_type::add_state(state); }
+
+        //  create a unique token id
+        id_type get_next_id() { return id_type(next_token_id++); }
+
+        lexer_def self;  // allow for easy token definition
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp
new file mode 100644
index 0000000..79e5f07
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp
@@ -0,0 +1,300 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_FUNCTOR_NOV_18_2007_1112PM)
+#define BOOST_SPIRIT_LEX_LEXER_FUNCTOR_NOV_18_2007_1112PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
+#include <boost/assert.hpp>
+
+#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+#define BOOST_SPIRIT_STATIC_EOF 1
+#define BOOST_SPIRIT_EOF_PREFIX static
+#else
+#define BOOST_SPIRIT_EOF_PREFIX 
+#endif
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  functor is a template usable as the functor object for the 
+    //  multi_pass iterator allowing to wrap a lexertl based dfa into a 
+    //  iterator based interface.
+    //  
+    //    Token:      the type of the tokens produced by this functor
+    //                this needs to expose a constructor with the following
+    //                prototype:
+    //
+    //                Token(std::size_t id, std::size_t state, 
+    //                      Iterator start, Iterator end)
+    //
+    //                where 'id' is the token id, state is the lexer state,
+    //                this token has been matched in, and 'first' and 'end'  
+    //                mark the start and the end of the token with respect 
+    //                to the underlying character stream.
+    //    FunctorData:
+    //                this is expected to encapsulate the shared part of the 
+    //                functor (see lex/lexer/lexertl/functor_data.hpp for an
+    //                example and documentation).
+    //    Iterator:   the type of the underlying iterator
+    //    SupportsActors:
+    //                this is expected to be a mpl::bool_, if mpl::true_ the
+    //                functor invokes functors which (optionally) have 
+    //                been attached to the token definitions.
+    //    SupportState:
+    //                this is expected to be a mpl::bool_, if mpl::true_ the
+    //                functor supports different lexer states, 
+    //                otherwise no lexer state is supported.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Token
+      , template <typename, typename, typename, typename> class FunctorData
+      , typename Iterator = typename Token::iterator_type
+      , typename SupportsActors = mpl::false_
+      , typename SupportsState = typename Token::has_state>
+    class functor
+    {
+    public:
+        typedef typename 
+            boost::detail::iterator_traits<Iterator>::value_type 
+        char_type;
+
+    private:
+        // Needed by compilers not implementing the resolution to DR45. For
+        // reference, see
+        // http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#45.
+        typedef typename Token::token_value_type token_value_type;
+        friend class FunctorData<Iterator, SupportsActors, SupportsState
+          , token_value_type>;
+
+        // Helper template allowing to assign a value on exit
+        template <typename T>
+        struct assign_on_exit
+        {
+            assign_on_exit(T& dst, T const& src)
+              : dst_(dst), src_(src) {}
+
+            ~assign_on_exit()
+            {
+                dst_ = src_;
+            }
+
+            T& dst_;
+            T const& src_;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            assign_on_exit& operator= (assign_on_exit const&);
+        };
+
+    public:
+        functor()
+#if defined(__PGI)
+          : eof()
+#endif 
+        {}
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+        // somehow VC7.1 needs this (meaningless) assignment operator
+        functor& operator=(functor const& rhs)
+        {
+            return *this;
+        }
+#endif
+
+        ///////////////////////////////////////////////////////////////////////
+        // interface to the iterator_policies::split_functor_input policy
+        typedef Token result_type;
+        typedef functor unique;
+        typedef FunctorData<Iterator, SupportsActors, SupportsState
+          , token_value_type> shared;
+
+        BOOST_SPIRIT_EOF_PREFIX result_type const eof;
+
+        ///////////////////////////////////////////////////////////////////////
+        typedef Iterator iterator_type;
+        typedef typename shared::semantic_actions_type semantic_actions_type;
+        typedef typename shared::next_token_functor next_token_functor;
+        typedef typename shared::get_state_name_type get_state_name_type;
+
+        // this is needed to wrap the semantic actions in a proper way
+        typedef typename shared::wrap_action_type wrap_action_type;
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename MultiPass>
+        static result_type& get_next(MultiPass& mp, result_type& result)
+        {
+            typedef typename result_type::id_type id_type;
+
+            shared& data = mp.shared()->ftor;
+            for(;;) 
+            {
+                if (data.get_first() == data.get_last()) 
+#if defined(BOOST_SPIRIT_STATIC_EOF)
+                    return result = eof;
+#else
+                    return result = mp.ftor.eof;
+#endif
+
+                data.reset_value();
+                Iterator end = data.get_first();
+                std::size_t unique_id = boost::lexer::npos;
+                bool prev_bol = false;
+
+                // lexer matching might change state
+                std::size_t state = data.get_state();
+                std::size_t id = data.next(end, unique_id, prev_bol);
+
+                if (boost::lexer::npos == id) {   // no match
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+                    std::string next;
+                    Iterator it = data.get_first();
+                    for (std::size_t i = 0; i < 10 && it != data.get_last(); ++it, ++i)
+                        next += *it;
+
+                    std::cerr << "Not matched, in state: " << state 
+                              << ", lookahead: >" << next << "<" << std::endl;
+#endif
+                    return result = result_type(0);
+                }
+                else if (0 == id) {         // EOF reached
+#if defined(BOOST_SPIRIT_STATIC_EOF)
+                    return result = eof;
+#else
+                    return result = mp.ftor.eof;
+#endif
+                }
+
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+                {
+                    std::string next;
+                    Iterator it = end;
+                    for (std::size_t i = 0; i < 10 && it != data.get_last(); ++it, ++i)
+                        next += *it;
+
+                    std::cerr << "Matched: " << id << ", in state: " 
+                              << state << ", string: >" 
+                              << std::basic_string<char_type>(data.get_first(), end) << "<"
+                              << ", lookahead: >" << next << "<" << std::endl;
+                    if (data.get_state() != state) {
+                        std::cerr << "Switched to state: " 
+                                  << data.get_state() << std::endl;
+                    }
+                }
+#endif
+                // account for a possibly pending lex::more(), i.e. moving 
+                // data.first_ back to the start of the previously matched token.
+                bool adjusted = data.adjust_start();
+
+                // set the end of the matched input sequence in the token data
+                data.set_end(end);
+
+                // invoke attached semantic actions, if defined, might change
+                // state, id, data.first_, and/or end
+                BOOST_SCOPED_ENUM(pass_flags) pass = 
+                    data.invoke_actions(state, id, unique_id, end);
+
+                if (data.has_value()) {
+                    // return matched token using the token value as set before
+                    // using data.set_value(), advancing 'data.first_' past the 
+                    // matched sequence
+                    assign_on_exit<Iterator> on_exit(data.get_first(), end);
+                    return result = result_type(id_type(id), state, data.get_value());
+                }
+                else if (pass_flags::pass_normal == pass) {
+                    // return matched token, advancing 'data.first_' past the 
+                    // matched sequence
+                    assign_on_exit<Iterator> on_exit(data.get_first(), end);
+                    return result = result_type(id_type(id), state, data.get_first(), end);
+                }
+                else if (pass_flags::pass_fail == pass) {
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+                    std::cerr << "Matching forced to fail" << std::endl; 
+#endif
+                    // if the data.first_ got adjusted above, revert this adjustment
+                    if (adjusted)
+                        data.revert_adjust_start();
+
+                    // one of the semantic actions signaled no-match
+                    data.reset_bol(prev_bol);
+                    if (state != data.get_state())
+                        continue;       // retry matching if state has changed
+
+                    // if the state is unchanged repeating the match wouldn't
+                    // move the input forward, causing an infinite loop
+                    return result = result_type(0);
+                }
+
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+                std::cerr << "Token ignored, continuing matching" << std::endl; 
+#endif
+            // if this token needs to be ignored, just repeat the matching,
+            // while starting right after the current match
+                data.get_first() = end;
+            }
+        }
+
+        // set_state are propagated up to the iterator interface, allowing to 
+        // manipulate the current lexer state through any of the exposed 
+        // iterators.
+        template <typename MultiPass>
+        static std::size_t set_state(MultiPass& mp, std::size_t state) 
+        { 
+            std::size_t oldstate = mp.shared()->ftor.get_state();
+            mp.shared()->ftor.set_state(state);
+
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+            std::cerr << "Switching state from: " << oldstate 
+                      << " to: " << state
+                      << std::endl;
+#endif
+            return oldstate; 
+        }
+
+        template <typename MultiPass>
+        static std::size_t get_state(MultiPass& mp) 
+        { 
+            return mp.shared()->ftor.get_state();
+        }
+
+        template <typename MultiPass>
+        static std::size_t 
+        map_state(MultiPass const& mp, char_type const* statename)  
+        { 
+            return mp.shared()->ftor.get_state_id(statename);
+        }
+
+        // we don't need this, but it must be there
+        template <typename MultiPass>
+        static void destroy(MultiPass const&) {}
+    };
+
+#if defined(BOOST_SPIRIT_STATIC_EOF)
+    ///////////////////////////////////////////////////////////////////////////
+    //  eof token
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Token
+      , template <typename, typename, typename, typename> class FunctorData
+      , typename Iterator, typename SupportsActors, typename SupportsState>
+    typename functor<Token, FunctorData, Iterator, SupportsActors, SupportsState>::result_type const
+        functor<Token, FunctorData, Iterator, SupportsActors, SupportsState>::eof = 
+            typename functor<Token, FunctorData, Iterator, SupportsActors
+              , SupportsState>::result_type();
+#endif
+
+}}}}
+
+#undef BOOST_SPIRIT_EOF_PREFIX
+#undef BOOST_SPIRIT_STATIC_EOF
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp
new file mode 100644
index 0000000..207b374
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp
@@ -0,0 +1,552 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_FUNCTOR_DATA_JUN_10_2009_0954AM)
+#define BOOST_SPIRIT_LEX_LEXER_FUNCTOR_DATA_JUN_10_2009_0954AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/spirit/home/support/detail/lexer/generator.hpp>
+#include <boost/spirit/home/support/detail/lexer/rules.hpp>
+#include <boost/spirit/home/support/detail/lexer/state_machine.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/iterator_tokenizer.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/semantic_action_data.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/optional.hpp>
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Iterator, typename HasActors, typename HasState
+          , typename TokenValue>
+        class data;    // no default specialization
+
+        ///////////////////////////////////////////////////////////////////////
+        //  neither supports state, nor actors
+        template <typename Iterator, typename TokenValue>
+        class data<Iterator, mpl::false_, mpl::false_, TokenValue>
+        {
+        protected:
+            typedef typename 
+                boost::detail::iterator_traits<Iterator>::value_type 
+            char_type;
+
+        public:
+            typedef Iterator base_iterator_type;
+            typedef iterator_range<Iterator> token_value_type;
+            typedef token_value_type get_value_type;
+            typedef std::size_t state_type;
+            typedef char_type const* state_name_type;
+            typedef unused_type semantic_actions_type;
+            typedef detail::wrap_action<unused_type, Iterator, data, std::size_t>
+                wrap_action_type;
+
+            typedef unused_type next_token_functor;
+            typedef unused_type get_state_name_type;
+
+            // initialize the shared data 
+            template <typename IterData>
+            data (IterData const& data_, Iterator& first, Iterator const& last)
+              : first_(first), last_(last)
+              , state_machine_(data_.state_machine_)
+              , rules_(data_.rules_)
+              , bol_(data_.state_machine_.data()._seen_BOL_assertion) {}
+
+            // The following functions are used by the implementation of the 
+            // placeholder '_state'.
+            template <typename Char>
+            void set_state_name (Char const*) 
+            {
+// some (random) versions of gcc instantiate this function even if it's not 
+// needed leading to false static asserts
+#if !defined(__GNUC__)
+                // If you see a compile time assertion below you're probably 
+                // using a token type not supporting lexer states (the 3rd 
+                // template parameter of the token is mpl::false_), but your 
+                // code uses state changes anyways.
+                BOOST_STATIC_ASSERT(false);
+#endif
+            }
+            char_type const* get_state_name() const { return rules_.initial(); }
+            std::size_t get_state_id (char_type const*) const
+            {
+                return 0;
+            }
+
+            // The function get_eoi() is used by the implementation of the 
+            // placeholder '_eoi'.
+            Iterator const& get_eoi() const { return last_; }
+
+            // The function less() is used by the implementation of the support
+            // function lex::less(). Its functionality is equivalent to flex'
+            // function yyless(): it returns an iterator positioned to the 
+            // nth input character beyond the current start iterator (i.e. by
+            // assigning the return value to the placeholder '_end' it is 
+            // possible to return all but the first n characters of the current 
+            // token back to the input stream. 
+            //
+            // This function does nothing as long as no semantic actions are 
+            // used.
+            Iterator const& less(Iterator const& it, int) 
+            { 
+                // The following assertion fires most likely because you are 
+                // using lexer semantic actions without using the actor_lexer
+                // as the base class for your token definition class.
+                BOOST_ASSERT(false && 
+                    "Are you using lexer semantic actions without using the "
+                    "actor_lexer base?");
+                return it; 
+            }
+
+            // The function more() is used by the implementation of the support 
+            // function lex::more(). Its functionality is equivalent to flex'
+            // function yymore(): it tells the lexer that the next time it 
+            // matches a rule, the corresponding token should be appended onto 
+            // the current token value rather than replacing it.
+            // 
+            // These functions do nothing as long as no semantic actions are 
+            // used.
+            void more() 
+            { 
+                // The following assertion fires most likely because you are 
+                // using lexer semantic actions without using the actor_lexer
+                // as the base class for your token definition class.
+                BOOST_ASSERT(false && 
+                    "Are you using lexer semantic actions without using the "
+                    "actor_lexer base?"); 
+            }
+            bool adjust_start() { return false; }
+            void revert_adjust_start() {}
+
+            // The function lookahead() is used by the implementation of the 
+            // support function lex::lookahead. It can be used to implement 
+            // lookahead for lexer engines not supporting constructs like flex'
+            // a/b  (match a, but only when followed by b):
+            //
+            // This function does nothing as long as no semantic actions are 
+            // used.
+            bool lookahead(std::size_t, std::size_t /*state*/ = std::size_t(~0)) 
+            { 
+                // The following assertion fires most likely because you are 
+                // using lexer semantic actions without using the actor_lexer
+                // as the base class for your token definition class.
+                BOOST_ASSERT(false && 
+                    "Are you using lexer semantic actions without using the "
+                    "actor_lexer base?");
+                return false; 
+            }
+
+            // the functions next, invoke_actions, and get_state are used by 
+            // the functor implementation below
+
+            // The function next() tries to match the next token from the 
+            // underlying input sequence. 
+            std::size_t next(Iterator& end, std::size_t& unique_id, bool& prev_bol)
+            {
+                prev_bol = bol_;
+
+                typedef basic_iterator_tokeniser<Iterator> tokenizer;
+                return tokenizer::next(state_machine_, bol_, end, last_
+                  , unique_id);
+            }
+
+            // nothing to invoke, so this is empty
+            BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t
+              , std::size_t, std::size_t, Iterator const&) 
+            {
+                return pass_flags::pass_normal;    // always accept
+            }
+
+            std::size_t get_state() const { return 0; }
+            void set_state(std::size_t) {}
+
+            void set_end(Iterator const& it) {}
+
+            Iterator& get_first() { return first_; }
+            Iterator const& get_first() const { return first_; }
+            Iterator const& get_last() const { return last_; }
+
+            iterator_range<Iterator> get_value() const 
+            { 
+                return iterator_range<Iterator>(first_, last_); 
+            }
+            bool has_value() const { return false; }
+            void reset_value() {}
+
+            void reset_bol(bool bol) { bol_ = bol; }
+
+        protected:
+            Iterator& first_;
+            Iterator last_;
+
+            boost::lexer::basic_state_machine<char_type> const& state_machine_;
+            boost::lexer::basic_rules<char_type> const& rules_;
+
+            bool bol_;      // helper storing whether last character was \n
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            data& operator= (data const&);
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  doesn't support lexer semantic actions, but supports state
+        template <typename Iterator, typename TokenValue>
+        class data<Iterator, mpl::false_, mpl::true_, TokenValue>
+          : public data<Iterator, mpl::false_, mpl::false_, TokenValue>
+        {
+        protected:
+            typedef data<Iterator, mpl::false_, mpl::false_, TokenValue> base_type;
+            typedef typename base_type::char_type char_type;
+
+        public:
+            typedef Iterator base_iterator_type;
+            typedef iterator_range<Iterator> token_value_type;
+            typedef token_value_type get_value_type;
+            typedef typename base_type::state_type state_type;
+            typedef typename base_type::state_name_type state_name_type;
+            typedef typename base_type::semantic_actions_type 
+                semantic_actions_type;
+
+            // initialize the shared data 
+            template <typename IterData>
+            data (IterData const& data_, Iterator& first, Iterator const& last)
+              : base_type(data_, first, last)
+              , state_(0) {}
+
+            // The following functions are used by the implementation of the 
+            // placeholder '_state'.
+            void set_state_name (char_type const* new_state) 
+            { 
+                std::size_t state_id = this->rules_.state(new_state);
+
+                // If the following assertion fires you've probably been using 
+                // a lexer state name which was not defined in your token 
+                // definition.
+                BOOST_ASSERT(state_id != boost::lexer::npos);
+
+                if (state_id != boost::lexer::npos)
+                    state_ = state_id;
+            }
+            char_type const* get_state_name() const
+            {
+                return this->rules_.state(state_);
+            }
+            std::size_t get_state_id (char_type const* state) const
+            {
+                return this->rules_.state(state);
+            }
+
+            // the functions next() and get_state() are used by the functor 
+            // implementation below
+
+            // The function next() tries to match the next token from the 
+            // underlying input sequence. 
+            std::size_t next(Iterator& end, std::size_t& unique_id, bool& prev_bol)
+            {
+                prev_bol = this->bol_;
+
+                typedef basic_iterator_tokeniser<Iterator> tokenizer;
+                return tokenizer::next(this->state_machine_, state_, 
+                    this->bol_, end, this->get_eoi(), unique_id);
+            }
+
+            std::size_t& get_state() { return state_; }
+            void set_state(std::size_t state) { state_ = state; }
+
+        protected:
+            std::size_t state_;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            data& operator= (data const&);
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  does support lexer semantic actions, may support state
+        template <typename Iterator, typename HasState, typename TokenValue>
+        class data<Iterator, mpl::true_, HasState, TokenValue> 
+          : public data<Iterator, mpl::false_, HasState, TokenValue>
+        {
+        public:
+            typedef semantic_actions<Iterator, HasState, data> 
+                semantic_actions_type;
+
+        protected:
+            typedef data<Iterator, mpl::false_, HasState, TokenValue> base_type;
+            typedef typename base_type::char_type char_type;
+            typedef typename semantic_actions_type::functor_wrapper_type
+                functor_wrapper_type;
+
+        public:
+            typedef Iterator base_iterator_type;
+            typedef TokenValue token_value_type;
+            typedef TokenValue const& get_value_type;
+            typedef typename base_type::state_type state_type;
+            typedef typename base_type::state_name_type state_name_type;
+
+            typedef detail::wrap_action<functor_wrapper_type
+              , Iterator, data, std::size_t> wrap_action_type;
+
+            template <typename IterData>
+            data (IterData const& data_, Iterator& first, Iterator const& last)
+              : base_type(data_, first, last)
+              , actions_(data_.actions_), hold_()
+              , value_(iterator_range<Iterator>(first, last))
+              , has_value_(false), has_hold_(false) {}
+
+            // invoke attached semantic actions, if defined
+            BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t state
+              , std::size_t& id, std::size_t unique_id, Iterator& end)
+            {
+                return actions_.invoke_actions(state, id, unique_id, end, *this); 
+            }
+
+            // The function less() is used by the implementation of the support
+            // function lex::less(). Its functionality is equivalent to flex'
+            // function yyless(): it returns an iterator positioned to the 
+            // nth input character beyond the current start iterator (i.e. by
+            // assigning the return value to the placeholder '_end' it is 
+            // possible to return all but the first n characters of the current 
+            // token back to the input stream). 
+            Iterator const& less(Iterator& it, int n) 
+            {
+                it = this->get_first();
+                std::advance(it, n);
+                return it;
+            }
+
+            // The function more() is used by the implementation of the support 
+            // function lex::more(). Its functionality is equivalent to flex'
+            // function yymore(): it tells the lexer that the next time it 
+            // matches a rule, the corresponding token should be appended onto 
+            // the current token value rather than replacing it.
+            void more()
+            {
+                hold_ = this->get_first();
+                has_hold_ = true;
+            }
+
+            // The function lookahead() is used by the implementation of the 
+            // support function lex::lookahead. It can be used to implement 
+            // lookahead for lexer engines not supporting constructs like flex'
+            // a/b  (match a, but only when followed by b)
+            bool lookahead(std::size_t id, std::size_t state = std::size_t(~0))
+            {
+                Iterator end = end_;
+                std::size_t unique_id = boost::lexer::npos;
+                bool bol = this->bol_;
+
+                if (std::size_t(~0) == state)
+                    state = this->state_;
+
+                typedef basic_iterator_tokeniser<Iterator> tokenizer;
+                return id == tokenizer::next(this->state_machine_, state, 
+                    bol, end, this->get_eoi(), unique_id);
+            }
+
+            // The adjust_start() and revert_adjust_start() are helper 
+            // functions needed to implement the functionality required for 
+            // lex::more(). It is called from the functor body below.
+            bool adjust_start()
+            {
+                if (!has_hold_)
+                    return false;
+
+                std::swap(this->get_first(), hold_);
+                has_hold_ = false;
+                return true;
+            }
+            void revert_adjust_start()
+            {
+                // this will be called only if adjust_start above returned true
+                std::swap(this->get_first(), hold_);
+                has_hold_ = true;
+            }
+
+            TokenValue const& get_value() const 
+            {
+                if (!has_value_) {
+                    value_ = iterator_range<Iterator>(this->get_first(), end_);
+                    has_value_ = true;
+                }
+                return value_;
+            }
+            template <typename Value>
+            void set_value(Value const& val)
+            {
+                value_ = val;
+                has_value_ = true;
+            }
+            void set_end(Iterator const& it)
+            {
+                end_ = it;
+            }
+            bool has_value() const { return has_value_; }
+            void reset_value() { has_value_ = false; }
+
+        protected:
+            semantic_actions_type const& actions_;
+            Iterator hold_;     // iterator needed to support lex::more()
+            Iterator end_;      // iterator pointing to end of matched token
+            mutable TokenValue value_;  // token value to use
+            mutable bool has_value_;    // 'true' if value_ is valid
+            bool has_hold_;     // 'true' if hold_ is valid
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            data& operator= (data const&);
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  does support lexer semantic actions, may support state, is used for
+        //  position_token exposing exactly one type
+        template <typename Iterator, typename HasState, typename TokenValue>
+        class data<Iterator, mpl::true_, HasState, boost::optional<TokenValue> > 
+          : public data<Iterator, mpl::false_, HasState, TokenValue>
+        {
+        public:
+            typedef semantic_actions<Iterator, HasState, data> 
+                semantic_actions_type;
+
+        protected:
+            typedef data<Iterator, mpl::false_, HasState, TokenValue> base_type;
+            typedef typename base_type::char_type char_type;
+            typedef typename semantic_actions_type::functor_wrapper_type
+                functor_wrapper_type;
+
+        public:
+            typedef Iterator base_iterator_type;
+            typedef boost::optional<TokenValue> token_value_type;
+            typedef boost::optional<TokenValue> const& get_value_type;
+            typedef typename base_type::state_type state_type;
+            typedef typename base_type::state_name_type state_name_type;
+
+            typedef detail::wrap_action<functor_wrapper_type
+              , Iterator, data, std::size_t> wrap_action_type;
+
+            template <typename IterData>
+            data (IterData const& data_, Iterator& first, Iterator const& last)
+              : base_type(data_, first, last)
+              , actions_(data_.actions_), hold_()
+              , has_value_(false), has_hold_(false) 
+            {
+                spirit::traits::assign_to(first, last, value_);
+                has_value_ = true;
+            }
+
+            // invoke attached semantic actions, if defined
+            BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t state
+              , std::size_t& id, std::size_t unique_id, Iterator& end)
+            {
+                return actions_.invoke_actions(state, id, unique_id, end, *this); 
+            }
+
+            // The function less() is used by the implementation of the support
+            // function lex::less(). Its functionality is equivalent to flex'
+            // function yyless(): it returns an iterator positioned to the 
+            // nth input character beyond the current start iterator (i.e. by
+            // assigning the return value to the placeholder '_end' it is 
+            // possible to return all but the first n characters of the current 
+            // token back to the input stream). 
+            Iterator const& less(Iterator& it, int n) 
+            {
+                it = this->get_first();
+                std::advance(it, n);
+                return it;
+            }
+
+            // The function more() is used by the implementation of the support 
+            // function lex::more(). Its functionality is equivalent to flex'
+            // function yymore(): it tells the lexer that the next time it 
+            // matches a rule, the corresponding token should be appended onto 
+            // the current token value rather than replacing it.
+            void more()
+            {
+                hold_ = this->get_first();
+                has_hold_ = true;
+            }
+
+            // The function lookahead() is used by the implementation of the 
+            // support function lex::lookahead. It can be used to implement 
+            // lookahead for lexer engines not supporting constructs like flex'
+            // a/b  (match a, but only when followed by b)
+            bool lookahead(std::size_t id, std::size_t state = std::size_t(~0))
+            {
+                Iterator end = end_;
+                std::size_t unique_id = boost::lexer::npos;
+                bool bol = this->bol_;
+
+                if (std::size_t(~0) == state)
+                    state = this->state_;
+
+                typedef basic_iterator_tokeniser<Iterator> tokenizer;
+                return id == tokenizer::next(this->state_machine_, state, 
+                    bol, end, this->get_eoi(), unique_id);
+            }
+
+            // The adjust_start() and revert_adjust_start() are helper 
+            // functions needed to implement the functionality required for 
+            // lex::more(). It is called from the functor body below.
+            bool adjust_start()
+            {
+                if (!has_hold_)
+                    return false;
+
+                std::swap(this->get_first(), hold_);
+                has_hold_ = false;
+                return true;
+            }
+            void revert_adjust_start()
+            {
+                // this will be called only if adjust_start above returned true
+                std::swap(this->get_first(), hold_);
+                has_hold_ = true;
+            }
+
+            token_value_type const& get_value() const 
+            {
+                if (!has_value_) {
+                    spirit::traits::assign_to(this->get_first(), end_, value_);
+                    has_value_ = true;
+                }
+                return value_;
+            }
+            template <typename Value>
+            void set_value(Value const& val)
+            {
+                value_ = val;
+                has_value_ = true;
+            }
+            void set_end(Iterator const& it)
+            {
+                end_ = it;
+            }
+            bool has_value() const { return has_value_; }
+            void reset_value() { has_value_ = false; }
+
+        protected:
+            semantic_actions_type const& actions_;
+            Iterator hold_;     // iterator needed to support lex::more()
+            Iterator end_;      // iterator pointing to end of matched token
+            mutable token_value_type value_;  // token value to use
+            mutable bool has_value_;    // 'true' if value_ is valid
+            bool has_hold_;     // 'true' if hold_ is valid
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            data& operator= (data const&);
+        };
+    }
+}}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp
new file mode 100644
index 0000000..f2793ba
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp
@@ -0,0 +1,121 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_ITERATOR_MAR_16_2007_0353PM)
+#define BOOST_SPIRIT_LEX_LEXER_ITERATOR_MAR_16_2007_0353PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#if defined(BOOST_SPIRIT_DEBUG)
+#include <boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp>
+#else
+#include <boost/spirit/home/support/iterators/detail/no_check_policy.hpp>
+#endif
+#include <boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp>
+#include <boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp>
+#include <boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp>
+#include <boost/spirit/home/support/iterators/multi_pass.hpp>
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename FunctorData>
+    struct make_multi_pass
+    {
+        // Divide the given functor type into its components (unique and 
+        // shared) and build a std::pair from these parts
+        typedef std::pair<typename FunctorData::unique
+          , typename FunctorData::shared> functor_data_type;
+
+        // This is the result type returned from the iterator
+        typedef typename FunctorData::result_type result_type;
+
+        // Compose the multi_pass iterator policy type from the appropriate 
+        // policies
+        typedef iterator_policies::split_functor_input input_policy;
+        typedef iterator_policies::ref_counted ownership_policy;
+#if defined(BOOST_SPIRIT_DEBUG)
+        typedef iterator_policies::buf_id_check check_policy;
+#else
+        typedef iterator_policies::no_check check_policy;
+#endif
+        typedef iterator_policies::split_std_deque storage_policy;
+
+        typedef iterator_policies::default_policy<
+                ownership_policy, check_policy, input_policy, storage_policy>
+            policy_type;
+
+        // Compose the multi_pass iterator from the policy
+        typedef spirit::multi_pass<functor_data_type, policy_type> type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  lexer_iterator exposes an iterator for a lexertl based dfa (lexer) 
+    //  The template parameters have the same semantics as described for the
+    //  functor above.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Functor>
+    class iterator : public make_multi_pass<Functor>::type
+    {
+    public:
+        typedef typename Functor::unique unique_functor_type;
+        typedef typename Functor::shared shared_functor_type;
+
+        typedef typename Functor::iterator_type base_iterator_type;
+        typedef typename Functor::result_type token_type;
+
+    private:
+        typedef typename make_multi_pass<Functor>::functor_data_type 
+            functor_type;
+        typedef typename make_multi_pass<Functor>::type base_type;
+        typedef typename Functor::char_type char_type;
+
+    public:
+        // create a new iterator encapsulating the lexer object to be used
+        // for tokenization
+        template <typename IteratorData>
+        iterator(IteratorData const& iterdata_, base_iterator_type& first
+              , base_iterator_type const& last, char_type const* state = 0)
+          : base_type(functor_type(unique_functor_type()
+              , shared_functor_type(iterdata_, first, last))) 
+        {
+            set_state(map_state(state));
+        }
+
+        // create an end iterator usable for end of range checking
+        iterator() {}
+
+        // (wash): < mgaunard> T it; T it2 = ++it; doesn't ocmpile
+        //         < mgaunard> this gets fixed by adding
+        iterator(const base_type& base)
+          : base_type(base) { }
+
+        // set the new required state for the underlying lexer object
+        std::size_t set_state(std::size_t state)
+        {
+            return unique_functor_type::set_state(*this, state);
+        }
+
+        // get the curent state for the underlying lexer object
+        std::size_t get_state()
+        {
+            return unique_functor_type::get_state(*this);
+        }
+
+        // map the given state name to a corresponding state id as understood
+        // by the underlying lexer object
+        std::size_t map_state(char_type const* statename)
+        {
+            return (0 != statename) 
+              ? unique_functor_type::map_state(*this, statename)
+              : 0;
+        }
+    };
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator_tokenizer.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator_tokenizer.hpp
new file mode 100644
index 0000000..31dffce
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator_tokenizer.hpp
@@ -0,0 +1,255 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXERTL_ITERATOR_TOKENISER_MARCH_22_2007_0859AM)
+#define BOOST_SPIRIT_LEXERTL_ITERATOR_TOKENISER_MARCH_22_2007_0859AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/detail/iterator.hpp>
+#include <boost/spirit/home/support/detail/lexer/state_machine.hpp>
+#include <boost/spirit/home/support/detail/lexer/consts.hpp>
+#include <boost/spirit/home/support/detail/lexer/size_t.hpp>
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+#include <vector>
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Iterator>
+    class basic_iterator_tokeniser
+    {
+    public:
+        typedef std::vector<std::size_t> size_t_vector;
+        typedef typename boost::detail::iterator_traits<Iterator>::value_type 
+            char_type;
+
+        static std::size_t next (
+            boost::lexer::basic_state_machine<char_type> const& state_machine_
+          , std::size_t &dfa_state_, bool& bol_, Iterator &start_token_
+          , Iterator const& end_, std::size_t& unique_id_)
+        {
+            if (start_token_ == end_) 
+            {
+                unique_id_ = boost::lexer::npos;
+                return 0;
+            }
+
+            bool bol = bol_;
+            boost::lexer::detail::internals const& internals_ =
+                state_machine_.data();
+
+        again:
+            std::size_t const* lookup_ = &internals_._lookup[dfa_state_]->
+                front ();
+            std::size_t dfa_alphabet_ = internals_._dfa_alphabet[dfa_state_];
+            std::size_t const* dfa_ = &internals_._dfa[dfa_state_]->front ();
+
+            std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+            Iterator curr_ = start_token_;
+            bool end_state_ = *ptr_ != 0;
+            std::size_t id_ = *(ptr_ + boost::lexer::id_index);
+            std::size_t uid_ = *(ptr_ + boost::lexer::unique_id_index);
+            std::size_t end_start_state_ = dfa_state_;
+            bool end_bol_ = bol_;
+            Iterator end_token_ = start_token_;
+
+            while (curr_ != end_)
+            {
+                std::size_t const BOL_state_ = ptr_[boost::lexer::bol_index];
+                std::size_t const EOL_state_ = ptr_[boost::lexer::eol_index];
+
+                if (BOL_state_ && bol)
+                {
+                    ptr_ = &dfa_[BOL_state_ * dfa_alphabet_];
+                }
+                else if (EOL_state_ && *curr_ == '\n')
+                {
+                    ptr_ = &dfa_[EOL_state_ * dfa_alphabet_];
+                }
+                else
+                {
+                    typedef typename 
+                        boost::detail::iterator_traits<Iterator>::value_type 
+                    value_type;
+                    typedef typename 
+                        boost::lexer::char_traits<value_type>::index_type 
+                    index_type;
+
+                    index_type index = 
+                        boost::lexer::char_traits<value_type>::call(*curr_++);
+                    bol = (index == '\n') ? true : false;
+                    std::size_t const state_ = ptr_[
+                        lookup_[static_cast<std::size_t>(index)]];
+
+                    if (state_ == 0)
+                    {
+                        break;
+                    }
+
+                    ptr_ = &dfa_[state_ * dfa_alphabet_];
+                }
+
+                if (*ptr_)
+                {
+                    end_state_ = true;
+                    id_ = *(ptr_ + boost::lexer::id_index);
+                    uid_ = *(ptr_ + boost::lexer::unique_id_index);
+                    end_start_state_ = *(ptr_ + boost::lexer::state_index);
+                    end_bol_ = bol;
+                    end_token_ = curr_;
+                }
+            }
+
+            std::size_t const EOL_state_ = ptr_[boost::lexer::eol_index];
+
+            if (EOL_state_ && curr_ == end_)
+            {
+                ptr_ = &dfa_[EOL_state_ * dfa_alphabet_];
+
+                if (*ptr_)
+                {
+                    end_state_ = true;
+                    id_ = *(ptr_ + boost::lexer::id_index);
+                    uid_ = *(ptr_ + boost::lexer::unique_id_index);
+                    end_start_state_ = *(ptr_ + boost::lexer::state_index);
+                    end_bol_ = bol;
+                    end_token_ = curr_;
+                }
+            }
+
+            if (end_state_) {
+                // return longest match
+                dfa_state_ = end_start_state_;
+                start_token_ = end_token_;
+
+                if (id_ == 0)
+                {
+                    bol = end_bol_;
+                    goto again;
+                }
+                else
+                {
+                    bol_ = end_bol_;
+                }
+            }
+            else {
+                bol_ = (*start_token_ == '\n') ? true : false;
+                id_ = boost::lexer::npos;
+                uid_ = boost::lexer::npos;
+            }
+
+            unique_id_ = uid_;
+            return id_;
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        static std::size_t next (
+            boost::lexer::basic_state_machine<char_type> const& state_machine_
+          , bool& bol_, Iterator &start_token_, Iterator const& end_
+          , std::size_t& unique_id_)
+        {
+            if (start_token_ == end_)
+            {
+                unique_id_ = boost::lexer::npos;
+                return 0;
+            }
+
+            bool bol = bol_;
+            std::size_t const* lookup_ = &state_machine_.data()._lookup[0]->front();
+            std::size_t dfa_alphabet_ = state_machine_.data()._dfa_alphabet[0];
+            std::size_t const* dfa_ = &state_machine_.data()._dfa[0]->front ();
+            std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+
+            Iterator curr_ = start_token_;
+            bool end_state_ = *ptr_ != 0;
+            std::size_t id_ = *(ptr_ + boost::lexer::id_index);
+            std::size_t uid_ = *(ptr_ + boost::lexer::unique_id_index);
+            bool end_bol_ = bol_;
+            Iterator end_token_ = start_token_;
+
+            while (curr_ != end_)
+            {
+                std::size_t const BOL_state_ = ptr_[boost::lexer::bol_index];
+                std::size_t const EOL_state_ = ptr_[boost::lexer::eol_index];
+
+                if (BOL_state_ && bol)
+                {
+                    ptr_ = &dfa_[BOL_state_ * dfa_alphabet_];
+                }
+                else if (EOL_state_ && *curr_ == '\n')
+                {
+                    ptr_ = &dfa_[EOL_state_ * dfa_alphabet_];
+                }
+                else
+                {
+                    typedef typename 
+                        boost::detail::iterator_traits<Iterator>::value_type 
+                    value_type;
+                    typedef typename 
+                        boost::lexer::char_traits<value_type>::index_type 
+                    index_type;
+
+                    index_type index = 
+                        boost::lexer::char_traits<value_type>::call(*curr_++);
+                    bol = (index == '\n') ? true : false;
+                    std::size_t const state_ = ptr_[
+                        lookup_[static_cast<std::size_t>(index)]];
+
+                    if (state_ == 0)
+                    {
+                        break;
+                    }
+
+                    ptr_ = &dfa_[state_ * dfa_alphabet_];
+                }
+
+                if (*ptr_)
+                {
+                    end_state_ = true;
+                    id_ = *(ptr_ + boost::lexer::id_index);
+                    uid_ = *(ptr_ + boost::lexer::unique_id_index);
+                    end_bol_ = bol;
+                    end_token_ = curr_;
+                }
+            }
+
+            std::size_t const EOL_state_ = ptr_[boost::lexer::eol_index];
+
+            if (EOL_state_ && curr_ == end_)
+            {
+                ptr_ = &dfa_[EOL_state_ * dfa_alphabet_];
+
+                if (*ptr_)
+                {
+                    end_state_ = true;
+                    id_ = *(ptr_ + boost::lexer::id_index);
+                    uid_ = *(ptr_ + boost::lexer::unique_id_index);
+                    end_bol_ = bol;
+                    end_token_ = curr_;
+                }
+            }
+
+            if (end_state_) {
+                // return longest match
+                bol_ = end_bol_;
+                start_token_ = end_token_;
+            }
+            else {
+                bol_ = *start_token_ == '\n';
+                id_ = boost::lexer::npos;
+                uid_ = boost::lexer::npos;
+            }
+
+            unique_id_ = uid_;
+            return id_;
+        }
+    };
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/lexer.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/lexer.hpp
new file mode 100644
index 0000000..0f8af55
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/lexer.hpp
@@ -0,0 +1,399 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_MAR_17_2007_0139PM)
+#define BOOST_SPIRIT_LEX_LEXER_MAR_17_2007_0139PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <iosfwd>
+
+#include <boost/spirit/home/support/detail/lexer/generator.hpp>
+#include <boost/spirit/home/support/detail/lexer/rules.hpp>
+#include <boost/spirit/home/support/detail/lexer/consts.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+
+#include <boost/spirit/home/lex/lexer/lexertl/token.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/functor.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/functor_data.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/iterator.hpp>
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+#include <boost/spirit/home/support/detail/lexer/debug.hpp>
+#endif
+
+#include <boost/foreach.hpp>
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////
+        //  The must_escape function checks if the given character value needs
+        //  to be preceded by a backslash character to disable its special
+        //  meaning in the context of a regular expression
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Char>
+        inline bool must_escape(Char c)
+        {
+            // FIXME: more needed?
+            switch (c) {
+            case '+': case '/': case '*': case '?':
+            case '|':
+            case '(': case ')':
+            case '[': case ']':
+            case '{': case '}':
+            case '.':
+            case '^': case '$':
+            case '\\':
+            case '"':
+                return true;
+
+            default:
+                break;
+            }
+            return false;
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        //  The escape function returns the string representation of the given
+        //  character value, possibly escaped with a backslash character, to
+        //  allow it being safely used in a regular expression definition.
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Char>
+        inline std::basic_string<Char> escape(Char ch)
+        {
+            std::basic_string<Char> result(1, ch);
+            if (detail::must_escape(ch))
+            {
+                typedef typename std::basic_string<Char>::size_type size_type;
+                result.insert((size_type)0, 1, '\\');
+            }
+            return result;
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        //
+        ///////////////////////////////////////////////////////////////////////
+        inline boost::lexer::regex_flags map_flags(unsigned int flags)
+        {
+            unsigned int retval = boost::lexer::none;
+            if (flags & match_flags::match_not_dot_newline)
+                retval |= boost::lexer::dot_not_newline;
+            if (flags & match_flags::match_icase)
+                retval |= boost::lexer::icase;
+
+            return boost::lexer::regex_flags(retval);
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Lexer, typename F>
+    bool generate_static(Lexer const&
+      , std::basic_ostream<typename Lexer::char_type>&
+      , typename Lexer::char_type const*, F);
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  Every lexer type to be used as a lexer for Spirit has to conform to
+    //  the following public interface:
+    //
+    //    typedefs:
+    //        iterator_type   The type of the iterator exposed by this lexer.
+    //        token_type      The type of the tokens returned from the exposed
+    //                        iterators.
+    //
+    //    functions:
+    //        default constructor
+    //                        Since lexers are instantiated as base classes
+    //                        only it might be a good idea to make this
+    //                        constructor protected.
+    //        begin, end      Return a pair of iterators, when dereferenced
+    //                        returning the sequence of tokens recognized in
+    //                        the input stream given as the parameters to the
+    //                        begin() function.
+    //        add_token       Should add the definition of a token to be
+    //                        recognized by this lexer.
+    //        clear           Should delete all current token definitions
+    //                        associated with the given state of this lexer
+    //                        object.
+    //
+    //    template parameters:
+    //        Iterator        The type of the iterator used to access the
+    //                        underlying character stream.
+    //        Token           The type of the tokens to be returned from the
+    //                        exposed token iterator.
+    //        Functor         The type of the InputPolicy to use to instantiate
+    //                        the multi_pass iterator type to be used as the
+    //                        token iterator (returned from begin()/end()).
+    //
+    ///////////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The lexer class is a implementation of a Spirit.Lex lexer on
+    //  top of Ben Hanson's lexertl library as outlined above (For more
+    //  information about lexertl go here: http://www.benhanson.net/lexertl.html).
+    //
+    //  This class is supposed to be used as the first and only template
+    //  parameter while instantiating instances of a lex::lexer class.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Token = token<>
+      , typename Iterator = typename Token::iterator_type
+      , typename Functor = functor<Token, lexertl::detail::data, Iterator> >
+    class lexer
+    {
+    private:
+        struct dummy { void true_() {} };
+        typedef void (dummy::*safe_bool)();
+
+        static std::size_t const all_states_id = static_cast<std::size_t>(-2);
+
+    public:
+        operator safe_bool() const
+            { return initialized_dfa_ ? &dummy::true_ : 0; }
+
+        typedef typename boost::detail::iterator_traits<Iterator>::value_type
+            char_type;
+        typedef std::basic_string<char_type> string_type;
+
+        typedef boost::lexer::basic_rules<char_type> basic_rules_type;
+
+        //  Every lexer type to be used as a lexer for Spirit has to conform to
+        //  a public interface .
+        typedef Token token_type;
+        typedef typename Token::id_type id_type;
+        typedef iterator<Functor> iterator_type;
+
+    private:
+        // this type is purely used for the iterator_type construction below
+        struct iterator_data_type
+        {
+            typedef typename Functor::semantic_actions_type semantic_actions_type;
+
+            iterator_data_type(
+                    boost::lexer::basic_state_machine<char_type> const& sm
+                  , boost::lexer::basic_rules<char_type> const& rules
+                  , semantic_actions_type const& actions)
+              : state_machine_(sm), rules_(rules), actions_(actions)
+            {}
+
+            boost::lexer::basic_state_machine<char_type> const& state_machine_;
+            boost::lexer::basic_rules<char_type> const& rules_;
+            semantic_actions_type const& actions_;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            iterator_data_type& operator= (iterator_data_type const&);
+        };
+
+    public:
+        //  Return the start iterator usable for iterating over the generated
+        //  tokens.
+        iterator_type begin(Iterator& first, Iterator const& last
+          , char_type const* initial_state = 0) const
+        {
+            if (!init_dfa())    // never minimize DFA for dynamic lexers
+                return iterator_type();
+
+            iterator_data_type iterator_data(state_machine_, rules_, actions_);
+            return iterator_type(iterator_data, first, last, initial_state);
+        }
+
+        //  Return the end iterator usable to stop iterating over the generated
+        //  tokens.
+        iterator_type end() const
+        {
+            return iterator_type();
+        }
+
+    protected:
+        //  Lexer instances can be created by means of a derived class only.
+        lexer(unsigned int flags)
+          : flags_(detail::map_flags(flags))
+          , rules_(flags_)
+          , initialized_dfa_(false)
+        {}
+
+    public:
+        // interface for token definition management
+        std::size_t add_token(char_type const* state, char_type tokendef,
+            std::size_t token_id, char_type const* targetstate)
+        {
+            add_state(state);
+            initialized_dfa_ = false;
+            if (state == all_states())
+                return rules_.add(state, detail::escape(tokendef), token_id, rules_.dot());
+
+            if (0 == targetstate)
+                targetstate = state;
+            else
+                add_state(targetstate);
+            return rules_.add(state, detail::escape(tokendef), token_id, targetstate);
+        }
+        std::size_t add_token(char_type const* state, string_type const& tokendef,
+            std::size_t token_id, char_type const* targetstate)
+        {
+            add_state(state);
+            initialized_dfa_ = false;
+            if (state == all_states())
+                return rules_.add(state, tokendef, token_id, rules_.dot());
+
+            if (0 == targetstate)
+                targetstate = state;
+            else
+                add_state(targetstate);
+            return rules_.add(state, tokendef, token_id, targetstate);
+        }
+
+        // interface for pattern definition management
+        void add_pattern (char_type const* state, string_type const& name,
+            string_type const& patterndef)
+        {
+            add_state(state);
+            rules_.add_macro(name.c_str(), patterndef);
+            initialized_dfa_ = false;
+        }
+
+        boost::lexer::rules const& get_rules() const { return rules_; }
+
+        void clear(char_type const* state)
+        {
+            std::size_t s = rules_.state(state);
+            if (boost::lexer::npos != s)
+                rules_.clear(state);
+            initialized_dfa_ = false;
+        }
+        std::size_t add_state(char_type const* state)
+        {
+            if (state == all_states())
+                return all_states_id;
+
+            std::size_t stateid = rules_.state(state);
+            if (boost::lexer::npos == stateid) {
+                stateid = rules_.add_state(state);
+                initialized_dfa_ = false;
+            }
+            return stateid;
+        }
+        string_type initial_state() const
+        {
+            return string_type(rules_.initial());
+        }
+        string_type all_states() const
+        {
+            return string_type(rules_.all_states());
+        }
+
+        //  Register a semantic action with the given id
+        template <typename F>
+        void add_action(std::size_t unique_id, std::size_t state, F act)
+        {
+            // If you see an error here stating add_action is not a member of
+            // fusion::unused_type then you are probably having semantic actions
+            // attached to at least one token in the lexer definition without
+            // using the lex::lexertl::actor_lexer<> as its base class.
+            typedef typename Functor::wrap_action_type wrapper_type;
+            if (state == all_states_id) {
+                // add the action to all known states
+                typedef typename
+                    basic_rules_type::string_size_t_map::value_type
+                state_type;
+
+                std::size_t states = rules_.statemap().size();
+                BOOST_FOREACH(state_type const& s, rules_.statemap()) {
+                    for (std::size_t j = 0; j < states; ++j)
+                        actions_.add_action(unique_id + j, s.second, wrapper_type::call(act));
+                }
+            }
+            else {
+                actions_.add_action(unique_id, state, wrapper_type::call(act));
+            }
+        }
+//         template <typename F>
+//         void add_action(std::size_t unique_id, char_type const* state, F act)
+//         {
+//             typedef typename Functor::wrap_action_type wrapper_type;
+//             actions_.add_action(unique_id, add_state(state), wrapper_type::call(act));
+//         }
+
+        // We do not minimize the state machine by default anymore because
+        // Ben said: "If you can afford to generate a lexer at runtime, there
+        //            is little point in calling minimise."
+        // Go figure.
+        bool init_dfa(bool minimize = false) const
+        {
+            if (!initialized_dfa_) {
+                state_machine_.clear();
+                typedef boost::lexer::basic_generator<char_type> generator;
+                generator::build (rules_, state_machine_);
+                if (minimize)
+                    generator::minimise (state_machine_);
+
+#if defined(BOOST_SPIRIT_LEXERTL_DEBUG)
+                boost::lexer::debug::dump(state_machine_, std::cerr);
+#endif
+                initialized_dfa_ = true;
+
+//                 // release memory held by rules description
+//                 basic_rules_type rules;
+//                 rules.init_state_info(rules_);        // preserve states
+//                 std::swap(rules, rules_);
+            }
+            return true;
+        }
+
+    private:
+        // lexertl specific data
+        mutable boost::lexer::basic_state_machine<char_type> state_machine_;
+        boost::lexer::regex_flags flags_;
+        /*mutable*/ basic_rules_type rules_;
+
+        typename Functor::semantic_actions_type actions_;
+        mutable bool initialized_dfa_;
+
+        // generator functions must be able to access members directly
+        template <typename Lexer, typename F>
+        friend bool generate_static(Lexer const&
+          , std::basic_ostream<typename Lexer::char_type>&
+          , typename Lexer::char_type const*, F);
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The actor_lexer class is another implementation of a Spirit.Lex
+    //  lexer on top of Ben Hanson's lexertl library as outlined above (For
+    //  more information about lexertl go here:
+    //  http://www.benhanson.net/lexertl.html).
+    //
+    //  The only difference to the lexer class above is that token_def
+    //  definitions may have semantic (lexer) actions attached while being
+    //  defined:
+    //
+    //      int w;
+    //      token_def word = "[^ \t\n]+";
+    //      self = word[++ref(w)];        // see example: word_count_lexer
+    //
+    //  This class is supposed to be used as the first and only template
+    //  parameter while instantiating instances of a lex::lexer class.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Token = token<>
+      , typename Iterator = typename Token::iterator_type
+      , typename Functor = functor<Token, lexertl::detail::data, Iterator, mpl::true_> >
+    class actor_lexer : public lexer<Token, Iterator, Functor>
+    {
+    protected:
+        //  Lexer instances can be created by means of a derived class only.
+        actor_lexer(unsigned int flags)
+          : lexer<Token, Iterator, Functor>(flags) {}
+    };
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/semantic_action_data.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/semantic_action_data.hpp
new file mode 100644
index 0000000..30748c5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/semantic_action_data.hpp
@@ -0,0 +1,121 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXER_SEMANTIC_ACTION_DATA_JUN_10_2009_0417PM)
+#define BOOST_SPIRIT_LEX_LEXER_SEMANTIC_ACTION_DATA_JUN_10_2009_0417PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/function.hpp>
+#include <vector>
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Iterator, typename SupportsState, typename Data>
+        struct semantic_actions;
+
+        // This specialization of semantic_actions will be used if the token
+        // type (lexer definition) does not support states, which simplifies 
+        // the data structures used to store the semantic action function 
+        // objects.
+        template <typename Iterator, typename Data>
+        struct semantic_actions<Iterator, mpl::false_, Data>
+        {
+            typedef void functor_type(Iterator&, Iterator&
+              , BOOST_SCOPED_ENUM(pass_flags)&, std::size_t&, Data&);
+            typedef boost::function<functor_type> functor_wrapper_type;
+
+            // add a semantic action function object
+            template <typename F>
+            void add_action(std::size_t unique_id, std::size_t, F act) 
+            {
+                if (actions_.size() <= unique_id)
+                    actions_.resize(unique_id + 1); 
+
+                actions_[unique_id] = act;
+            }
+
+            // try to invoke a semantic action for the given token (unique_id)
+            BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t /*state*/
+              , std::size_t& id, std::size_t unique_id, Iterator& end
+              , Data& data) const
+            {
+                // if there is nothing to invoke, continue with 'match'
+                if (unique_id >= actions_.size() || !actions_[unique_id]) 
+                    return pass_flags::pass_normal;
+
+                // Note: all arguments might be changed by the invoked semantic 
+                //       action
+                BOOST_SCOPED_ENUM(pass_flags) match = pass_flags::pass_normal;
+                actions_[unique_id](data.get_first(), end, match, id, data);
+                return match;
+            }
+
+            std::vector<functor_wrapper_type> actions_;
+        }; 
+
+        // This specialization of semantic_actions will be used if the token
+        // type (lexer definition) needs to support states, resulting in a more
+        // complex data structure needed for storing the semantic action 
+        // function objects.
+        template <typename Iterator, typename Data>
+        struct semantic_actions<Iterator, mpl::true_, Data>
+        {
+            typedef void functor_type(Iterator&, Iterator&
+              , BOOST_SCOPED_ENUM(pass_flags)&, std::size_t&, Data&);
+            typedef boost::function<functor_type> functor_wrapper_type;
+
+            // add a semantic action function object
+            template <typename F>
+            void add_action(std::size_t unique_id, std::size_t state, F act) 
+            {
+                if (actions_.size() <= state)
+                    actions_.resize(state + 1); 
+
+                std::vector<functor_wrapper_type>& actions (actions_[state]);
+                if (actions.size() <= unique_id)
+                    actions.resize(unique_id + 1); 
+
+                actions[unique_id] = act;
+            }
+
+            // try to invoke a semantic action for the given token (unique_id)
+            BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t state
+              , std::size_t& id, std::size_t unique_id, Iterator& end
+              , Data& data) const
+            {
+                // if there is no action defined for this state, return match
+                if (state >= actions_.size())
+                    return pass_flags::pass_normal;
+
+                // if there is nothing to invoke, continue with 'match'
+                std::vector<functor_wrapper_type> const& actions = actions_[state];
+                if (unique_id >= actions.size() || !actions[unique_id]) 
+                    return pass_flags::pass_normal;
+
+                // set token value 
+                data.set_end(end);
+
+                // Note: all arguments might be changed by the invoked semantic 
+                //       action
+                BOOST_SCOPED_ENUM(pass_flags) match = pass_flags::pass_normal;
+                actions[unique_id](data.get_first(), end, match, id, data);
+                return match;
+            }
+
+            std::vector<std::vector<functor_wrapper_type> > actions_;
+        }; 
+    }
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp
new file mode 100644
index 0000000..90961af
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp
@@ -0,0 +1,654 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_TOKEN_FEB_10_2008_0751PM)
+#define BOOST_SPIRIT_LEX_TOKEN_FEB_10_2008_0751PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/spirit/home/support/attributes.hpp>
+#include <boost/spirit/home/support/argument.hpp>
+#include <boost/spirit/home/support/detail/lexer/generator.hpp>
+#include <boost/spirit/home/support/detail/lexer/rules.hpp>
+#include <boost/spirit/home/support/detail/lexer/consts.hpp>
+#include <boost/spirit/home/support/utree/utree_traits_fwd.hpp>
+#include <boost/spirit/home/lex/lexer/terminals.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/value_at.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/variant.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/range/iterator_range.hpp>
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#include <boost/static_assert.hpp>
+#endif
+
+#if defined(BOOST_SPIRIT_DEBUG)
+#include <iosfwd>
+#endif
+
+namespace boost { namespace spirit { namespace lex { namespace lexertl
+{ 
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The token is the type of the objects returned by default by the 
+    //  iterator.
+    //
+    //    template parameters:
+    //        Iterator        The type of the iterator used to access the
+    //                        underlying character stream.
+    //        AttributeTypes  A mpl sequence containing the types of all 
+    //                        required different token values to be supported 
+    //                        by this token type.
+    //        HasState        A mpl::bool_ indicating, whether this token type
+    //                        should support lexer states.
+    //        Idtype          The type to use for the token id (defaults to 
+    //                        std::size_t).
+    //
+    //  It is possible to use other token types with the spirit::lex 
+    //  framework as well. If you plan to use a different type as your token 
+    //  type, you'll need to expose the following things from your token type 
+    //  to make it compatible with spirit::lex:
+    //
+    //    typedefs
+    //        iterator_type   The type of the iterator used to access the
+    //                        underlying character stream.
+    //
+    //        id_type         The type of the token id used.
+    //
+    //    methods
+    //        default constructor
+    //                        This should initialize the token as an end of 
+    //                        input token.
+    //        constructors    The prototype of the other required 
+    //                        constructors should be:
+    //
+    //              token(int)
+    //                        This constructor should initialize the token as 
+    //                        an invalid token (not carrying any specific 
+    //                        values)
+    //
+    //              where:  the int is used as a tag only and its value is 
+    //                      ignored
+    //
+    //                        and:
+    //
+    //              token(Idtype id, std::size_t state, 
+    //                    iterator_type first, iterator_type last);
+    //
+    //              where:  id:           token id
+    //                      state:        lexer state this token was matched in
+    //                      first, last:  pair of iterators marking the matched 
+    //                                    range in the underlying input stream 
+    //
+    //        accessors
+    //              id()      return the token id of the matched input sequence
+    //              id(newid) set the token id of the token instance
+    //
+    //              state()   return the lexer state this token was matched in
+    //
+    //              value()   return the token value
+    //
+    //  Additionally, you will have to implement a couple of helper functions
+    //  in the same namespace as the token type: a comparison operator==() to 
+    //  compare your token instances, a token_is_valid() function and different 
+    //  specializations of the Spirit customization point 
+    //  assign_to_attribute_from_value as shown below.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator = char const*
+      , typename AttributeTypes = mpl::vector0<>
+      , typename HasState = mpl::true_
+      , typename Idtype = std::size_t> 
+    struct token;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This specialization of the token type doesn't contain any item data and
+    //  doesn't support working with lexer states.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Idtype>
+    struct token<Iterator, lex::omit, mpl::false_, Idtype>
+    {
+        typedef Iterator iterator_type;
+        typedef mpl::false_ has_state;
+        typedef Idtype id_type;
+        typedef unused_type token_value_type;
+
+        //  default constructed tokens correspond to EOI tokens
+        token() : id_(id_type(boost::lexer::npos)) {}
+
+        //  construct an invalid token
+        explicit token(int) : id_(id_type(0)) {}
+
+        token(id_type id, std::size_t) : id_(id) {}
+
+        token(id_type id, std::size_t, token_value_type)
+          : id_(id) {}
+
+        token_value_type& value() { static token_value_type u; return u; }
+        token_value_type const& value() const { return unused; }
+
+#if defined(BOOST_SPIRIT_DEBUG)
+        token(id_type id, std::size_t, Iterator const& first
+              , Iterator const& last)
+          : matched_(first, last)
+          , id_(id) {}
+#else
+        token(id_type id, std::size_t, Iterator const&, Iterator const&)
+          : id_(id) {}
+#endif
+
+        //  this default conversion operator is needed to allow the direct 
+        //  usage of tokens in conjunction with the primitive parsers defined 
+        //  in Qi
+        operator id_type() const { return id_; }
+
+        //  Retrieve or set the token id of this token instance. 
+        id_type id() const { return id_; }
+        void id(id_type newid) { id_ = newid; }
+
+        std::size_t state() const { return 0; }   // always '0' (INITIAL state)
+
+        bool is_valid() const 
+        { 
+            return 0 != id_ && id_type(boost::lexer::npos) != id_; 
+        }
+
+#if defined(BOOST_SPIRIT_DEBUG)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+        // workaround for MSVC10 which has problems copying a default 
+        // constructed iterator_range
+        token& operator= (token const& rhs)
+        {
+            if (this != &rhs) 
+            {
+                id_ = rhs.id_;
+                if (is_valid()) 
+                    matched_ = rhs.matched_;
+            }
+            return *this;
+        }
+#endif
+        std::pair<Iterator, Iterator> matched_;
+#endif
+
+    protected:
+        id_type id_;            // token id, 0 if nothing has been matched
+    };
+
+#if defined(BOOST_SPIRIT_DEBUG)
+    template <typename Char, typename Traits, typename Iterator
+      , typename AttributeTypes, typename HasState, typename Idtype> 
+    inline std::basic_ostream<Char, Traits>& 
+    operator<< (std::basic_ostream<Char, Traits>& os
+      , token<Iterator, AttributeTypes, HasState, Idtype> const& t)
+    {
+        if (t.is_valid()) {
+            Iterator end = t.matched_.second;
+            for (Iterator it = t.matched_.first; it != end; ++it)
+                os << *it;
+        }
+        else {
+            os << "<invalid token>";
+        }
+        return os;
+    }
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This specialization of the token type doesn't contain any item data but
+    //  supports working with lexer states.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Idtype>
+    struct token<Iterator, lex::omit, mpl::true_, Idtype>
+      : token<Iterator, lex::omit, mpl::false_, Idtype>
+    {
+    private:
+        typedef token<Iterator, lex::omit, mpl::false_, Idtype> base_type;
+
+    public:
+        typedef typename base_type::id_type id_type;
+        typedef Iterator iterator_type;
+        typedef mpl::true_ has_state;
+        typedef unused_type token_value_type;
+
+        //  default constructed tokens correspond to EOI tokens
+        token() : state_(boost::lexer::npos) {}
+
+        //  construct an invalid token
+        explicit token(int) : base_type(0), state_(boost::lexer::npos) {}
+
+        token(id_type id, std::size_t state)
+          : base_type(id, boost::lexer::npos), state_(state) {}
+
+        token(id_type id, std::size_t state, token_value_type)
+          : base_type(id, boost::lexer::npos, unused)
+          , state_(state) {}
+
+        token(id_type id, std::size_t state
+              , Iterator const& first, Iterator const& last)
+          : base_type(id, boost::lexer::npos, first, last)
+          , state_(state) {}
+
+        std::size_t state() const { return state_; }
+
+#if defined(BOOST_SPIRIT_DEBUG) && BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+        // workaround for MSVC10 which has problems copying a default 
+        // constructed iterator_range
+        token& operator= (token const& rhs)
+        {
+            if (this != &rhs) 
+            {
+                this->base_type::operator=(static_cast<base_type const&>(rhs));
+                state_ = rhs.state_;
+            }
+            return *this;
+        }
+#endif
+
+    protected:
+        std::size_t state_;      // lexer state this token was matched in
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The generic version of the token type derives from the 
+    //  specialization above and adds a single data member holding the item 
+    //  data carried by the token instance.
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////
+        //  Meta-function to calculate the type of the variant data item to be 
+        //  stored with each token instance.
+        //
+        //  Note: The iterator pair needs to be the first type in the list of 
+        //        types supported by the generated variant type (this is being 
+        //        used to identify whether the stored data item in a particular 
+        //        token instance needs to be converted from the pair of 
+        //        iterators (see the first of the assign_to_attribute_from_value 
+        //        specializations below).
+        ///////////////////////////////////////////////////////////////////////
+        template <typename IteratorPair, typename AttributeTypes>
+        struct token_value_typesequence
+        {
+            typedef typename mpl::insert<
+                AttributeTypes
+              , typename mpl::begin<AttributeTypes>::type
+              , IteratorPair
+            >::type sequence_type;
+            typedef typename make_variant_over<sequence_type>::type type;
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  The type of the data item stored with a token instance is defined 
+        //  by the template parameter 'AttributeTypes' and may be:
+        //  
+        //     lex::omit:         no data item is stored with the token 
+        //                        instance (this is handled by the 
+        //                        specializations of the token class
+        //                        below)
+        //     mpl::vector0<>:    each token instance stores a pair of 
+        //                        iterators pointing to the matched input 
+        //                        sequence
+        //     mpl::vector<...>:  each token instance stores a variant being 
+        //                        able to store the pair of iterators pointing 
+        //                        to the matched input sequence, or any of the 
+        //                        types a specified in the mpl::vector<>
+        //
+        //  All this is done to ensure the token type is as small (in terms 
+        //  of its byte-size) as possible.
+        ///////////////////////////////////////////////////////////////////////
+        template <typename IteratorPair, typename AttributeTypes>
+        struct token_value_type
+          : mpl::eval_if<
+                mpl::or_<
+                    is_same<AttributeTypes, mpl::vector0<> >
+                  , is_same<AttributeTypes, mpl::vector<> > >
+              , mpl::identity<IteratorPair>
+              , token_value_typesequence<IteratorPair, AttributeTypes> >
+        {};
+    }
+
+    template <typename Iterator, typename AttributeTypes, typename HasState
+      , typename Idtype>
+    struct token : token<Iterator, lex::omit, HasState, Idtype>
+    {
+    private: // precondition assertions
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+        BOOST_STATIC_ASSERT((mpl::is_sequence<AttributeTypes>::value || 
+                            is_same<AttributeTypes, lex::omit>::value));
+#endif
+        typedef token<Iterator, lex::omit, HasState, Idtype> base_type;
+
+    protected: 
+        //  If no additional token value types are given, the the token will 
+        //  hold the plain pair of iterators pointing to the matched range
+        //  in the underlying input sequence. Otherwise the token value is 
+        //  stored as a variant and will again hold the pair of iterators but
+        //  is able to hold any of the given data types as well. The conversion 
+        //  from the iterator pair to the required data type is done when it is
+        //  accessed for the first time.
+        typedef iterator_range<Iterator> iterpair_type;
+
+    public:
+        typedef typename base_type::id_type id_type;
+        typedef typename detail::token_value_type<
+            iterpair_type, AttributeTypes
+        >::type token_value_type;
+
+        typedef Iterator iterator_type;
+
+        //  default constructed tokens correspond to EOI tokens
+        token() : value_(iterpair_type(iterator_type(), iterator_type())) {}
+
+        //  construct an invalid token
+        explicit token(int)
+          : base_type(0)
+          , value_(iterpair_type(iterator_type(), iterator_type())) {}
+
+        token(id_type id, std::size_t state, token_value_type const& value)
+          : base_type(id, state, value)
+          , value_(value) {}
+
+        token(id_type id, std::size_t state, Iterator const& first
+              , Iterator const& last)
+          : base_type(id, state, first, last)
+          , value_(iterpair_type(first, last)) {}
+
+        token_value_type& value() { return value_; }
+        token_value_type const& value() const { return value_; }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+        // workaround for MSVC10 which has problems copying a default 
+        // constructed iterator_range
+        token& operator= (token const& rhs)
+        {
+            if (this != &rhs) 
+            {
+                this->base_type::operator=(static_cast<base_type const&>(rhs));
+                if (this->is_valid()) 
+                    value_ = rhs.value_;
+            }
+            return *this;
+        }
+#endif
+
+    protected:
+        token_value_type value_; // token value, by default a pair of iterators
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  tokens are considered equal, if their id's match (these are unique)
+    template <typename Iterator, typename AttributeTypes, typename HasState
+      , typename Idtype>
+    inline bool 
+    operator== (token<Iterator, AttributeTypes, HasState, Idtype> const& lhs, 
+                token<Iterator, AttributeTypes, HasState, Idtype> const& rhs)
+    {
+        return lhs.id() == rhs.id();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This overload is needed by the multi_pass/functor_input_policy to 
+    //  validate a token instance. It has to be defined in the same namespace 
+    //  as the token class itself to allow ADL to find it.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename AttributeTypes, typename HasState
+      , typename Idtype>
+    inline bool 
+    token_is_valid(token<Iterator, AttributeTypes, HasState, Idtype> const& t)
+    {
+        return t.is_valid();
+    }
+}}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  We have to provide specializations for the customization point
+    //  assign_to_attribute_from_value allowing to extract the needed value 
+    //  from the token. 
+    ///////////////////////////////////////////////////////////////////////////
+
+    //  This is called from the parse function of token_def if the token_def
+    //  has been defined to carry a special attribute type
+    template <typename Attribute, typename Iterator, typename AttributeTypes
+      , typename HasState, typename Idtype>
+    struct assign_to_attribute_from_value<Attribute
+      , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+    {
+        static void 
+        call(lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> const& t
+          , Attribute& attr)
+        {
+        //  The goal of this function is to avoid the conversion of the pair of
+        //  iterators (to the matched character sequence) into the token value 
+        //  of the required type being done more than once. For this purpose it 
+        //  checks whether the stored value type is still the default one (pair 
+        //  of iterators) and if yes, replaces the pair of iterators with the 
+        //  converted value to be returned from subsequent calls.
+
+            if (0 == t.value().which()) {
+            //  first access to the token value
+                typedef iterator_range<Iterator> iterpair_type;
+                iterpair_type const& ip = boost::get<iterpair_type>(t.value());
+
+            // Interestingly enough we use the assign_to() framework defined in 
+            // Spirit.Qi allowing to convert the pair of iterators to almost any 
+            // required type (assign_to(), if available, uses the standard Spirit 
+            // parsers to do the conversion).
+                spirit::traits::assign_to(ip.begin(), ip.end(), attr);
+
+            //  If you get an error during the compilation of the following 
+            //  assignment expression, you probably forgot to list one or more 
+            //  types used as token value types (in your token_def<...> 
+            //  definitions) in your definition of the token class. I.e. any token 
+            //  value type used for a token_def<...> definition has to be listed 
+            //  during the declaration of the token type to use. For instance let's 
+            //  assume we have two token_def's:
+            //
+            //      token_def<int> number; number = "...";
+            //      token_def<std::string> identifier; identifier = "...";
+            //
+            //  Then you'll have to use the following token type definition 
+            //  (assuming you are using the token class):
+            //
+            //      typedef mpl::vector<int, std::string> token_values;
+            //      typedef token<base_iter_type, token_values> token_type;
+            //
+            //  where: base_iter_type is the iterator type used to expose the 
+            //         underlying input stream.
+            //
+            //  This token_type has to be used as the second template parameter 
+            //  to the lexer class:
+            //
+            //      typedef lexer<base_iter_type, token_type> lexer_type;
+            //
+            //  again, assuming you're using the lexer<> template for your 
+            //  tokenization.
+
+                typedef lex::lexertl::token<
+                    Iterator, AttributeTypes, HasState, Idtype> token_type;
+                spirit::traits::assign_to(
+                    attr, const_cast<token_type&>(t).value());   // re-assign value
+            }
+            else {
+            // reuse the already assigned value
+                spirit::traits::assign_to(boost::get<Attribute>(t.value()), attr);
+            }
+        }
+    };
+
+    template <typename Attribute, typename Iterator, typename AttributeTypes
+      , typename HasState, typename Idtype>
+    struct assign_to_container_from_value<Attribute
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+      : assign_to_attribute_from_value<Attribute
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+    {};
+
+    template <typename Iterator, typename AttributeTypes
+      , typename HasState, typename Idtype>
+    struct assign_to_container_from_value<utree
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+      : assign_to_attribute_from_value<utree
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+    {};
+
+    template <typename Iterator>
+    struct assign_to_container_from_value<
+        iterator_range<Iterator>, iterator_range<Iterator> >
+    {
+        static void 
+        call(iterator_range<Iterator> const& val, iterator_range<Iterator>& attr)
+        {
+            attr = val;
+        }
+    };
+
+    //  These are called from the parse function of token_def if the token type
+    //  has no special attribute type assigned 
+    template <typename Attribute, typename Iterator, typename HasState
+      , typename Idtype>
+    struct assign_to_attribute_from_value<Attribute
+      , lex::lexertl::token<Iterator, mpl::vector0<>, HasState, Idtype> >
+    {
+        static void 
+        call(lex::lexertl::token<Iterator, mpl::vector0<>, HasState, Idtype> const& t
+          , Attribute& attr)
+        {
+            //  The default type returned by the token_def parser component (if 
+            //  it has no token value type assigned) is the pair of iterators 
+            //  to the matched character sequence.
+            spirit::traits::assign_to(t.value().begin(), t.value().end(), attr);
+        }
+    };
+
+//     template <typename Attribute, typename Iterator, typename HasState
+//       , typename Idtype>
+//     struct assign_to_container_from_value<Attribute
+//           , lex::lexertl::token<Iterator, mpl::vector0<>, HasState, Idtype> >
+//       : assign_to_attribute_from_value<Attribute
+//           , lex::lexertl::token<Iterator, mpl::vector0<>, HasState, Idtype> >
+//     {};
+
+    // same as above but using mpl::vector<> instead of mpl::vector0<>
+    template <typename Attribute, typename Iterator, typename HasState
+      , typename Idtype>
+    struct assign_to_attribute_from_value<Attribute
+      , lex::lexertl::token<Iterator, mpl::vector<>, HasState, Idtype> >
+    {
+        static void 
+        call(lex::lexertl::token<Iterator, mpl::vector<>, HasState, Idtype> const& t
+          , Attribute& attr)
+        {
+            //  The default type returned by the token_def parser component (if 
+            //  it has no token value type assigned) is the pair of iterators 
+            //  to the matched character sequence.
+            spirit::traits::assign_to(t.value().begin(), t.value().end(), attr);
+        }
+    };
+
+//     template <typename Attribute, typename Iterator, typename HasState
+//       , typename Idtype>
+//     struct assign_to_container_from_value<Attribute
+//           , lex::lexertl::token<Iterator, mpl::vector<>, HasState, Idtype> >
+//       : assign_to_attribute_from_value<Attribute
+//           , lex::lexertl::token<Iterator, mpl::vector<>, HasState, Idtype> >
+//     {};
+
+    //  This is called from the parse function of token_def if the token type
+    //  has been explicitly omitted (i.e. no attribute value is used), which
+    //  essentially means that every attribute gets initialized using default 
+    //  constructed values.
+    template <typename Attribute, typename Iterator, typename HasState
+      , typename Idtype>
+    struct assign_to_attribute_from_value<Attribute
+      , lex::lexertl::token<Iterator, lex::omit, HasState, Idtype> >
+    {
+        static void 
+        call(lex::lexertl::token<Iterator, lex::omit, HasState, Idtype> const& t
+          , Attribute& attr)
+        {
+            // do nothing
+        }
+    };
+
+    template <typename Attribute, typename Iterator, typename HasState
+      , typename Idtype>
+    struct assign_to_container_from_value<Attribute
+          , lex::lexertl::token<Iterator, lex::omit, HasState, Idtype> >
+      : assign_to_attribute_from_value<Attribute
+          , lex::lexertl::token<Iterator, lex::omit, HasState, Idtype> >
+    {};
+
+    //  This is called from the parse function of lexer_def_
+    template <typename Iterator, typename AttributeTypes, typename HasState
+      , typename Idtype_, typename Idtype>
+    struct assign_to_attribute_from_value<
+        fusion::vector2<Idtype_, iterator_range<Iterator> >
+      , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+    {
+        static void 
+        call(lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> const& t
+          , fusion::vector2<Idtype_, iterator_range<Iterator> >& attr)
+        {
+            //  The type returned by the lexer_def_ parser components is a 
+            //  fusion::vector containing the token id of the matched token 
+            //  and the pair of iterators to the matched character sequence.
+            typedef iterator_range<Iterator> iterpair_type;
+            typedef fusion::vector2<Idtype_, iterator_range<Iterator> > 
+                attribute_type;
+
+            iterpair_type const& ip = boost::get<iterpair_type>(t.value());
+            attr = attribute_type(t.id(), ip);
+        }
+    };
+
+    template <typename Iterator, typename AttributeTypes, typename HasState
+      , typename Idtype_, typename Idtype>
+    struct assign_to_container_from_value<
+            fusion::vector2<Idtype_, iterator_range<Iterator> >
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+      : assign_to_attribute_from_value<
+            fusion::vector2<Idtype_, iterator_range<Iterator> >
+          , lex::lexertl::token<Iterator, AttributeTypes, HasState, Idtype> >
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Overload debug output for a single token, this integrates lexer tokens 
+    // with Qi's simple_trace debug facilities
+    template <typename Iterator, typename Attribute, typename HasState
+      , typename Idtype>
+    struct token_printer_debug<
+        lex::lexertl::token<Iterator, Attribute, HasState, Idtype> >
+    {
+        typedef lex::lexertl::token<Iterator, Attribute, HasState, Idtype> token_type;
+
+        template <typename Out>
+        static void print(Out& out, token_type const& val) 
+        {
+            out << '[';
+            spirit::traits::print_token(out, val.value());
+            out << ']';
+        }
+    };
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp
new file mode 100644
index 0000000..e128d27
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp
@@ -0,0 +1,154 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_WRAP_ACTION_APR_19_2008_0103PM)
+#define BOOST_SPIRIT_WRAP_ACTION_APR_19_2008_0103PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/spirit/include/phoenix_scope.hpp>
+
+#include <boost/spirit/home/support/attributes.hpp>
+#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace lex { namespace lexertl 
+{ 
+    namespace detail
+    {
+        template <typename FunctionType, typename Iterator, typename Context
+          , typename IdType>
+        struct wrap_action
+        {
+            // plain functions with 5 arguments, function objects (including 
+            // phoenix actors) are not touched at all
+            template <typename F>
+            static FunctionType call(F const& f)
+            {
+                return f;
+            }
+
+            // semantic actions with 4 arguments
+            template <typename F>
+            static void arg4_action(F* f, Iterator& start, Iterator& end
+              , BOOST_SCOPED_ENUM(pass_flags)& pass, IdType& id
+              , Context const&)
+            {
+                f(start, end, pass, id);
+            }
+
+            template <typename A0, typename A1, typename A2, typename A3>
+            static FunctionType call(void (*f)(A0, A1, A2, A3))
+            {
+                void (*pf)(void(*)(A0, A1, A2, A3)
+                  , Iterator&, Iterator&, BOOST_SCOPED_ENUM(pass_flags)&
+                  , IdType&, Context const&) = &wrap_action::arg4_action;
+
+                using phoenix::arg_names::_1;
+                using phoenix::arg_names::_2;
+                using phoenix::arg_names::_3;
+                using phoenix::arg_names::_4;
+                using phoenix::arg_names::_5;
+                return phoenix::bind(pf, f, _1, _2, _3, _4, _5);
+            }
+
+            // semantic actions with 3 arguments
+            template <typename F>
+            static void arg3_action(F* f, Iterator& start, Iterator& end
+              , BOOST_SCOPED_ENUM(pass_flags)& pass, IdType
+              , Context const&)
+            {
+                f(start, end, pass);
+            }
+
+            template <typename A0, typename A1, typename A2>
+            static FunctionType call(void (*f)(A0, A1, A2))
+            {
+                void (*pf)(void(*)(A0, A1, A2), Iterator&, Iterator&
+                  , BOOST_SCOPED_ENUM(pass_flags)&, IdType
+                  , Context const&) = &wrap_action::arg3_action;
+
+                using phoenix::arg_names::_1;
+                using phoenix::arg_names::_2;
+                using phoenix::arg_names::_3;
+                using phoenix::arg_names::_4;
+                using phoenix::arg_names::_5;
+                return phoenix::bind(pf, f, _1, _2, _3, _4, _5);
+            }
+
+            // semantic actions with 2 arguments
+            template <typename F>
+            static void arg2_action(F* f, Iterator& start, Iterator& end
+              , BOOST_SCOPED_ENUM(pass_flags)&, IdType, Context const&)
+            {
+                f (start, end);
+            }
+
+            template <typename A0, typename A1>
+            static FunctionType call(void (*f)(A0, A1))
+            {
+                void (*pf)(void(*)(A0, A1), Iterator&, Iterator&
+                  , BOOST_SCOPED_ENUM(pass_flags)&
+                  , IdType, Context const&) = &wrap_action::arg2_action;
+
+                using phoenix::arg_names::_1;
+                using phoenix::arg_names::_2;
+                using phoenix::arg_names::_3;
+                using phoenix::arg_names::_4;
+                using phoenix::arg_names::_5;
+                return phoenix::bind(pf, f, _1, _2, _3, _4, _5);
+            }
+
+            // we assume that either both iterators are to be passed to the 
+            // semantic action or none iterator at all (i.e. it's not possible 
+            // to have a lexer semantic action function taking one arguments).
+
+            // semantic actions with 0 argument
+            template <typename F>
+            static void arg0_action(F* f, Iterator&, Iterator&
+              , BOOST_SCOPED_ENUM(pass_flags)&, IdType, Context const&)
+            {
+                f();
+            }
+
+            static FunctionType call(void (*f)())
+            {
+                void (*pf)(void(*)(), Iterator&, Iterator&
+                  , BOOST_SCOPED_ENUM(pass_flags)&
+                  , IdType, Context const&) = &arg0_action;
+
+                using phoenix::arg_names::_1;
+                using phoenix::arg_names::_2;
+                using phoenix::arg_names::_3;
+                using phoenix::arg_names::_4;
+                using phoenix::arg_names::_5;
+                return phoenix::bind(pf, f, _1, _2, _3, _4, _5);
+            }
+        };
+
+        // specialization allowing to skip wrapping for lexer types not 
+        // supporting semantic actions
+        template <typename Iterator, typename Context, typename Idtype>
+        struct wrap_action<unused_type, Iterator, Context, Idtype>
+        {
+            // plain function objects are not touched at all
+            template <typename F>
+            static F const& call(F const& f)
+            {
+                return f;
+            }
+        };
+    }
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/pass_flags.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/pass_flags.hpp
new file mode 100644
index 0000000..6cda3ba
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/pass_flags.hpp
@@ -0,0 +1,28 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_PASS_FLAGS_JUN_09_2009_0840PM)
+#define BOOST_SPIRIT_LEX_PASS_FLAGS_JUN_09_2009_0840PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    BOOST_SCOPED_ENUM_START(pass_flags) 
+    { 
+        pass_fail = 0,        // make the current match fail in retrospective
+        pass_normal = 1,      // continue normal token matching, that's the default 
+        pass_ignore = 2       // ignore the current token and start matching the next
+    };
+    BOOST_SCOPED_ENUM_END
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/sequence.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/sequence.hpp
new file mode 100644
index 0000000..b7fad61
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/sequence.hpp
@@ -0,0 +1,72 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(SPIRIT_LEX_SEQUENCE_MAR_28_2007_0610PM)
+#define SPIRIT_LEX_SEQUENCE_MAR_28_2007_0610PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/domain.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+#include <boost/spirit/home/lex/detail/sequence_function.hpp>
+#include <boost/fusion/include/any.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+    template <>
+    struct use_operator<lex::domain, proto::tag::bitwise_or>  // enables |
+      : mpl::true_ {};
+
+    template <>
+    struct flatten_tree<lex::domain, proto::tag::bitwise_or>  // flattens |
+      : mpl::true_ {};
+
+}}
+
+namespace boost { namespace spirit { namespace lex
+{
+    template <typename Elements>
+    struct sequence : nary_lexer<sequence<Elements> >
+    {
+        sequence(Elements const& elements)
+          : elements(elements) {}
+
+        template <typename LexerDef, typename String>
+        void collect(LexerDef& lexdef, String const& state
+          , String const& targetstate) const
+        {
+            typedef detail::sequence_collect_function<LexerDef, String>
+                collect_function_type;
+            collect_function_type f (lexdef, state, targetstate);
+            fusion::any(elements, f);
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef& lexdef) const 
+        {
+            detail::sequence_add_actions_function<LexerDef> f (lexdef);
+            fusion::any(elements, f);
+        }
+
+        Elements elements;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Lexer generator: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::bitwise_or, Elements, Modifiers>
+      : make_nary_composite<Elements, sequence>
+    {};
+
+}}} // namespace boost::spirit::lex
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/string_token_def.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/string_token_def.hpp
new file mode 100644
index 0000000..9eb9870
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/string_token_def.hpp
@@ -0,0 +1,178 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_STRING_TOKEN_DEF_MAR_28_2007_0722PM)
+#define BOOST_SPIRIT_LEX_STRING_TOKEN_DEF_MAR_28_2007_0722PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+#include <boost/spirit/home/lex/domain.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables strings
+    template <typename T>
+    struct use_terminal<lex::domain, T
+      , typename enable_if<traits::is_string<T> >::type>
+      : mpl::true_ {};
+
+    // enables string(str)
+    template <typename CharEncoding, typename A0>
+    struct use_terminal<lex::domain
+      , terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector1<A0> > > 
+      : traits::is_string<A0> {};
+
+    // enables string(str, ID)
+    template <typename CharEncoding, typename A0, typename A1>
+    struct use_terminal<lex::domain
+      , terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector2<A0, A1> > > 
+      : traits::is_string<A0> {};
+}}
+
+namespace boost { namespace spirit { namespace lex
+{ 
+    // use string from standard character set by default
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::standard::string;
+#endif
+    using spirit::standard::string_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  string_token_def 
+    //      represents a string based token definition
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename String, typename IdType = std::size_t
+      , typename CharEncoding = char_encoding::standard>
+    struct string_token_def
+      : primitive_lexer<string_token_def<String, IdType, CharEncoding> >
+    {
+        typedef typename
+            remove_const<typename traits::char_type_of<String>::type>::type
+        char_type;
+        typedef std::basic_string<char_type> string_type;
+
+        string_token_def(typename add_reference<String>::type str, IdType const& id)
+          : str_(str), id_(id), unique_id_(std::size_t(~0))
+          , token_state_(std::size_t(~0)) 
+        {}
+
+        template <typename LexerDef, typename String_>
+        void collect(LexerDef& lexdef, String_ const& state
+          , String_ const& targetstate) const
+        {
+            std::size_t state_id = lexdef.add_state(state.c_str());
+
+            // If the following assertion fires you are probably trying to use 
+            // a single string_token_def instance in more than one lexer state. 
+            // This is not possible. Please create a separate token_def instance 
+            // from the same regular expression for each lexer state it needs 
+            // to be associated with.
+            BOOST_ASSERT(
+                (std::size_t(~0) == token_state_ || state_id == token_state_) &&
+                "Can't use single string_token_def with more than one lexer state");
+
+            char_type const* target = targetstate.empty() ? 0 : targetstate.c_str();
+            if (target)
+                lexdef.add_state(target);
+
+            token_state_ = state_id;
+
+            typedef typename LexerDef::id_type id_type;
+            if (IdType(~0) == id_)
+                id_ = IdType(lexdef.get_next_id());
+
+            unique_id_ = lexdef.add_token (state.c_str(), str_, id_, target);
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef&) const {}
+
+        std::size_t id() const { return id_; }
+        std::size_t unique_id() const { return unique_id_; }
+        std::size_t state() const { return token_state_; }
+
+        string_type str_;
+        mutable IdType id_;
+        mutable std::size_t unique_id_;
+        mutable std::size_t token_state_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Lex generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Modifiers>
+    struct make_primitive<T, Modifiers
+      , typename enable_if<traits::is_string<T> >::type>
+    {
+        typedef typename add_const<T>::type const_string;
+        typedef string_token_def<const_string> result_type;
+
+        result_type operator()(
+            typename add_reference<const_string>::type str, unused_type) const
+        {
+            return result_type(str, std::size_t(~0));
+        }
+    };
+
+    template <typename Modifiers, typename CharEncoding, typename A0>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector1<A0> >
+      , Modifiers>
+    {
+        typedef typename add_const<A0>::type const_string;
+        typedef string_token_def<const_string, std::size_t, CharEncoding> 
+            result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args), std::size_t(~0));
+        }
+    };
+
+    template <typename Modifiers, typename CharEncoding, typename A0, typename A1>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector2<A0, A1> >
+      , Modifiers>
+    {
+        typedef typename add_const<A0>::type const_string;
+        typedef string_token_def<const_string, A1, CharEncoding> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args), fusion::at_c<1>(term.args));
+        }
+    };
+}}}  // namespace boost::spirit::lex
+
+#endif 
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp
new file mode 100644
index 0000000..f3987c6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp
@@ -0,0 +1,205 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(SPIRIT_LEX_SUPPORT_FUNCTIONS_JUN_08_2009_0211PM)
+#define SPIRIT_LEX_SUPPORT_FUNCTIONS_JUN_08_2009_0211PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
+#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
+
+#include <boost/spirit/home/lex/lexer/support_functions_expression.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // The function object less_type is used by the implementation of the 
+    // support function lex::less(). Its functionality is equivalent to flex' 
+    // function yyless(): it returns an iterator positioned to the nth input 
+    // character beyond the current start iterator (i.e. by assigning the 
+    // return value to the placeholder '_end' it is possible to return all but
+    // the first n characters of the current token back to the input stream. 
+    //
+    //  This Phoenix actor is invoked whenever the function lex::less(n) is 
+    //  used inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ _end = lex::less(4) ];
+    //
+    //  The example shows how to limit the length of the matched identifier to 
+    //  four characters.
+    //
+    //  Note: the function lex::less() has no effect if used on it's own, you 
+    //        need to use the returned result in order to make use of its 
+    //        functionality.
+    template <typename Actor>
+    struct less_type
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                remove_const<
+                    typename mpl::at_c<typename Env::args_type, 4>::type
+                >::type
+            context_type;
+            typedef typename context_type::base_iterator_type type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type 
+        eval(Env const& env) const
+        {
+            typename result<Env>::type it;
+            return fusion::at_c<4>(env.args()).less(it, actor_());
+        }
+
+        less_type(Actor const& actor)
+          : actor_(actor) {}
+
+        Actor actor_;
+    };
+
+    //  The function lex::less() is used to create a Phoenix actor allowing to
+    //  implement functionality similar to flex' function yyless().
+    template <typename T>
+    inline typename expression::less<
+        typename phoenix::as_actor<T>::type
+    >::type const
+    less(T const& v)
+    {
+        return expression::less<T>::make(phoenix::as_actor<T>::convert(v));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The function object more_type is used by the implementation of the  
+    // support function lex::more(). Its functionality is equivalent to flex' 
+    // function yymore(): it tells the lexer that the next time it matches a 
+    // rule, the corresponding token should be appended onto the current token 
+    // value rather than replacing it.
+    //
+    //  This Phoenix actor is invoked whenever the function lex::more(n) is 
+    //  used inside a lexer semantic action:
+    //
+    //      lex::token_def<> identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+    //      this->self = identifier [ lex::more() ];
+    //
+    //  The example shows how prefix the next matched token with the matched
+    //  identifier.
+    struct more_type
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef void type;
+        };
+
+        template <typename Env>
+        void eval(Env const& env) const
+        {
+            fusion::at_c<4>(env.args()).more();
+        }
+    };
+
+    //  The function lex::more() is used to create a Phoenix actor allowing to
+    //  implement functionality similar to flex' function yymore(). 
+    //inline expression::more<mpl::void_>::type const
+    inline phoenix::actor<more_type> more()
+    {
+        return phoenix::actor<more_type>();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The function object lookahead_type is used by the implementation of the  
+    // support function lex::lookahead(). Its functionality is needed to 
+    // emulate the flex' lookahead operator a/b. Use lex::lookahead() inside
+    // of lexer semantic actions to test whether the argument to this function
+    // matches the current look ahead input. lex::lookahead() can be used with
+    // either a token id or a token_def instance as its argument. It returns
+    // a bool indicating whether the look ahead has been matched.
+    template <typename IdActor, typename StateActor>
+    struct lookahead_type
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef bool type;
+        };
+
+        template <typename Env>
+        bool eval(Env const& env) const
+        {
+            return fusion::at_c<4>(env.args()).
+                lookahead(id_actor_(), state_actor_());
+        }
+
+        lookahead_type(IdActor const& id_actor, StateActor const& state_actor)
+          : id_actor_(id_actor), state_actor_(state_actor) {}
+
+        IdActor id_actor_;
+        StateActor state_actor_;
+    };
+
+    //  The function lex::lookahead() is used to create a Phoenix actor 
+    //  allowing to implement functionality similar to flex' lookahead operator
+    //  a/b.
+    template <typename T>
+    inline typename expression::lookahead<
+        typename phoenix::as_actor<T>::type
+      , typename phoenix::as_actor<std::size_t>::type
+    >::type const
+    lookahead(T const& id)
+    {
+        typedef typename phoenix::as_actor<T>::type id_actor_type;
+        typedef typename phoenix::as_actor<std::size_t>::type state_actor_type;
+
+        return expression::lookahead<id_actor_type, state_actor_type>::make(
+            phoenix::as_actor<T>::convert(id),
+            phoenix::as_actor<std::size_t>::convert(std::size_t(~0)));
+    }
+
+    template <typename Attribute, typename Char, typename Idtype>
+    inline typename expression::lookahead<
+        typename phoenix::as_actor<Idtype>::type
+      , typename phoenix::as_actor<std::size_t>::type
+    >::type const
+    lookahead(token_def<Attribute, Char, Idtype> const& tok)
+    {
+        typedef typename phoenix::as_actor<Idtype>::type id_actor_type;
+        typedef typename phoenix::as_actor<std::size_t>::type state_actor_type;
+
+        std::size_t state = tok.state();
+
+        // The following assertion fires if you pass a token_def instance to 
+        // lex::lookahead without first associating this instance with the 
+        // lexer.
+        BOOST_ASSERT(std::size_t(~0) != state && 
+            "token_def instance not associated with lexer yet");
+
+        return expression::lookahead<id_actor_type, state_actor_type>::make(
+            phoenix::as_actor<Idtype>::convert(tok.id()),
+            phoenix::as_actor<std::size_t>::convert(state));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    inline BOOST_SCOPED_ENUM(pass_flags) ignore()
+    {
+        return pass_flags::pass_ignore;
+    }
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp
new file mode 100644
index 0000000..613a4a4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp
@@ -0,0 +1,135 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c)      2011 Thomas Heller
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(SPIRIT_LEX_SUPPORT_FUNCTIONS_EXPRESSION_MAR_22_2011_0711PM)
+#define SPIRIT_LEX_SUPPORT_FUNCTIONS_EXPRESSION_MAR_22_2011_0711PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    template <typename> struct less_type;
+    struct more_type;
+    template <typename, typename> struct lookahead_type;
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+
+namespace boost { namespace spirit { namespace lex
+{
+    namespace expression
+    {
+        template <typename Eval>
+        struct less
+        {
+            typedef phoenix::actor<lex::less_type<Eval> > type;
+
+            static type make(Eval const & eval)
+            {
+                return lex::less_type<Eval>(eval);
+            }
+        };
+
+        template <typename IdType, typename State>
+        struct lookahead
+        {
+            typedef phoenix::actor<lex::lookahead_type<IdType, State> > type;
+
+            static type make(IdType const & id_type, State const & state)
+            {
+                return lex::lookahead_type<IdType, State>(id_type, state);
+            }
+        };
+    }
+}}}
+
+#else // BOOST_SPIRIT_USE_PHOENIX_V3
+
+BOOST_PHOENIX_DEFINE_EXPRESSION(
+    (boost)(spirit)(lex)(less)
+  , (boost::phoenix::meta_grammar)
+)
+
+BOOST_PHOENIX_DEFINE_EXPRESSION(
+    (boost)(spirit)(lex)(lookahead)
+  , (boost::phoenix::meta_grammar)
+    (boost::phoenix::meta_grammar)
+)
+
+namespace boost { namespace phoenix
+{
+
+    namespace result_of
+    {
+        template <>
+        struct is_nullary<custom_terminal<boost::spirit::lex::more_type> >
+          : mpl::false_
+        {};
+    }
+    
+    template <typename Dummy>
+    struct is_custom_terminal<boost::spirit::lex::more_type, Dummy> : mpl::true_ {};
+    
+    template <typename Dummy>
+    struct custom_terminal<boost::spirit::lex::more_type, Dummy>
+        : proto::call<
+            v2_eval(
+                proto::make<boost::spirit::lex::more_type()>
+              , proto::call<functional::env(proto::_state)>
+            )
+        >
+    {};
+
+
+    template <typename Dummy>
+    struct is_nullary::when<spirit::lex::rule::less, Dummy>
+      : proto::make<mpl::false_()>
+    {};
+
+    template <typename Dummy>
+    struct default_actions::when<spirit::lex::rule::less, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<
+                    spirit::lex::less_type<proto::_child0>(proto::_child0)
+                >
+              , _env
+            )
+        >
+    {};
+
+    template <typename Dummy>
+    struct is_nullary::when<spirit::lex::rule::lookahead, Dummy>
+      : proto::make<mpl::false_()>
+    {};
+
+    template <typename Dummy>
+    struct default_actions::when<spirit::lex::rule::lookahead, Dummy>
+      : proto::call<
+            v2_eval(
+                proto::make<
+                    spirit::lex::lookahead_type<
+                        proto::_child0
+                      , proto::_child1
+                    >(
+                        proto::_child0
+                      , proto::_child1
+                    )
+                >
+              , _env
+            )
+        >
+    {};
+}}
+
+#endif // BOOST_SPIRIT_USE_PHOENIX_V3
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/terminals.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/terminals.hpp
new file mode 100644
index 0000000..b5059cc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/terminals.hpp
@@ -0,0 +1,23 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_TERMINALS_APR_20_2009_0550PM)
+#define BOOST_SPIRIT_LEX_TERMINALS_APR_20_2009_0550PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/common_terminals.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Define a more convenient name for an omitted token attribute type
+    typedef spirit::omit_type omit;
+    using spirit::omit_type;
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/token_def.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/token_def.hpp
new file mode 100644
index 0000000..1bd2534
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/token_def.hpp
@@ -0,0 +1,246 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_TOKEN_DEF_MAR_13_2007_0145PM)
+#define BOOST_SPIRIT_LEX_TOKEN_DEF_MAR_13_2007_0145PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/argument.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/detail/construct.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/spirit/home/lex/reference.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/lex/lexer/terminals.hpp>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/variant.hpp>
+
+#include <string>
+#include <cstdlib>
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4355) // 'this' : used in base member initializer list warning
+#endif
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  This component represents a token definition
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Attribute = unused_type
+      , typename Char = char
+      , typename Idtype = std::size_t>
+    struct token_def
+      : proto::extends<
+            typename proto::terminal<
+                lex::reference<token_def<Attribute, Char, Idtype> const, Idtype> 
+            >::type
+          , token_def<Attribute, Char, Idtype> >
+      , qi::parser<token_def<Attribute, Char, Idtype> >
+      , lex::lexer_type<token_def<Attribute, Char, Idtype> >
+    {
+    private:
+        // initialize proto base class
+        typedef lex::reference<token_def const, Idtype> reference_;
+        typedef typename proto::terminal<reference_>::type terminal_type;
+        typedef proto::extends<terminal_type, token_def> proto_base_type;
+
+        static std::size_t const all_states_id = static_cast<std::size_t>(-2);
+
+    public:
+        // Qi interface: meta-function calculating parser return type
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            //  The return value of the token_def is either the specified 
+            //  attribute type, or the pair of iterators from the match of the 
+            //  corresponding token (if no attribute type has been specified),
+            //  or unused_type (if omit has been specified).
+            typedef typename Iterator::base_iterator_type iterator_type;
+            typedef typename mpl::if_<
+                traits::not_is_unused<Attribute>
+              , typename mpl::if_<
+                    is_same<Attribute, lex::omit>, unused_type, Attribute
+                >::type
+              , iterator_range<iterator_type>
+            >::type type;
+        };
+
+    public:
+        // Qi interface: parse functionality
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute_>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute_& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                typedef typename 
+                    boost::detail::iterator_traits<Iterator>::value_type 
+                token_type;
+
+                //  If the following assertion fires you probably forgot to  
+                //  associate this token definition with a lexer instance.
+                BOOST_ASSERT(std::size_t(~0) != token_state_);
+
+                token_type const& t = *first;
+                if (token_id_ == t.id() && 
+                    (all_states_id == token_state_ || token_state_ == t.state())) 
+                {
+                    spirit::traits::assign_to(t, attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            if (0 == def_.which()) 
+                return info("token_def", boost::get<string_type>(def_));
+
+            return info("token_def", boost::get<char_type>(def_));
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        // Lex interface: collect token definitions and put it into the 
+        // provided lexer def
+        template <typename LexerDef, typename String>
+        void collect(LexerDef& lexdef, String const& state
+          , String const& targetstate) const
+        {
+            std::size_t state_id = lexdef.add_state(state.c_str());
+
+            // If the following assertion fires you are probably trying to use 
+            // a single token_def instance in more than one lexer state. This 
+            // is not possible. Please create a separate token_def instance 
+            // from the same regular expression for each lexer state it needs 
+            // to be associated with.
+            BOOST_ASSERT(
+                (std::size_t(~0) == token_state_ || state_id == token_state_) &&
+                "Can't use single token_def with more than one lexer state");
+
+            char_type const* target = targetstate.empty() ? 0 : targetstate.c_str();
+            if (target)
+                lexdef.add_state(target);
+
+            token_state_ = state_id;
+            if (0 == token_id_)
+                token_id_ = lexdef.get_next_id();
+
+            if (0 == def_.which()) {
+                unique_id_ = lexdef.add_token(state.c_str()
+                  , boost::get<string_type>(def_), token_id_, target);
+            }
+            else {
+                unique_id_ = lexdef.add_token(state.c_str()
+                  , boost::get<char_type>(def_), token_id_, target);
+            }
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef&) const {}
+
+    public:
+        typedef Char char_type;
+        typedef Idtype id_type;
+        typedef std::basic_string<char_type> string_type;
+
+        // Lex interface: constructing token definitions
+        token_def() 
+          : proto_base_type(terminal_type::make(reference_(*this)))
+          , def_('\0'), token_id_()
+          , unique_id_(std::size_t(~0)), token_state_(std::size_t(~0)) {}
+
+        token_def(token_def const& rhs) 
+          : proto_base_type(terminal_type::make(reference_(*this)))
+          , def_(rhs.def_), token_id_(rhs.token_id_)
+          , unique_id_(rhs.unique_id_), token_state_(rhs.token_state_) {}
+
+        explicit token_def(char_type def_, Idtype id_ = Idtype())
+          : proto_base_type(terminal_type::make(reference_(*this)))
+          , def_(def_)
+          , token_id_(Idtype() == id_ ? Idtype(def_) : id_)
+          , unique_id_(std::size_t(~0)), token_state_(std::size_t(~0)) {}
+
+        explicit token_def(string_type const& def_, Idtype id_ = Idtype())
+          : proto_base_type(terminal_type::make(reference_(*this)))
+          , def_(def_), token_id_(id_)
+          , unique_id_(std::size_t(~0)), token_state_(std::size_t(~0)) {}
+
+        template <typename String>
+        token_def& operator= (String const& definition)
+        {
+            def_ = definition;
+            token_id_ = Idtype();
+            unique_id_ = std::size_t(~0);
+            token_state_ = std::size_t(~0);
+            return *this;
+        }
+        token_def& operator= (token_def const& rhs)
+        {
+            def_ = rhs.def_;
+            token_id_ = rhs.token_id_;
+            unique_id_ = rhs.unique_id_;
+            token_state_ = rhs.token_state_;
+            return *this;
+        }
+
+        // general accessors 
+        Idtype const& id() const { return token_id_; }
+        void id(Idtype const& id) { token_id_ = id; }
+        std::size_t unique_id() const { return unique_id_; }
+
+        string_type definition() const 
+        { 
+            return (0 == def_.which()) ? 
+                boost::get<string_type>(def_) : 
+                string_type(1, boost::get<char_type>(def_));
+        }
+        std::size_t state() const { return token_state_; }
+
+    private:
+        variant<string_type, char_type> def_;
+        mutable Idtype token_id_;
+        mutable std::size_t unique_id_;
+        mutable std::size_t token_state_;
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Attribute, typename Char, typename Idtype
+      , typename Attr, typename Context, typename Iterator>
+    struct handles_container<
+            lex::token_def<Attribute, Char, Idtype>, Attr, Context, Iterator>
+      : traits::is_container<
+            typename attribute_of<
+                lex::token_def<Attribute, Char, Idtype>, Context, Iterator
+            >::type>
+    {};
+}}}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer_lexertl.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer_lexertl.hpp
new file mode 100644
index 0000000..0706bd9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer_lexertl.hpp
@@ -0,0 +1,18 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_LEXERTL_MAR_17_2007_1008PM)
+#define BOOST_SPIRIT_LEX_LEXERTL_MAR_17_2007_1008PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+//  These includes make available everything needed to use lexertl either 
+//  standalone or as a lexer component for spirit::qi
+#include <boost/spirit/home/lex.hpp>
+#include <boost/spirit/home/lex/lexer/lexertl/lexer.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer_type.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer_type.hpp
new file mode 100644
index 0000000..e58bce0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer_type.hpp
@@ -0,0 +1,100 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXER_TYPE_APR_20_2009_0759PM)
+#define BOOST_SPIRIT_LEXER_TYPE_APR_20_2009_0759PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/spirit/home/lex/domain.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    template <typename Derived>
+    struct lexer_type
+    {
+        struct lexer_id;
+        typedef Derived derived_type;
+        typedef lex::domain domain;
+
+        // Requirement: l.collect(def, state, targetstate) -> void
+        //
+        //  l:           a lexer component
+        //  def:         token definition container
+        //  state:       lexer state this token definition needs to be added to
+        //  targetstate: an optional lexer state the lexer should be switched 
+        //               into after matching this token 
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    template <typename Derived>
+    struct primitive_lexer : lexer_type<Derived>
+    {
+        struct primitive_lexer_id;
+    };
+
+    template <typename Derived>
+    struct unary_lexer : lexer_type<Derived>
+    {
+        struct unary_lexer_id;
+
+        // Requirement: l.subject -> subject lexer component
+        //
+        // l:   a unary lexer component
+
+        // Requirement: L::subject_type -> subject lexer component type
+        //
+        // L:   a unary lexer component type
+    };
+
+    template <typename Derived>
+    struct nary_lexer : lexer_type<Derived>
+    {
+        struct nary_lexer_id;
+
+        // Requirement: l.elements -> fusion sequence
+        //
+        // l:   a composite lexer component
+
+        // Requirement: L::elements_type -> fusion sequence
+        //
+        // L:   a composite lexer component type
+    };
+
+}}}
+
+namespace boost { namespace spirit { namespace traits // classification
+{
+    namespace detail
+    {
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(lexer_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(primitive_lexer_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(unary_lexer_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(nary_lexer_id)
+    }
+
+    template <typename T>
+    struct is_lexer : detail::has_lexer_id<T> {};
+
+    template <typename T>
+    struct is_primitive_lexer : detail::has_primitive_lexer_id<T> {};
+
+    template <typename T>
+    struct is_unary_lexer : detail::has_unary_lexer_id<T> {};
+
+    template <typename T>
+    struct is_nary_lexer : detail::has_nary_lexer_id<T> {};
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/meta_compiler.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/meta_compiler.hpp
new file mode 100644
index 0000000..6e13d37
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/meta_compiler.hpp
@@ -0,0 +1,104 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_META_COMPILER_APR_20_2009_0756PM)
+#define BOOST_SPIRIT_LEX_META_COMPILER_APR_20_2009_0756PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/lex/domain.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace spirit
+{
+    template <typename T>
+    struct use_terminal<lex::domain, T
+      , typename enable_if<traits::is_lexer<T> >::type> // enables lexers
+      : mpl::true_ {};
+
+    namespace lex
+    {
+        template <typename T, typename Modifiers, typename Enable = void>
+        struct make_primitive // by default, return it as-is
+        {
+            typedef T result_type;
+
+            template <typename T_>
+            T_& operator()(T_& val, unused_type) const
+            {
+                return val;
+            }
+
+            template <typename T_>
+            T_ const& operator()(T_ const& val, unused_type) const
+            {
+                return val;
+            }
+        };
+
+        template <typename Tag, typename Elements
+          , typename Modifiers, typename Enable = void>
+        struct make_composite;
+    }
+
+    // Lex primitive meta-compiler
+    template <>
+    struct make_component<lex::domain, proto::tag::terminal>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename lex::make_primitive<
+                typename remove_const<typename Elements::car_type>::type,
+                typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            typedef typename remove_const<typename Elements::car_type>::type term;
+            return lex::make_primitive<term, Modifiers>()(elements.car, modifiers);
+        }
+    };
+
+    // Lex composite meta-compiler
+    template <typename Tag>
+    struct make_component<lex::domain, Tag>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                lex::make_composite<Tag, Elements
+                  , typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return lex::make_composite<Tag, Elements, Modifiers>()(
+                elements, modifiers);
+        }
+    };
+
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi.hpp
new file mode 100644
index 0000000..3b4e704
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi.hpp
@@ -0,0 +1,20 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXER_QI_APR_21_2009_0205PM)
+#define BOOST_SPIRIT_LEXER_QI_APR_21_2009_0205PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/qi/state_switcher.hpp>
+#include <boost/spirit/home/lex/qi/in_state.hpp>
+#include <boost/spirit/home/lex/qi/plain_token.hpp>
+#include <boost/spirit/home/lex/qi/plain_tokenid.hpp>
+#include <boost/spirit/home/lex/qi/plain_tokenid_mask.hpp>
+#include <boost/spirit/home/lex/qi/plain_raw_token.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/in_state.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/in_state.hpp
new file mode 100644
index 0000000..fe7580b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/in_state.hpp
@@ -0,0 +1,32 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_IN_STATE_OCT_09_2007_0748PM)
+#define BOOST_SPIRIT_LEX_IN_STATE_OCT_09_2007_0748PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/proto/core.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace qi
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // The following is a helper template allowing to use the in_state()[] as 
+    // a skip parser
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Skipper, typename String = char const*>
+    struct in_state_skipper
+      : proto::subscript<
+            typename proto::terminal<
+                terminal_ex<tag::in_state, fusion::vector1<String> > 
+            >::type
+          , Skipper
+        >::type {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_raw_token.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_raw_token.hpp
new file mode 100644
index 0000000..ebe980d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_raw_token.hpp
@@ -0,0 +1,149 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_PLAIN_RAW_TOKEN_JUN_03_2011_0853PM)
+#define BOOST_SPIRIT_LEX_PLAIN_RAW_TOKEN_JUN_03_2011_0853PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables raw_token
+    template <>
+    struct use_terminal<qi::domain, tag::raw_token>
+      : mpl::true_ {};
+
+    // enables raw_token(id)
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::raw_token, fusion::vector1<A0> >
+    > : mpl::or_<is_integral<A0>, is_enum<A0> > {};
+
+    // enables *lazy* raw_token(id)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::raw_token, 1
+    > : mpl::true_ {};
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::raw_token;
+#endif
+    using spirit::raw_token_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename TokenId>
+    struct plain_raw_token
+      : primitive_parser<plain_raw_token<TokenId> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+
+        plain_raw_token(TokenId const& id)
+          : id(id) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the id this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
+                    spirit::traits::assign_to(t, attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("raw_token",
+                "raw_token(" + boost::lexical_cast<utf8_string>(id) + ")");
+        }
+
+        TokenId id;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Modifiers>
+    struct make_primitive<tag::raw_token, Modifiers>
+    {
+        typedef plain_raw_token<std::size_t> result_type;
+
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type(std::size_t(~0));
+        }
+    };
+
+    template <typename Modifiers, typename TokenId>
+    struct make_primitive<terminal_ex<tag::raw_token, fusion::vector1<TokenId> >
+      , Modifiers>
+    {
+        typedef plain_raw_token<TokenId> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Idtype, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_raw_token<Idtype>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_token.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_token.hpp
new file mode 100644
index 0000000..b77e2a9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_token.hpp
@@ -0,0 +1,242 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_PLAIN_TOKEN_NOV_11_2007_0451PM)
+#define BOOST_SPIRIT_LEX_PLAIN_TOKEN_NOV_11_2007_0451PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables token
+    template <>
+    struct use_terminal<qi::domain, tag::token>
+      : mpl::true_ {};
+
+    // enables token(id)
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::token, fusion::vector1<A0> >
+    > : mpl::or_<is_integral<A0>, is_enum<A0> > {};
+
+    // enables token(idmin, idmax)
+    template <typename A0, typename A1>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::token, fusion::vector2<A0, A1> >
+    > : mpl::and_<
+            mpl::or_<is_integral<A0>, is_enum<A0> >
+          , mpl::or_<is_integral<A1>, is_enum<A1> >
+        > {};
+
+    // enables *lazy* token(id)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::token, 1
+    > : mpl::true_ {};
+
+    // enables *lazy* token(idmin, idmax)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::token, 2
+    > : mpl::true_ {};
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::token;
+#endif
+    using spirit::token_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename TokenId>
+    struct plain_token
+      : primitive_parser<plain_token<TokenId> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename Iterator::base_iterator_type iterator_type;
+            typedef iterator_range<iterator_type> type;
+        };
+
+        plain_token(TokenId const& id)
+          : id(id) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the id this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
+                    spirit::traits::assign_to(t, attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("token",
+                "token(" + boost::lexical_cast<utf8_string>(id) + ")");
+        }
+
+        TokenId id;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename TokenId>
+    struct plain_token_range
+      : primitive_parser<plain_token_range<TokenId> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename Iterator::base_iterator_type iterator_type;
+            typedef iterator_range<iterator_type> type;
+        };
+
+        plain_token_range(TokenId const& idmin, TokenId const& idmax)
+          : idmin(idmin), idmax(idmax) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the id this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if (id_type(idmin) >= t.id() && id_type(idmin) <= t.id())
+                {
+                    spirit::traits::assign_to(t, attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("token_range"
+              , "token(" +
+                    boost::lexical_cast<utf8_string>(idmin) + ", " +
+                    boost::lexical_cast<utf8_string>(idmax) + ")"
+            );
+            return info("token_range");
+        }
+
+        TokenId idmin, idmax;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Modifiers>
+    struct make_primitive<tag::token, Modifiers>
+    {
+        typedef plain_token<std::size_t> result_type;
+
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type(std::size_t(~0));
+        }
+    };
+
+    template <typename Modifiers, typename TokenId>
+    struct make_primitive<terminal_ex<tag::token, fusion::vector1<TokenId> >
+      , Modifiers>
+    {
+        typedef plain_token<TokenId> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+
+    template <typename Modifiers, typename TokenId>
+    struct make_primitive<terminal_ex<tag::token, fusion::vector2<TokenId, TokenId> >
+      , Modifiers>
+    {
+        typedef plain_token_range<TokenId> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args)
+              , fusion::at_c<1>(term.args));
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Idtype, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_token<Idtype>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+
+    template<typename Idtype, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_token_range<Idtype>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid.hpp
new file mode 100644
index 0000000..7a70c77
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid.hpp
@@ -0,0 +1,242 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_PLAIN_TOKENID_NOV_26_2010_0944AM)
+#define BOOST_SPIRIT_LEX_PLAIN_TOKENID_NOV_26_2010_0944AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables tokenid
+    template <>
+    struct use_terminal<qi::domain, tag::tokenid>
+      : mpl::true_ {};
+
+    // enables tokenid(id)
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::tokenid, fusion::vector1<A0> >
+    > : mpl::or_<is_integral<A0>, is_enum<A0> > {};
+
+    // enables tokenid(idmin, idmax)
+    template <typename A0, typename A1>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::tokenid, fusion::vector2<A0, A1> >
+    > : mpl::and_<
+            mpl::or_<is_integral<A0>, is_enum<A0> >
+          , mpl::or_<is_integral<A1>, is_enum<A1> >
+        > {};
+
+    // enables *lazy* tokenid(id)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::tokenid, 1
+    > : mpl::true_ {};
+
+    // enables *lazy* tokenid(idmin, idmax)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::tokenid, 2
+    > : mpl::true_ {};
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::tokenid;
+#endif
+    using spirit::tokenid_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The plain_tokenid represents a simple token defined by the lexer inside
+    // a Qi grammar. The difference to plain_token is that it exposes the
+    // matched token id instead of the iterator_range of the matched input.
+    template <typename TokenId>
+    struct plain_tokenid
+      : primitive_parser<plain_tokenid<TokenId> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef TokenId type;
+        };
+
+        plain_tokenid(TokenId const& id)
+          : id(id) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the id this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
+                    spirit::traits::assign_to(id, attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("tokenid",
+                "tokenid(" + boost::lexical_cast<utf8_string>(id) + ")");
+        }
+
+        TokenId id;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename TokenId>
+    struct plain_tokenid_range
+      : primitive_parser<plain_tokenid_range<TokenId> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef TokenId type;
+        };
+
+        plain_tokenid_range(TokenId const& idmin, TokenId const& idmax)
+          : idmin(idmin), idmax(idmax) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the id this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if (id_type(idmin) >= t.id() && id_type(idmin) <= t.id())
+                {
+                    spirit::traits::assign_to(t.id(), attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("tokenid_range"
+              , "token(" +
+                    boost::lexical_cast<utf8_string>(idmin) + ", " +
+                    boost::lexical_cast<utf8_string>(idmax) + ")"
+            );
+        }
+
+        TokenId idmin, idmax;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Modifiers>
+    struct make_primitive<tag::tokenid, Modifiers>
+    {
+        typedef plain_tokenid<std::size_t> result_type;
+
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type(std::size_t(~0));
+        }
+    };
+
+    template <typename Modifiers, typename TokenId>
+    struct make_primitive<terminal_ex<tag::tokenid, fusion::vector1<TokenId> >
+      , Modifiers>
+    {
+        typedef plain_tokenid<TokenId> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+
+    template <typename Modifiers, typename TokenId>
+    struct make_primitive<terminal_ex<tag::tokenid, fusion::vector2<TokenId, TokenId> >
+      , Modifiers>
+    {
+        typedef plain_tokenid_range<TokenId> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args)
+              , fusion::at_c<1>(term.args));
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Idtype, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_tokenid<Idtype>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+
+    template<typename Idtype, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_tokenid_range<Idtype>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp
new file mode 100644
index 0000000..92ac126
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp
@@ -0,0 +1,138 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_PLAIN_TOKENID_MASK_JUN_03_2011_0929PM)
+#define BOOST_SPIRIT_LEX_PLAIN_TOKENID_MASK_JUN_03_2011_0929PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/detail/assign_to.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables tokenid_mask(id)
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::tokenid_mask, fusion::vector1<A0> >
+    > : mpl::or_<is_integral<A0>, is_enum<A0> > {};
+
+    // enables *lazy* tokenid_mask(id)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::tokenid_mask, 1
+    > : mpl::true_ {};
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::tokenid_mask;
+#endif
+    using spirit::tokenid_mask_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The plain_tokenid represents a simple token defined by the lexer inside
+    // a Qi grammar. The difference to plain_token is that it exposes the
+    // matched token id instead of the iterator_range of the matched input.
+    // Additionally it applies the given mask to the matched token id.
+    template <typename Mask>
+    struct plain_tokenid_mask
+      : primitive_parser<plain_tokenid_mask<Mask> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef Mask type;
+        };
+
+        plain_tokenid_mask(Mask const& mask)
+          : mask(mask) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            if (first != last) {
+                // simply match the token id with the mask this component has
+                // been initialized with
+
+                typedef typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                token_type;
+                typedef typename token_type::id_type id_type;
+
+                token_type const& t = *first;
+                if ((t.id() & mask) == id_type(mask))
+                {
+                    spirit::traits::assign_to(t.id(), attr);
+                    ++first;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("tokenid_mask",
+                "tokenid_mask(" + boost::lexical_cast<utf8_string>(mask) + ")");
+        }
+
+        Mask mask;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Modifiers, typename Mask>
+    struct make_primitive<terminal_ex<tag::tokenid_mask, fusion::vector1<Mask> >
+      , Modifiers>
+    {
+        typedef plain_tokenid_mask<Mask> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Mask, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::plain_tokenid_mask<Mask>, Attr, Context, Iterator>
+      : mpl::true_
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/qi/state_switcher.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/qi/state_switcher.hpp
new file mode 100644
index 0000000..a8fd55a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/qi/state_switcher.hpp
@@ -0,0 +1,270 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c)      2010 Bryce Lelbach
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_STATE_SWITCHER_SEP_23_2007_0714PM)
+#define BOOST_SPIRIT_LEX_STATE_SWITCHER_SEP_23_2007_0714PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+#include <boost/spirit/home/support/has_semantic_action.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/mpl/print.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    // enables set_state(s)
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::set_state, fusion::vector1<A0> >
+    > : traits::is_string<A0> {};
+
+    // enables *lazy* set_state(s)
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::set_state, 1
+    > : mpl::true_ {};
+
+    // enables in_state(s)[p]
+    template <typename A0>
+    struct use_directive<qi::domain
+      , terminal_ex<tag::in_state, fusion::vector1<A0> >
+    > : traits::is_string<A0> {};
+
+    // enables *lazy* in_state(s)[p]
+    template <>
+    struct use_lazy_directive<
+        qi::domain, tag::in_state, 1
+    > : mpl::true_ {};
+
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    using spirit::set_state;
+    using spirit::in_state;
+#endif
+    using spirit::set_state_type;
+    using spirit::in_state_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename Iterator>
+        inline std::size_t
+        set_lexer_state(Iterator& it, std::size_t state)
+        {
+            return it.set_state(state);
+        }
+
+        template <typename Iterator, typename Char>
+        inline std::size_t
+        set_lexer_state(Iterator& it, Char const* statename)
+        {
+            std::size_t state = it.map_state(statename);
+
+            //  If the following assertion fires you probably used the
+            //  set_state(...) or in_state(...)[...] lexer state switcher with
+            //  a lexer state name unknown to the lexer (no token definitions
+            //  have been associated with this lexer state).
+            BOOST_ASSERT(std::size_t(~0) != state);
+            return it.set_state(state);
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Parser switching the state of the underlying lexer component.
+    //  This parser gets used for the set_state(...) construct.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename State>
+    struct state_switcher
+      : primitive_parser<state_switcher<State> >
+    {
+        typedef typename 
+            remove_const<typename traits::char_type_of<State>::type>::type 
+        char_type;
+        typedef std::basic_string<char_type> string_type;
+
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+
+        state_switcher(char_type const* state)
+          : state(state) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& /*attr*/) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            // just switch the state and return success
+            detail::set_lexer_state(first, state.c_str());
+            return true;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info("set_state");
+        }
+
+        string_type state;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename Iterator>
+        struct reset_state_on_exit
+        {
+            template <typename State>
+            reset_state_on_exit(Iterator& it_, State state_)
+              : it(it_)
+              , state(set_lexer_state(it_, traits::get_c_string(state_))) 
+            {}
+
+            ~reset_state_on_exit()
+            {
+                // reset the state of the underlying lexer instance
+                set_lexer_state(it, state);
+            }
+
+            Iterator& it;
+            std::size_t state;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            reset_state_on_exit& operator= (reset_state_on_exit const&);
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser, which switches the state of the underlying lexer component
+    // for the execution of the embedded sub-parser, switching the state back
+    // afterwards. This parser gets used for the in_state(...)[p] construct.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename State>
+    struct state_switcher_context 
+      : unary_parser<state_switcher_context<Subject, State> >
+    {
+        typedef Subject subject_type;
+        typedef typename traits::char_type_of<State>::type char_type;
+        typedef typename remove_const<char_type>::type non_const_char_type;
+
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<subject_type, Context, Iterator>::type
+            type;
+        };
+
+        state_switcher_context(Subject const& subject
+              , typename add_reference<State>::type state)
+          : subject(subject), state(state) {}
+
+        // The following conversion constructors are needed to make the 
+        // in_state_switcher template usable
+        template <typename String>
+        state_switcher_context(
+                state_switcher_context<Subject, String> const& rhs)
+          : subject(rhs.subject), state(traits::get_c_string(rhs.state)) {}
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);   // always do a pre-skip
+
+            // the state has to be reset at exit in any case
+            detail::reset_state_on_exit<Iterator> guard(first, state);
+            return subject.parse(first, last, context, skipper, attr);
+        }
+
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("in_state", subject.what(context));
+        }
+
+        Subject subject;
+        State state;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        state_switcher_context& operator= (state_switcher_context const&);
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Modifiers, typename State>
+    struct make_primitive<terminal_ex<tag::set_state, fusion::vector1<State> >
+      , Modifiers, typename enable_if<traits::is_string<State> >::type>
+    {
+        typedef typename add_const<State>::type const_string;
+        typedef state_switcher<const_string> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(traits::get_c_string(fusion::at_c<0>(term.args)));
+        }
+    };
+
+    template <typename State, typename Subject, typename Modifiers>
+    struct make_directive<terminal_ex<tag::in_state, fusion::vector1<State> >
+      , Subject, Modifiers>
+    {
+        typedef typename add_const<State>::type const_string;
+        typedef state_switcher_context<Subject, const_string> result_type;
+
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, Subject const& subject
+          , unused_type) const
+        {
+            return result_type(subject, fusion::at_c<0>(term.args));
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename State>
+    struct has_semantic_action<qi::state_switcher_context<Subject, State> >
+      : unary_has_semantic_action<Subject> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename State, typename Attribute
+        , typename Context, typename Iterator>
+    struct handles_container<qi::state_switcher_context<Subject, State>
+          , Attribute, Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {}; 
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/reference.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/reference.hpp
new file mode 100644
index 0000000..d1aaabf
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/reference.hpp
@@ -0,0 +1,85 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEX_REFERENCE_APR_20_2009_0827AM)
+#define BOOST_SPIRIT_LEX_REFERENCE_APR_20_2009_0827AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/lex/meta_compiler.hpp>
+#include <boost/spirit/home/lex/lexer_type.hpp>
+#include <boost/spirit/home/qi/reference.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/ref.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // reference is a lexer that references another lexer (its Subject)
+    // all lexer components are at the same time
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename IdType = unused_type>
+    struct reference; 
+
+    template <typename Subject>
+    struct reference<Subject, unused_type>
+      : qi::reference<Subject>
+      , lexer_type<reference<Subject> >
+    {
+        reference(Subject& subject)
+          : qi::reference<Subject>(subject) {}
+
+        template <typename LexerDef, typename String>
+        void collect(LexerDef& lexdef, String const& state
+          , String const& targetstate) const
+        {
+            this->ref.get().collect(lexdef, state, targetstate);
+        }
+
+        template <typename LexerDef>
+        void add_actions(LexerDef& lexdef) const 
+        {
+            this->ref.get().add_actions(lexdef);
+        }
+    };
+
+    template <typename Subject, typename IdType>
+    struct reference : reference<Subject>
+    {
+        reference(Subject& subject)
+          : reference<Subject>(subject) {}
+
+        IdType id() const 
+        { 
+            return this->ref.get().id(); 
+        }
+        std::size_t unique_id() const 
+        { 
+            return this->ref.get().unique_id(); 
+        }
+        std::size_t state() const 
+        { 
+            return this->ref.get().state(); 
+        }
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename IdType
+      , typename Attribute, typename Context, typename Iterator>
+    struct handles_container<lex::reference<Subject, IdType>
+          , Attribute, Context, Iterator>
+      : handles_container<
+            typename remove_const<Subject>::type, Attribute, Context, Iterator> 
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse.hpp
new file mode 100644
index 0000000..db12935
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse.hpp
@@ -0,0 +1,325 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_LEXER_PARSE_NOV_17_2007_0246PM)
+#define BOOST_SPIRIT_LEXER_PARSE_NOV_17_2007_0246PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/qi/parse.hpp>
+#include <boost/spirit/home/qi/nonterminal/grammar.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/lex/lexer.hpp>
+#include <boost/mpl/assert.hpp>
+
+namespace boost { namespace spirit { namespace lex
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Import skip_flag enumerator type from Qi namespace
+    using qi::skip_flag;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The tokenize_and_parse() function is one of the main Spirit API 
+    //  functions. It simplifies using a lexer as the underlying token source
+    //  while parsing a given input sequence.
+    //
+    //  The function takes a pair of iterators spanning the underlying input 
+    //  stream to parse, the lexer object (built from the token definitions) 
+    //  and a parser object (built from the parser grammar definition).
+    //
+    //  The second version of this function additionally takes an attribute to 
+    //  be used as the top level data structure instance the parser should use 
+    //  to store the recognized input to.
+    //
+    //  The function returns true if the parsing succeeded (the given input
+    //  sequence has been successfully matched by the given grammar).
+    //
+    //  first, last:    The pair of iterators spanning the underlying input 
+    //                  sequence to parse. These iterators must at least 
+    //                  conform to the requirements of the std::intput_iterator 
+    //                  category.
+    //                  On exit the iterator 'first' will be updated to the 
+    //                  position right after the last successfully matched 
+    //                  token. 
+    //  lex:            The lexer object (encoding the token definitions) to be
+    //                  used to convert the input sequence into a sequence of 
+    //                  tokens. This token sequence is passed to the parsing 
+    //                  process. The LexerExpr type must conform to the 
+    //                  lexer interface described in the corresponding section
+    //                  of the documentation.
+    //  xpr:            The grammar object (encoding the parser grammar) to be
+    //                  used to match the token sequence generated by the lex 
+    //                  object instance. The ParserExpr type must conform to 
+    //                  the grammar interface described in the corresponding 
+    //                  section of the documentation.
+    //  attr:           The top level attribute passed to the parser. It will 
+    //                  be populated during the parsing of the input sequence.
+    //                  On exit it will hold the 'parser result' corresponding 
+    //                  to the matched input sequence.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer, typename ParserExpr>
+    inline bool
+    tokenize_and_parse(Iterator& first, Iterator last, Lexer const& lex,
+        ParserExpr const& xpr)
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        return compile<qi::domain>(xpr).parse(
+            iter, lex.end(), unused, unused, unused);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Attribute>
+    inline bool
+    tokenize_and_parse(Iterator& first, Iterator last, Lexer const& lex
+      , ParserExpr const& xpr, Attribute& attr)
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        return compile<qi::domain>(xpr).parse(
+            iter, lex.end(), unused, unused, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The tokenize_and_phrase_parse() function is one of the main Spirit API 
+    //  functions. It simplifies using a lexer as the underlying token source
+    //  while phrase parsing a given input sequence.
+    //
+    //  The function takes a pair of iterators spanning the underlying input 
+    //  stream to parse, the lexer object (built from the token definitions) 
+    //  and a parser object (built from the parser grammar definition). The 
+    //  additional skipper parameter will be used as the skip parser during
+    //  the parsing process.
+    //
+    //  The second version of this function additionally takes an attribute to 
+    //  be used as the top level data structure instance the parser should use 
+    //  to store the recognized input to.
+    //
+    //  The function returns true if the parsing succeeded (the given input
+    //  sequence has been successfully matched by the given grammar).
+    //
+    //  first, last:    The pair of iterators spanning the underlying input 
+    //                  sequence to parse. These iterators must at least 
+    //                  conform to the requirements of the std::intput_iterator 
+    //                  category.
+    //                  On exit the iterator 'first' will be updated to the 
+    //                  position right after the last successfully matched 
+    //                  token. 
+    //  lex:            The lexer object (encoding the token definitions) to be
+    //                  used to convert the input sequence into a sequence of 
+    //                  tokens. This token sequence is passed to the parsing 
+    //                  process. The LexerExpr type must conform to the 
+    //                  lexer interface described in the corresponding section
+    //                  of the documentation.
+    //  xpr:            The grammar object (encoding the parser grammar) to be
+    //                  used to match the token sequence generated by the lex 
+    //                  object instance. The ParserExpr type must conform to 
+    //                  the grammar interface described in the corresponding 
+    //                  section of the documentation.
+    //  skipper:        The skip parser to be used while parsing the given 
+    //                  input sequence. Note, the skip parser will have to 
+    //                  act on the same token sequence as the main parser 
+    //                  'xpr'.
+    //  post_skip:      The post_skip flag controls whether the function will
+    //                  invoke an additional post skip after the main parser
+    //                  returned.
+    //  attr:           The top level attribute passed to the parser. It will 
+    //                  be populated during the parsing of the input sequence.
+    //                  On exit it will hold the 'parser result' corresponding 
+    //                  to the matched input sequence.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Skipper>
+    inline bool
+    tokenize_and_phrase_parse(Iterator& first, Iterator last
+      , Lexer const& lex, ParserExpr const& xpr, Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip = skip_flag::postskip)
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper);
+
+        typedef
+            typename spirit::result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        typename Lexer::iterator_type end = lex.end();
+        if (!compile<qi::domain>(xpr).parse(
+                iter, end, unused, skipper_, unused))
+            return false;
+
+        // do a final post-skip
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(iter, end, skipper_);
+        return true;
+    }
+
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Skipper, typename Attribute>
+    inline bool
+    tokenize_and_phrase_parse(Iterator& first, Iterator last
+      , Lexer const& lex, ParserExpr const& xpr, Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip, Attribute& attr)
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper);
+
+        typedef
+            typename spirit::result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        typename Lexer::iterator_type end = lex.end();
+        if (!compile<qi::domain>(xpr).parse(
+                iter, end, unused, skipper_, attr))
+            return false;
+
+        // do a final post-skip
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(iter, end, skipper_);
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Skipper, typename Attribute>
+    inline bool
+    tokenize_and_phrase_parse(Iterator& first, Iterator last
+      , Lexer const& lex, ParserExpr const& xpr, Skipper const& skipper
+      , Attribute& attr)
+    {
+        return tokenize_and_phrase_parse(first, last, lex, xpr, skipper
+          , skip_flag::postskip, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    //  The tokenize() function is one of the main Spirit API functions. It 
+    //  simplifies using a lexer to tokenize a given input sequence. It's main
+    //  purpose is to use the lexer to tokenize all the input. 
+    //
+    //  The second version below discards all generated tokens afterwards. 
+    //  This is useful whenever all the needed functionality has been 
+    //  implemented directly inside the lexer semantic actions, which are being 
+    //  executed while the tokens are matched. 
+    //
+    //  The function takes a pair of iterators spanning the underlying input 
+    //  stream to scan, the lexer object (built from the token definitions),
+    //  and a (optional) functor being called for each of the generated tokens. 
+    //
+    //  The function returns true if the scanning of the input succeeded (the 
+    //  given input sequence has been successfully matched by the given token
+    //  definitions).
+    //
+    //  first, last:    The pair of iterators spanning the underlying input 
+    //                  sequence to parse. These iterators must at least 
+    //                  conform to the requirements of the std::intput_iterator 
+    //                  category.
+    //                  On exit the iterator 'first' will be updated to the 
+    //                  position right after the last successfully matched 
+    //                  token. 
+    //  lex:            The lexer object (encoding the token definitions) to be
+    //                  used to convert the input sequence into a sequence of 
+    //                  tokens. The LexerExpr type must conform to the 
+    //                  lexer interface described in the corresponding section
+    //                  of the documentation.
+    //  f:              A functor (callable object) taking a single argument of
+    //                  the token type and returning a bool, indicating whether
+    //                  the tokenization should be canceled.
+    //  initial_state:  The name of the state the lexer should start matching.
+    //                  The default value is zero, causing the lexer to start 
+    //                  in its 'INITIAL' state.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename Token, typename F>
+        bool tokenize_callback(Token const& t, F f)
+        {
+            return f(t);
+        }
+
+        template <typename Token, typename Eval>
+        bool tokenize_callback(Token const& t, phoenix::actor<Eval> const& f)
+        {
+            f(t);
+            return true;
+        }
+
+        template <typename Token>
+        bool tokenize_callback(Token const& t, void (*f)(Token const&))
+        {
+            f(t);
+            return true;
+        }
+
+        template <typename Token>
+        bool tokenize_callback(Token const& t, bool (*f)(Token const&))
+        {
+            return f(t);
+        }
+    }
+
+    template <typename Iterator, typename Lexer, typename F>
+    inline bool
+    tokenize(Iterator& first, Iterator last, Lexer const& lex, F f
+      , typename Lexer::char_type const* initial_state = 0)
+    {
+        typedef typename Lexer::iterator_type iterator_type;
+
+        iterator_type iter = lex.begin(first, last, initial_state);
+        iterator_type end = lex.end();
+        for (/**/; iter != end && token_is_valid(*iter); ++iter) 
+        {
+            if (!detail::tokenize_callback(*iter, f))
+                return false;
+        }
+        return (iter == end) ? true : false;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    inline bool
+    tokenize(Iterator& first, Iterator last, Lexer const& lex
+      , typename Lexer::char_type const* initial_state = 0)
+    {
+        typedef typename Lexer::iterator_type iterator_type;
+
+        iterator_type iter = lex.begin(first, last, initial_state);
+        iterator_type end = lex.end();
+
+        while (iter != end && token_is_valid(*iter))
+            ++iter;
+
+        return (iter == end) ? true : false;
+    }
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse_attr.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse_attr.hpp
new file mode 100644
index 0000000..98d191d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/lex/tokenize_and_parse_attr.hpp
@@ -0,0 +1,114 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+//  Copyright (c) 2009 Carl Barron
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+#if !defined(BOOST_SPIRIT_LEXER_PARSE_ATTR_MAY_27_2009_0926AM)
+#define BOOST_SPIRIT_LEXER_PARSE_ATTR_MAY_27_2009_0926AM
+
+#include <boost/spirit/home/lex/tokenize_and_parse.hpp>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_FILENAME_1 <boost/spirit/home/lex/tokenize_and_parse_attr.hpp>
+#define BOOST_PP_ITERATION_LIMITS (2, SPIRIT_ARGUMENTS_LIMIT)
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+#define BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE(z, n, A) BOOST_PP_CAT(A, n)&
+
+namespace boost { namespace spirit { namespace lex
+{
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline bool
+    tokenize_and_parse(Iterator& first, Iterator last, Lexer const& lex
+      , ParserExpr const& expr, BOOST_PP_ENUM_BINARY_PARAMS(N, A, & attr))
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+
+        typedef fusion::vector<
+            BOOST_PP_ENUM(N, BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE, A)
+        > vector_type;
+
+        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        return compile<qi::domain>(expr).parse(
+            iter, lex.end(), unused, unused, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Skipper, BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline bool
+    tokenize_and_phrase_parse(Iterator& first, Iterator last, Lexer const& lex
+      , ParserExpr const& expr, Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, & attr))
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then either the expression (expr) or skipper is not a valid
+        // spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, ParserExpr);
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper);
+
+        typedef
+            typename spirit::result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+
+        typedef fusion::vector<
+            BOOST_PP_ENUM(N, BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE, A)
+        > vector_type;
+
+        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
+        typename Lexer::iterator_type iter = lex.begin(first, last);
+        if (!compile<qi::domain>(expr).parse(
+                iter, lex.end(), unused, skipper_, attr))
+            return false;
+
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+
+    template <typename Iterator, typename Lexer, typename ParserExpr
+      , typename Skipper, BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline bool
+    tokenize_and_phrase_parse(Iterator& first, Iterator last, Lexer const& lex
+      , ParserExpr const& expr, Skipper const& skipper
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, & attr))
+    {
+        return tokenize_and_phrase_parse(first, last, expr, skipper
+          , skip_flag::postskip, BOOST_PP_ENUM_PARAMS(N, attr));
+    }
+
+}}}
+
+#undef BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE
+#undef N
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp
new file mode 100644
index 0000000..5a90d44
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_BIND_HPP
+#define PHOENIX_BIND_HPP
+
+#include <boost/spirit/home/phoenix/version.hpp>
+#include <boost/spirit/home/phoenix/bind/bind_function.hpp>
+#include <boost/spirit/home/phoenix/bind/bind_function_object.hpp>
+#include <boost/spirit/home/phoenix/bind/bind_member_function.hpp>
+#include <boost/spirit/home/phoenix/bind/bind_member_variable.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp
new file mode 100644
index 0000000..9121fdc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp
@@ -0,0 +1,58 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_BIND_BIND_FUNCTION_HPP
+#define PHOENIX_BIND_BIND_FUNCTION_HPP
+
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp>
+#include <boost/spirit/home/phoenix/bind/detail/function_ptr.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename RT>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<0>
+          , detail::function_ptr<0, RT, RT(*)()>
+        >::type>
+    bind(RT(*f)())
+    {
+        typedef detail::function_ptr<0, RT, RT(*)()> fp_type;
+        return compose<detail::function_eval<0> >(fp_type(f));
+    }
+
+    template <typename RT, typename T0, typename A0>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::function_ptr<1, RT, RT(*)(T0)>
+          , A0
+        >::type>
+    bind(RT(*f)(T0), A0 const& _0)
+    {
+        typedef detail::function_ptr<1, RT, RT(*)(T0)> fp_type;
+        return compose<detail::function_eval<1> >(fp_type(f), _0);
+    }
+
+    template <typename RT, typename T0, typename T1, typename A0, typename A1>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<2>
+          , detail::function_ptr<2, RT, RT(*)(T0, T1)>
+          , A0, A1
+        >::type>
+    bind(RT(*f)(T0, T1), A0 const& _0, A1 const& _1)
+    {
+        typedef detail::function_ptr<2, RT, RT(*)(T0, T1)> fp_type;
+        return compose<detail::function_eval<2> >(fp_type(f), _0, _1);
+    }
+
+    //  Bring in the rest of the function binders
+    #include <boost/spirit/home/phoenix/bind/detail/bind_function.hpp>
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp
new file mode 100644
index 0000000..752ae31
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp
@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP
+#define PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP
+
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename F>
+    inline actor<typename as_composite<detail::function_eval<0>, F>::type>
+    bind(F const& f)
+    {
+        return compose<detail::function_eval<0> >(f);
+    }
+
+    template <typename F, typename A0>
+    inline actor<typename as_composite<detail::function_eval<1>, F, A0>::type>
+    bind(F const& f, A0 const& _0)
+    {
+        return compose<detail::function_eval<1> >(f, _0);
+    }
+
+    template <typename F, typename A0, typename A1>
+    inline actor<typename as_composite<detail::function_eval<2>, F, A0, A1>::type>
+    bind(F const& f, A0 const& _0, A1 const& _1)
+    {
+        return compose<detail::function_eval<2> >(f, _0, _1);
+    }
+
+    //  Bring in the rest of the function object binders
+    #include <boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp>
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp
new file mode 100644
index 0000000..9d31a38
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp
@@ -0,0 +1,77 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP
+#define PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP
+
+#include <boost/spirit/home/phoenix/core/reference.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp>
+#include <boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename RT, typename ClassT, typename ClassA>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_function_ptr<0, RT, RT(ClassT::*)()>
+          , ClassA
+        >::type>
+    bind(RT(ClassT::*f)(), ClassA const& obj)
+    {
+        typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type;
+        return compose<detail::function_eval<1> >(fp_type(f), obj);
+    }
+
+    template <typename RT, typename ClassT, typename ClassA>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_function_ptr<0, RT, RT(ClassT::*)() const>
+          , ClassA
+        >::type>
+    bind(RT(ClassT::*f)() const, ClassA const& obj)
+    {
+        typedef detail::member_function_ptr<0, RT, RT(ClassT::*)() const> fp_type;
+        return compose<detail::function_eval<1> >(fp_type(f), obj);
+    }
+
+    template <typename RT, typename ClassT>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_function_ptr<0, RT, RT(ClassT::*)()>
+          , actor<reference<ClassT> >
+        >::type>
+    bind(RT(ClassT::*f)(), ClassT& obj)
+    {
+        typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type;
+        return compose<detail::function_eval<1> >(
+            fp_type(f)
+          , actor<reference<ClassT> >(reference<ClassT>(obj)));
+    }
+
+    template <typename RT, typename ClassT>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_function_ptr<0, RT, RT(ClassT::*)() const>
+          , actor<reference<ClassT> >
+        >::type>
+    bind(RT(ClassT::*f)() const, ClassT& obj)
+    {
+        typedef detail::member_function_ptr<0, RT, RT(ClassT::*)() const> fp_type;
+        return compose<detail::function_eval<1> >(
+            fp_type(f)
+          , actor<reference<ClassT> >(reference<ClassT>(obj)));
+    }
+
+    //  Bring in the rest of the function binders
+    #include <boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp>
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp
new file mode 100644
index 0000000..3d11351
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp
@@ -0,0 +1,105 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP
+#define PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/reference.hpp>
+#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        template <typename RT, typename MP>
+        struct member_variable
+        {
+            template <typename Class>
+            struct result
+            {
+                typedef typename boost::mpl::if_<
+                    boost::is_const<
+                        typename boost::remove_pointer<
+                            typename boost::remove_reference<Class>::type
+                        >::type
+                    >
+                  , const RT&
+                  , RT&
+                >::type type;
+            };
+
+            member_variable(MP mp)
+                : mp(mp) {}
+
+            template <typename Class>
+            RT& operator()(Class& obj) const
+            {
+                return obj.*mp;
+            }
+
+            template <typename Class>
+            RT& operator()(Class* obj) const
+            {
+                return obj->*mp;
+            }
+
+            template <typename Class>
+            RT const& operator()(Class const& obj) const
+            {
+                return obj.*mp;
+            }
+
+            template <typename Class>
+            RT const& operator()(Class const* obj) const
+            {
+                return obj->*mp;
+            }
+
+            MP mp;
+        };
+    }
+
+    template <typename RT, typename ClassT, typename ClassA>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_variable<RT, RT ClassT::*>
+          , ClassA
+        >::type>
+    bind(RT ClassT::*mp, ClassA const& obj)
+    {
+        typedef detail::member_variable<RT, RT ClassT::*> mp_type;
+        return compose<detail::function_eval<1> >(mp_type(mp), obj);
+    }
+
+    template <typename RT, typename ClassT>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<1>
+          , detail::member_variable<RT, RT ClassT::*>
+          , actor<reference<ClassT> >
+        >::type>
+    bind(RT ClassT::*mp, ClassT& obj)
+    {
+        typedef detail::member_variable<RT, RT ClassT::*> mp_type;
+        return compose<detail::function_eval<1> >(
+            mp_type(mp)
+          , actor<reference<ClassT> >(reference<ClassT>(obj)));
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp
new file mode 100644
index 0000000..8d6340d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp
@@ -0,0 +1,53 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_BIND_DETAIL_BIND_FUNCTION_HPP)
+#define PHOENIX_BIND_DETAIL_BIND_FUNCTION_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT),                              \
+    "boost/spirit/home/phoenix/bind/detail/bind_function.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <typename RT
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<N>
+          , detail::function_ptr<N, RT, RT(*)(BOOST_PP_ENUM_PARAMS(N, T))>
+          , BOOST_PP_ENUM_PARAMS(N, A)
+        >::type>
+    bind(RT(*f)(BOOST_PP_ENUM_PARAMS(N, T))
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        typedef detail::function_ptr<
+            N, RT, RT(*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type;
+        return compose<detail::function_eval<N> >(
+            fp_type(f), BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp
new file mode 100644
index 0000000..4e4984d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_BIND_DETAIL_BIND_FUNCTION_OBJECT_HPP)
+#define PHOENIX_BIND_DETAIL_BIND_FUNCTION_OBJECT_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT),                              \
+    "boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<typename as_composite<detail::function_eval<N>, F
+      , BOOST_PP_ENUM_PARAMS(N, A)>::type>
+    bind(F const& f, BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        return compose<detail::function_eval<N> >(f, BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp
new file mode 100644
index 0000000..315f56f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp
@@ -0,0 +1,132 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_BIND_DETAIL_BIND_MEMBER_FUNCTION_HPP)
+#define PHOENIX_BIND_DETAIL_BIND_MEMBER_FUNCTION_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT)),                \
+    "boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <typename RT
+      , typename ClassT
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+      , typename ClassA
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<BOOST_PP_INC(N)>
+          , detail::member_function_ptr<N,
+                RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))>
+          , ClassA, BOOST_PP_ENUM_PARAMS(N, A)
+        >::type>
+    bind(
+        RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T))
+      , ClassA const& obj
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        typedef detail::member_function_ptr<
+            N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type;
+        return compose<detail::function_eval<BOOST_PP_INC(N)> >(
+            fp_type(f), obj, BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+    template <typename RT
+      , typename ClassT
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+      , typename ClassA
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<BOOST_PP_INC(N)>
+          , detail::member_function_ptr<N,
+                RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const>
+          , ClassA, BOOST_PP_ENUM_PARAMS(N, A)
+        >::type>
+    bind(
+        RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) const
+      , ClassA const& obj
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        typedef detail::member_function_ptr<
+            N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> fp_type;
+        return compose<detail::function_eval<BOOST_PP_INC(N)> >(
+            fp_type(f), obj, BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+    template <typename RT
+      , typename ClassT
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<BOOST_PP_INC(N)>
+          , detail::member_function_ptr<N,
+                RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))>
+          , actor<reference<ClassT> >
+          , BOOST_PP_ENUM_PARAMS(N, A)
+        >::type>
+    bind(
+        RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T))
+      , ClassT& obj
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        typedef detail::member_function_ptr<
+            N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type;
+        return compose<detail::function_eval<BOOST_PP_INC(N)> >(
+            fp_type(f)
+          , actor<reference<ClassT> >(reference<ClassT>(obj))
+          , BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+    template <typename RT
+      , typename ClassT
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+      , BOOST_PP_ENUM_PARAMS(N, typename A)>
+    inline actor<
+        typename as_composite<
+            detail::function_eval<BOOST_PP_INC(N)>
+          , detail::member_function_ptr<N,
+                RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const>
+          , actor<reference<ClassT> >
+          , BOOST_PP_ENUM_PARAMS(N, A)
+        >::type>
+    bind(
+        RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) const
+      , ClassT& obj
+      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _))
+    {
+        typedef detail::member_function_ptr<
+            N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> fp_type;
+        return compose<detail::function_eval<BOOST_PP_INC(N)> >(
+            fp_type(f)
+          , actor<reference<ClassT> >(reference<ClassT>(obj))
+          , BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp
new file mode 100644
index 0000000..a2352cd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp
@@ -0,0 +1,99 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP)
+#define PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/dec.hpp>
+
+namespace boost { namespace phoenix { namespace detail
+{
+    template <int N>
+    struct function_ptr_impl
+    {
+        template <typename RT, typename FP>
+        struct impl;
+    };
+
+    template <int N, typename RT, typename FP>
+    struct function_ptr : function_ptr_impl<N>::template impl<RT, FP>
+    {
+        typedef typename function_ptr_impl<N>::template impl<RT, FP> base;
+        function_ptr(FP fp)
+            : base(fp) {}
+    };
+
+    template <>
+    struct function_ptr_impl<0>
+    {
+        template <typename RT, typename FP>
+        struct impl
+        {
+            typedef RT result_type;
+
+            impl(FP fp)
+                : fp(fp) {}
+
+            RT operator()() const
+            {
+                return fp();
+            }
+
+            FP fp;
+        };
+    };
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (1, PHOENIX_COMPOSITE_LIMIT,                                            \
+    "boost/spirit/home/phoenix/bind/detail/function_ptr.hpp"))
+#include BOOST_PP_ITERATE()
+
+}}} // namespace boost::phoenix::detail
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <>
+    struct function_ptr_impl<N>
+    {
+        template <typename RT, typename FP>
+        struct impl
+        {
+            template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+            struct result
+            {
+                typedef RT type;
+            };
+
+            impl(FP fp)
+                : fp(fp) {}
+
+            template <BOOST_PP_ENUM_PARAMS(N, typename A)>
+            RT operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const
+            {
+                return fp(BOOST_PP_ENUM_PARAMS(N, _));
+            }
+
+            FP fp;
+        };
+    };
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp
new file mode 100644
index 0000000..2c11510
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp
@@ -0,0 +1,119 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP)
+#define PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/utility/addressof.hpp>
+
+namespace boost { namespace phoenix { namespace detail
+{
+    template <int N>
+    struct member_function_ptr_impl
+    {
+        template <typename RT, typename FP>
+        struct impl;
+    };
+
+    template <int N, typename RT, typename FP>
+    struct member_function_ptr
+        : member_function_ptr_impl<N>::template impl<RT, FP>
+    {
+        typedef typename member_function_ptr_impl<N>::
+            template impl<RT, FP> base;
+        member_function_ptr(FP fp)
+            : base(fp) {}
+    };
+
+    template <>
+    struct member_function_ptr_impl<0>
+    {
+        template <typename RT, typename FP>
+        struct impl
+        {
+            template <typename Class>
+            struct result
+            {
+                typedef RT type;
+            };
+
+            impl(FP fp)
+                : fp(fp) {}
+
+            template <typename Class>
+            RT operator()(Class& obj) const
+            {
+                return (obj.*fp)();
+            }
+
+            template <typename Class>
+            RT operator()(Class* obj) const
+            {
+                return (obj->*fp)();
+            }
+
+            FP fp;
+        };
+    };
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (1, PHOENIX_COMPOSITE_LIMIT,                                            \
+    "boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp"))
+#include BOOST_PP_ITERATE()
+
+}}} // namespace boost::phoenix::detail
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <>
+    struct member_function_ptr_impl<N>
+    {
+        template <typename RT, typename FP>
+        struct impl
+        {
+            template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename T)>
+            struct result
+            {
+                typedef RT type;
+            };
+
+            impl(FP fp)
+                : fp(fp) {}
+
+            template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename A)>
+            RT operator()(Class& obj, BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const
+            {
+                return (obj.*fp)(BOOST_PP_ENUM_PARAMS(N, _));
+            }
+
+            template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename A)>
+            RT operator()(Class* obj, BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const
+            {
+                return (obj->*fp)(BOOST_PP_ENUM_PARAMS(N, _));
+            }
+
+            FP fp;
+        };
+    };
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp
new file mode 100644
index 0000000..7dfefb3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp
@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_HPP
+#define PHOENIX_CORE_HPP
+
+#include <boost/spirit/home/phoenix/version.hpp>
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/core/basic_environment.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/spirit/home/phoenix/core/as_actor.hpp>
+#include <boost/spirit/home/phoenix/core/is_actor.hpp>
+#include <boost/spirit/home/phoenix/core/argument.hpp>
+#include <boost/spirit/home/phoenix/core/value.hpp>
+#include <boost/spirit/home/phoenix/core/reference.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/nothing.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp
new file mode 100644
index 0000000..6ff48e9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp
@@ -0,0 +1,194 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_ACTOR_HPP
+#define PHOENIX_CORE_ACTOR_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+
+#if !defined(BOOST_RESULT_OF_NUM_ARGS)
+# define BOOST_RESULT_OF_NUM_ARGS PHOENIX_ACTOR_LIMIT
+#elif (BOOST_RESULT_OF_NUM_ARGS < PHOENIX_ACTOR_LIMIT)
+# error "BOOST_RESULT_OF_NUM_ARGS < PHOENIX_ACTOR_LIMIT"
+#endif
+
+#include <boost/spirit/home/phoenix/core/basic_environment.hpp>
+#include <boost/mpl/min.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/result_of.hpp>
+
+namespace boost { namespace phoenix
+{
+    // phoenix::void_ is the same as fusion::void_
+    typedef fusion::void_ void_;
+
+    namespace detail
+    {
+        //  Forward declarations. These will come in when we get to the
+        //  operator module, yet, the actor's assignment operator and index
+        //  operator are required to be members.
+
+        template <typename T0, typename T1>
+        struct make_assign_composite;
+
+        template <typename T0, typename T1>
+        struct make_index_composite;
+
+        template <typename BaseT0, typename BaseT1>
+        struct comma_result;
+
+        // error no arguments supplied
+        struct error_expecting_arguments
+        {
+            template <typename T>
+            error_expecting_arguments(T const&) {}
+        };
+    }
+
+    template <typename Eval, typename Env>
+    struct eval_result
+    {
+        typedef typename Eval::template result<Env>::type type;
+    };
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4522) // multiple assignment operators specified warning
+#endif
+
+    template <typename Eval>
+    struct actor : Eval
+    {
+        typedef actor<Eval> self_type;
+        typedef Eval eval_type;
+
+        template <class Sig> struct result {};
+
+        actor()
+            : Eval() {}
+
+        actor(Eval const& base)
+            : Eval(base) {}
+
+        template <typename T0>
+        explicit actor(T0 const& _0)
+            : Eval(_0) {}
+
+        template <typename T0, typename T1>
+        actor(T0 const& _0, T1 const& _1)
+            : Eval(_0, _1) {}
+
+        typedef typename
+            mpl::eval_if<
+                typename Eval::no_nullary // avoid calling eval_result when this is true
+              , mpl::identity<detail::error_expecting_arguments>
+              , eval_result<eval_type, basic_environment<> >
+            >::type
+        nullary_result;
+
+        actor& operator=(actor const& rhs)
+        {
+            Eval::operator=(rhs);
+            return *this;
+        }
+
+        actor& operator=(actor& rhs)
+        {
+            Eval::operator=(rhs);
+            return *this;
+        }
+
+        nullary_result
+        operator()() const
+        {
+            return eval_type::eval(basic_environment<>());
+        }
+
+        template <class F, class A0>
+        struct result<F(A0)>
+          : eval_result<
+                eval_type
+              , basic_environment<
+                    typename remove_reference<A0>::type
+                >
+            >
+        {};
+
+        template <typename T0>
+        typename result<actor(T0&)>::type
+        operator()(T0& _0) const
+        {
+            return eval_type::eval(basic_environment<T0>(_0));
+        }
+
+        template <class F, class A0, class A1>
+        struct result<F(A0,A1)>
+          : eval_result<
+                eval_type
+              , basic_environment<
+                    typename remove_reference<A0>::type
+                  , typename remove_reference<A1>::type
+                >
+            >
+        {};
+
+        template <typename T0, typename T1>
+        typename result<actor(T0&,T1&)>::type
+        operator()(T0& _0, T1& _1) const
+        {
+            return eval_type::eval(basic_environment<T0, T1>(_0, _1));
+        }
+
+        template <typename T1>
+        typename detail::make_assign_composite<self_type, T1>::type
+        operator=(T1 const& a1) const;
+
+        template <typename T1>
+        typename detail::make_index_composite<self_type, T1>::type
+        operator[](T1 const& a1) const;
+
+        //  Bring in the rest of the constructors and function call operators
+        #include <boost/spirit/home/phoenix/core/detail/actor.hpp>
+    };
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+    //  Forward declaration: The intent to overload the comma must be
+    //  stated early on to avoid the subtle problem that arises when
+    //  the header file where the comma operator overload is defined,
+    //  is not included by the client and the client attempts to use
+    //  the comma anyway.
+
+    namespace detail
+    {
+        template <typename BaseT0, typename BaseT1>
+        struct comma_result;
+    }
+
+    template <typename BaseT0, typename BaseT1>
+    typename detail::comma_result<BaseT0, BaseT1>::type
+    operator,(actor<BaseT0> const& a0, actor<BaseT1> const& a1);
+}}
+
+namespace boost
+{
+    template <typename Eval>
+    struct result_of<phoenix::actor<Eval>()>
+    {
+        typedef typename phoenix::actor<Eval>::nullary_result type;
+    };
+
+    template <typename Eval>
+    struct result_of<phoenix::actor<Eval> const()>
+        : result_of<phoenix::actor<Eval>()>
+    {};
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp
new file mode 100644
index 0000000..1679cb2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp
@@ -0,0 +1,99 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_ARGUMENT_HPP
+#define PHOENIX_CORE_ARGUMENT_HPP
+
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#define PHOENIX_DECLARE_ARG(z, n, data)                                       \
+    typedef actor<argument<n> >                                               \
+        BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type);              \
+    actor<argument<n> > const                                                 \
+        BOOST_PP_CAT(arg, BOOST_PP_INC(n)) = argument<n>();                   \
+    typedef actor<argument<n> >                                               \
+        BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type);                \
+    actor<argument<n> > const                                                 \
+        BOOST_PP_CAT(_, BOOST_PP_INC(n)) = argument<n>();
+
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        template <typename Arg>
+        struct error_argument_not_found {};
+        inline void test_invalid_argument(int) {}
+    }
+
+    template <int N>
+    struct argument
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                fusion::result_of::at<typename Env::tie_type, mpl::int_<N> >::type
+            type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename
+                mpl::if_<
+                    mpl::less<mpl::int_<N>, mpl::size<typename Env::args_type> >
+                  , int
+                  , detail::error_argument_not_found<argument<N> >
+                >::type
+            check_out_of_bounds;
+
+            detail::test_invalid_argument(check_out_of_bounds());
+            return fusion::at_c<N>(env.args());
+        }
+    };
+
+    namespace arg_names
+    {
+    //  Phoenix style names
+        typedef actor<argument<0> > arg1_type;
+        actor<argument<0> > const arg1 = argument<0>();
+        typedef actor<argument<1> > arg2_type;
+        actor<argument<1> > const arg2 = argument<1>();
+        typedef actor<argument<2> > arg3_type;
+        actor<argument<2> > const arg3 = argument<2>();
+
+    //  BLL style names
+        typedef actor<argument<0> > _1_type;
+        actor<argument<0> > const _1 = argument<0>();
+        typedef actor<argument<1> > _2_type;
+        actor<argument<1> > const _2 = argument<1>();
+        typedef actor<argument<2> > _3_type;
+        actor<argument<2> > const _3 = argument<2>();
+
+    //  Bring in the rest or the Phoenix style arguments (arg4 .. argN+1)
+    //  and BLL style arguments (_4 .. _N+1), using PP
+        BOOST_PP_REPEAT_FROM_TO(
+            3, PHOENIX_ARG_LIMIT, PHOENIX_DECLARE_ARG, _)
+    }
+}}
+
+#undef PHOENIX_DECLARE_ARG
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp
new file mode 100644
index 0000000..36f0aac
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp
@@ -0,0 +1,62 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_AS_ACTOR_HPP
+#define PHOENIX_CORE_AS_ACTOR_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename T>
+    struct as_actor_base; // defined in value.hpp
+
+    template <typename Base>
+    struct as_actor_base<actor<Base> >
+    {
+        typedef Base type;
+
+        static Base const&
+        convert(actor<Base> const& x)
+        {
+            return x;
+        }
+    };
+
+    template <>
+    struct as_actor_base<fusion::void_>
+    {
+        typedef fusion::void_ type;
+        struct error_attempting_to_convert_void_type_to_an_actor {};
+
+        static void
+        convert(error_attempting_to_convert_void_type_to_an_actor);
+    };
+
+    template <>
+    struct as_actor_base<void>
+    {
+        typedef void type;
+        struct error_attempting_to_convert_void_type_to_an_actor {};
+
+        static void
+        convert(error_attempting_to_convert_void_type_to_an_actor);
+    };
+
+    template <typename T>
+    struct as_actor
+    {
+        typedef actor<typename as_actor_base<T>::type> type;
+
+        static type
+        convert(T const& x)
+        {
+            return as_actor_base<T>::convert(x);
+        }
+    };
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp
new file mode 100644
index 0000000..5ef8223
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp
@@ -0,0 +1,81 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_BASIC_ENVIRONMENT_HPP
+#define PHOENIX_CORE_BASIC_ENVIRONMENT_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/mpl/remove.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/fusion/include/mpl.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <
+        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            PHOENIX_ARG_LIMIT, typename T, fusion::void_)>
+    class basic_environment
+    {
+        typedef
+            mpl::BOOST_PP_CAT(vector, PHOENIX_ARG_LIMIT)<
+                BOOST_PP_ENUM_PARAMS(PHOENIX_ARG_LIMIT, T)>
+        args_with_void_type;
+
+    public:
+
+        // args_type: the list of types in an mpl::sequence
+        typedef typename 
+            mpl::remove<args_with_void_type, fusion::void_>::type 
+        args_type;
+        
+        // tie_type: a fusion::tuple of references
+        typedef typename
+            fusion::result_of::as_vector<
+                typename mpl::transform<
+                    args_type, boost::add_reference<mpl::_1> 
+                >::type
+            >::type
+        tie_type;
+
+        basic_environment()
+            : args_() {}
+
+        template <typename U0>
+        explicit basic_environment(U0& _0)
+            : args_(_0) {}
+
+        template <typename U0, typename U1>
+        basic_environment(U0& _0, U1& _1)
+            : args_(_0, _1) {}
+
+        //  Bring in the rest of the constructors
+        #include <boost/spirit/home/phoenix/core/detail/basic_environment.hpp>
+
+        tie_type const& 
+        args() const
+        {
+            return args_;
+        }
+
+        tie_type& 
+        args()
+        {
+            return args_;
+        }
+
+    private:
+
+        tie_type args_;
+    };
+}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp
new file mode 100644
index 0000000..d536113
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp
@@ -0,0 +1,118 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_COMPOSE_HPP
+#define PHOENIX_CORE_COMPOSE_HPP
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/value.hpp>
+#include <boost/spirit/home/phoenix/core/as_actor.hpp>
+
+#define PHOENIX_AS_ACTOR(z, n, data)                                            \
+    typename mpl::eval_if<                                                      \
+        is_same<BOOST_PP_CAT(T, n), fusion::void_>                              \
+      , mpl::identity<fusion::void_>                                            \
+      , as_actor_base<BOOST_PP_CAT(T, n)>                                       \
+    >::type
+
+namespace boost { namespace phoenix
+{
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  as_composite<EvalPolicy, T0,... TN> metafunction
+//
+//      Create a composite given an EvalPolicy and types T0..TN.
+//      The types are converted to an actor through the as_actor
+//      metafunction (see as_actor.hpp).
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <
+        typename EvalPolicy
+      , BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            PHOENIX_COMPOSITE_LIMIT, typename T, fusion::void_)>
+    struct as_composite
+    {
+        typedef composite<
+            EvalPolicy
+          , fusion::vector<
+                BOOST_PP_ENUM(PHOENIX_COMPOSITE_LIMIT, PHOENIX_AS_ACTOR, _)>
+        >
+        type;
+    };
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  compose functions
+//
+//      Usage:
+//
+//          compose<EvalPolicy>(_0, _1,... _N)
+//
+//      Returns a composite given an EvalPolicy and arguments _0.._N. 
+//      The arguments are converted to an actor through the as_actor
+//      metafunction (see as_actor.hpp).
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <typename EvalPolicy>
+    inline actor<typename as_composite<EvalPolicy>::type>
+    compose()
+    {
+        return actor<typename as_composite<EvalPolicy>::type>();
+    }
+
+    template <typename EvalPolicy, typename T0>
+    inline actor<typename as_composite<EvalPolicy, T0>::type>
+    compose(T0 const& _0)
+    {
+        return actor<typename as_composite<EvalPolicy, T0>::type>(
+            as_actor<T0>::convert(_0)
+        );
+    }
+
+    template <typename EvalPolicy, typename T0, typename T1>
+    inline actor<typename as_composite<EvalPolicy, T0, T1>::type>
+    compose(T0 const& _0, T1 const& _1)
+    {
+        return actor<typename as_composite<EvalPolicy, T0, T1>::type>(
+            as_actor<T0>::convert(_0)
+          , as_actor<T1>::convert(_1)
+        );
+    }
+
+    //  Bring in the the rest of the compose overloads
+    #include <boost/spirit/home/phoenix/core/detail/compose.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  re_curry<EvalPolicy, T0,...TN>
+//
+//      returns the result of re currying T0..TN using EvalPolicy.
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <
+        typename EvalPolicy
+      , BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            PHOENIX_COMPOSITE_LIMIT, typename T, fusion::void_)>
+    struct re_curry
+    {
+        typedef actor<
+            typename as_composite<
+                EvalPolicy
+              , BOOST_PP_ENUM_PARAMS(PHOENIX_COMPOSITE_LIMIT, T)>::type
+            >
+        type;
+    };
+}}
+
+#undef PHOENIX_AS_ACTOR
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp
new file mode 100644
index 0000000..283bdc2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp
@@ -0,0 +1,96 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_COMPOSITE_HPP
+#define PHOENIX_CORE_COMPOSITE_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/spirit/home/phoenix/core/is_actor.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/mpl.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        template <int N>
+        struct composite_eval;
+        
+        struct compute_no_nullary
+        {
+            template <typename State, typename T>
+            struct apply
+            {
+                typedef typename 
+                    mpl::or_<typename T::no_nullary, State>::type
+                type;
+            };
+        };
+    }
+
+    template <typename EvalPolicy, typename EvalTuple>
+    struct composite : EvalTuple
+    {
+        typedef EvalTuple base_type;
+        typedef composite<EvalPolicy, EvalTuple> self_type;
+        typedef EvalPolicy eval_policy_type;
+        
+        typedef typename
+            mpl::fold<
+                EvalTuple
+              , mpl::false_
+              , detail::compute_no_nullary
+            >::type
+        no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef
+                typename detail::composite_eval<
+                    fusion::result_of::size<base_type>::value>::
+                template result<self_type, Env>::type
+            type;
+        };
+
+        composite()
+            : base_type() {}
+
+        composite(base_type const& base)
+            : base_type(base) {}
+
+        template <typename U0>
+        composite(U0& _0)
+            : base_type(_0) {}
+
+        template <typename U0, typename U1>
+        composite(U0& _0, U1& _1)
+            : base_type(_0, _1) {}
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename result<Env>::type return_type;
+            return detail::
+                composite_eval<fusion::result_of::size<base_type>::value>::template
+                    call<return_type>(*this, env);
+        }
+
+        //  Bring in the rest of the constructors
+        #include <boost/spirit/home/phoenix/core/detail/composite.hpp>
+    };
+
+    //  Bring in the detail::composite_eval<0..N> definitions
+    #include <boost/spirit/home/phoenix/core/detail/composite_eval.hpp>
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp
new file mode 100644
index 0000000..66666c5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp
@@ -0,0 +1,65 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_CORE_DETAIL_ACTOR_HPP
+#define PHOENIX_CORE_DETAIL_ACTOR_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, PHOENIX_ACTOR_LIMIT,                                                \
+    "boost/spirit/home/phoenix/core/detail/actor.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
+        : Eval(BOOST_PP_ENUM_PARAMS(N, _)) {}
+
+    template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)>
+    struct result<F(BOOST_PP_ENUM_PARAMS(N, A))>
+      : eval_result<
+            eval_type
+          , basic_environment<
+                BOOST_PP_ENUM_BINARY_PARAMS(
+                    N
+                  , typename remove_reference<A
+                  , >::type BOOST_PP_INTERCEPT
+                )
+            >
+        >
+    {};
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    typename result<
+        actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & BOOST_PP_INTERCEPT))
+    >::type
+    operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _)) const
+    {
+        return eval_type::eval(
+            basic_environment<BOOST_PP_ENUM_PARAMS(N, T)>(
+                BOOST_PP_ENUM_PARAMS(N, _))
+        );
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp
new file mode 100644
index 0000000..986ecf2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp
@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP
+#define PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, PHOENIX_ARG_LIMIT,                                                  \
+    "boost/spirit/home/phoenix/core/detail/basic_environment.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+    basic_environment(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _))
+        : args_(BOOST_PP_ENUM_PARAMS(N, _)) {}
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp
new file mode 100644
index 0000000..945a3d3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp
@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP
+#define PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+
+#define PHOENIX_AS_ACTOR_CONVERT(z, n, data)                                    \
+    as_actor<BOOST_PP_CAT(T, n)>::convert(BOOST_PP_CAT(_, n))
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, PHOENIX_COMPOSITE_LIMIT,                                            \
+    "boost/spirit/home/phoenix/core/detail/compose.hpp"))
+#include BOOST_PP_ITERATE()
+
+#undef PHOENIX_AS_ACTOR_CONVERT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <typename EvalPolicy, BOOST_PP_ENUM_PARAMS(N, typename T)>
+    inline actor<
+        typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type>
+    compose(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
+    {
+        return actor<
+            typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type>(
+                BOOST_PP_ENUM(N, PHOENIX_AS_ACTOR_CONVERT, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp
new file mode 100644
index 0000000..6970f7c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_HPP
+#define PHOENIX_CORE_DETAIL_COMPOSITE_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, PHOENIX_COMPOSITE_LIMIT,                                            \
+    "boost/spirit/home/phoenix/core/detail/composite.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+    composite(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _))
+        : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp
new file mode 100644
index 0000000..14f12af
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP
+#define PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+
+    namespace detail
+    {
+        template <int N>
+        struct composite_eval;
+
+        template <>
+        struct composite_eval<0>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename Composite::eval_policy_type::
+                    template result<Env>::type
+                type;
+            };
+
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& /*composite*/, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(env);
+            }
+        };
+
+        template <typename Actor, typename Env>
+        struct eval_is_actor
+            : is_actor<typename Actor::template result<Env>::type> {};
+
+        template <typename Actor, typename Env>
+        struct eval_is_void
+            : is_same<typename Actor::template result<Env>::type, fusion::void_> {};
+    }
+
+#define PHOENIX_GET_ACTOR_TYPE(z, n, data)                                      \
+    typedef                                                                     \
+        typename fusion::result_of::value_at_c<Composite, n>::type              \
+    BOOST_PP_CAT(actor, n);
+
+#define PHOENIX_GET_ACTOR(z, n, data)                                           \
+    fusion::at_c<n>(composite)
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (1, PHOENIX_COMPOSITE_LIMIT,                                            \
+    "boost/spirit/home/phoenix/core/detail/composite_eval.hpp"))
+#include BOOST_PP_ITERATE()
+
+#undef PHOENIX_GET_ACTOR
+#undef PHOENIX_GET_ACTOR_TYPE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    namespace detail
+    {
+        template <>
+        struct composite_eval<N>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                BOOST_PP_REPEAT(N, PHOENIX_GET_ACTOR_TYPE, _)
+
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, BOOST_PP_ENUM_PARAMS(N, actor)
+                    >::type
+                type;
+            };
+
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, BOOST_PP_ENUM(N, PHOENIX_GET_ACTOR, _));
+            }
+        };
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp
new file mode 100644
index 0000000..711b32c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp
@@ -0,0 +1,142 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP)
+#define PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+// we assume that mpl::vectorN, where N = PHOENIX_COMPOSITE_LIMIT
+// is included already.
+
+namespace boost { namespace phoenix { namespace detail
+{
+    template <int N>
+    struct function_eval;
+
+    template <>
+    struct function_eval<0>
+    {
+        template <typename Env, typename F>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type 
+                >::type
+            fn;
+            typedef typename fn::result_type type;
+        };
+
+        template <typename RT, typename Env, typename F>
+        static RT
+        eval(Env const& env, F const& f)
+        {
+            return f.eval(env)();
+        }
+    };
+
+    template <typename T>
+    T& help_rvalue_deduction(T& x)
+    {
+        return x;
+    }
+
+    template <typename T>
+    T const& help_rvalue_deduction(T const& x)
+    {
+        return x;
+    }
+
+// When we call f(_0, _1...) we remove the reference when deducing f's
+// return type. $$$ Explain why $$$
+
+#define PHOENIX_GET_ARG(z, n, data)                                             \
+    typedef typename                                                            \
+        remove_reference<                                                       \
+            typename BOOST_PP_CAT(A, n)::template result<Env>::type             \
+        >::type                                                                 \
+    BOOST_PP_CAT(a, n);
+
+#define PHOENIX_EVAL_ARG(z, n, data)                                            \
+    help_rvalue_deduction(BOOST_PP_CAT(_, n).eval(env))
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (1, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT),                              \
+    "boost/spirit/home/phoenix/core/detail/function_eval.hpp"))
+#include BOOST_PP_ITERATE()
+
+}}} // namespace boost::phoenix::detail
+
+#undef PHOENIX_GET_ARG
+#undef PHOENIX_EVAL_ARG
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <>
+    struct function_eval<N>
+    {
+        template <typename Env, typename F
+          , BOOST_PP_ENUM_PARAMS(N, typename A)>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type 
+                >::type
+            fn;
+            BOOST_PP_REPEAT(N, PHOENIX_GET_ARG, _)
+
+            typedef BOOST_PP_CAT(mpl::vector, N)
+                <BOOST_PP_ENUM_PARAMS(N, a)>
+            args;
+
+            typedef typename
+                fn::template result<BOOST_PP_ENUM_PARAMS(N, a)>
+            function_apply;
+
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+
+        template <typename RT, typename Env, typename F
+          , BOOST_PP_ENUM_PARAMS(N, typename A)>
+        static RT
+        eval(Env const& env, F const& f
+          , BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _))
+        {
+            return f.eval(env)(BOOST_PP_ENUM(N, PHOENIX_EVAL_ARG, _));
+        }
+    };
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp
new file mode 100644
index 0000000..ba0e77c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp
@@ -0,0 +1,29 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_IS_ACTOR_HPP
+#define PHOENIX_CORE_IS_ACTOR_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace phoenix
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+//  is_actor<T>
+//
+//      Tests if T is an actor. Evaluates to mpl::true_ or mpl::false_
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct is_actor : mpl::false_ {};
+
+    template <typename Base>
+    struct is_actor<actor<Base> > : mpl::true_ {};
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp
new file mode 100644
index 0000000..50c7573
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_LIMITS_HPP
+#define PHOENIX_CORE_LIMITS_HPP
+
+#include <boost/preprocessor/dec.hpp>
+
+#if !defined(PHOENIX_LIMIT)
+# define PHOENIX_LIMIT 10
+#elif (PHOENIX_LIMIT < 5)
+# error "PHOENIX_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_ARG_LIMIT)
+# define PHOENIX_ARG_LIMIT PHOENIX_LIMIT
+#elif (PHOENIX_ARG_LIMIT < 5)
+# error "PHOENIX_ARG_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_ACTOR_LIMIT)
+# define PHOENIX_ACTOR_LIMIT PHOENIX_LIMIT
+#elif (PHOENIX_ACTOR_LIMIT > PHOENIX_ARG_LIMIT)
+# error "PHOENIX_ACTOR_LIMIT > PHOENIX_ARG_LIMIT"
+#elif (PHOENIX_ACTOR_LIMIT < 3)
+# error "PHOENIX_ACTOR_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_COMPOSITE_LIMIT)
+# define PHOENIX_COMPOSITE_LIMIT PHOENIX_LIMIT
+#elif (PHOENIX_COMPOSITE_LIMIT < 5)
+# error "PHOENIX_COMPOSITE_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_MEMBER_LIMIT)
+# define PHOENIX_MEMBER_LIMIT BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT))
+#elif (PHOENIX_MEMBER_LIMIT > PHOENIX_COMPOSITE_LIMIT)
+# error "PHOENIX_MEMBER_LIMIT > PHOENIX_COMPOSITE_LIMIT"
+#elif (PHOENIX_MEMBER_LIMIT < 3)
+# error "PHOENIX_MEMBER_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_CATCH_LIMIT)
+# define PHOENIX_CATCH_LIMIT BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT)
+#elif (PHOENIX_CATCH_LIMIT < 1)
+# error "PHOENIX_CATCH_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_DYNAMIC_LIMIT)
+# define PHOENIX_DYNAMIC_LIMIT PHOENIX_LIMIT
+#elif (PHOENIX_DYNAMIC_LIMIT < 1)
+# error "PHOENIX_DYNAMIC_LIMIT is set too low"
+#endif
+
+#if !defined(PHOENIX_LOCAL_LIMIT)
+# define PHOENIX_LOCAL_LIMIT PHOENIX_LIMIT
+#elif (PHOENIX_LOCAL_LIMIT < 3)
+# error "PHOENIX_LOCAL_LIMIT is set too low"
+#endif
+
+
+#if !defined(FUSION_MAX_VECTOR_SIZE)
+# define FUSION_MAX_VECTOR_SIZE PHOENIX_LIMIT
+#elif (FUSION_MAX_VECTOR_SIZE < PHOENIX_LIMIT)
+# error "FUSION_MAX_VECTOR_SIZE < PHOENIX_LIMIT"
+#endif
+
+// this include will bring in mpl::vectorN and 
+// fusion::vectorN where N is PHOENIX_LIMIT
+#include <boost/fusion/include/vector.hpp>
+
+// for some reason, this must be included now to make
+// detail/type_deduction.hpp compile. $$$ TODO: Investigate further $$$
+#include <boost/mpl/vector/vector20.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp
new file mode 100644
index 0000000..029fbbf
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_NOTHING_HPP
+#define PHOENIX_CORE_NOTHING_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace phoenix
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+//  null_actor
+//
+//      A actor that does nothing (a "bum", if you will :-).
+//
+///////////////////////////////////////////////////////////////////////////////
+    struct null_actor
+    {
+        typedef mpl::false_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef void type;
+        };
+
+        template <typename Env>
+        void
+        eval(Env const&) const
+        {
+        }
+    };
+
+    actor<null_actor> const nothing = null_actor();
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp
new file mode 100644
index 0000000..2e1f588
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp
@@ -0,0 +1,80 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_REFERENCE_HPP
+#define PHOENIX_CORE_REFERENCE_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename T>
+    struct reference
+    {
+        // $$$ TODO: a better (user friendly) static assert
+        BOOST_STATIC_ASSERT(
+            mpl::not_<is_reference<T> >::value != 0);
+
+        typedef mpl::false_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef T& type;
+        };
+
+        reference(T& arg)
+            : ref(arg) {}
+
+        template <typename Env>
+        T& eval(Env const&) const
+        {
+            return ref;
+        }
+
+        T& ref;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        reference& operator= (reference const&);
+    };
+
+    template <typename T>
+    inline actor<reference<T> > const
+    ref(T& v)
+    {
+        return reference<T>(v);
+    }
+
+    template <typename T>
+    inline actor<reference<T const> > const
+    cref(T const& v)
+    {
+        return reference<T const>(v);
+    }
+
+    namespace detail
+    {
+        struct error_attempting_to_convert_an_actor_to_a_reference {};
+    }
+
+    template <typename Base>
+    void
+    ref(actor<Base> const& v
+        , detail::error_attempting_to_convert_an_actor_to_a_reference
+            = detail::error_attempting_to_convert_an_actor_to_a_reference());
+
+    template <typename Base>
+    void
+    cref(actor<Base> const& v
+        , detail::error_attempting_to_convert_an_actor_to_a_reference
+            = detail::error_attempting_to_convert_an_actor_to_a_reference());
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp
new file mode 100644
index 0000000..a275a7d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp
@@ -0,0 +1,158 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_CORE_VALUE_HPP
+#define PHOENIX_CORE_VALUE_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/spirit/home/phoenix/core/as_actor.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/is_function.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost { namespace phoenix
+{
+    namespace meta
+    {
+        template<typename T>
+        struct const_ref
+            : add_reference<typename add_const<T>::type>
+        {};
+
+        template<typename T>
+        struct argument_type
+            : mpl::eval_if<
+            is_function<typename remove_pointer<T>::type>,
+            mpl::identity<T>,
+            const_ref<T> >
+        {
+            typedef T type;
+        };
+    }
+
+    template <typename T>
+    struct value
+    {
+        BOOST_STATIC_ASSERT(
+            mpl::not_<is_reference<T> >::value != 0);
+
+        typedef mpl::false_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef T type;
+        };
+
+        value()
+            : val() {}
+
+        value(T const& arg)
+            : val(arg) {}
+
+        template <typename Env>
+        T const&
+        eval(Env const&) const
+        {
+            return val;
+        }
+
+        T val;
+    };
+
+    template <typename Actor>
+    struct actor_value
+    {
+        typedef typename Actor::no_nullary no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename eval_result<Actor, Env>::type
+                >::type
+            type;
+        };
+
+        actor_value(Actor const& actor)
+            : actor(actor) {}
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return actor.eval(env);
+        }
+
+        Actor actor;
+    };
+
+    template <typename T>
+    inline typename as_actor<T>::type
+    val(T const& v)
+    {
+        return as_actor<T>::convert(v);
+    }
+
+    template <typename Derived>
+    inline actor<actor_value<Derived> >
+    val(actor<Derived> const& actor)
+    {
+        return actor_value<Derived>(actor);
+    }
+
+    template <typename T>
+    struct as_actor_base
+    {
+        typedef value<T> type;
+
+        static value<T>
+        convert(typename meta::argument_type<T>::type x)
+        {
+            return value<T>(x);
+        }
+    };
+
+    // Sometimes it is necessary to auto-convert references to
+    // a value<T>. This happens when we are re-currying. This
+    // cannot happen through the standard public actor interfaces.
+    template <typename T>
+    struct as_actor_base<T&>
+    {
+        typedef value<T> type;
+
+        static value<T>
+        convert(T& x)
+        {
+            return value<T>(x);
+        }
+    };
+
+    template <typename T, int N>
+    struct as_actor_base<T[N]>
+    {
+        typedef value<T const*> type;
+
+        static value<T const*>
+        convert(T const x[N])
+        {
+            return value<T const*>(x);
+        }
+    };
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp
new file mode 100644
index 0000000..ad1fdb4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_DETAIL_LOCAL_REFERENCE_HPP
+#define PHOENIX_DETAIL_LOCAL_REFERENCE_HPP
+
+#include <boost/utility/addressof.hpp>
+
+namespace boost { namespace phoenix { namespace detail
+{
+    template <typename T>
+    struct local_reference
+    { 
+        typedef T type;
+    
+        explicit local_reference(T& t): t_(boost::addressof(t)) {}
+        operator T& () const { return *t_; }
+        local_reference& operator=(T const& x) { *t_ = x; return *this; }
+        local_reference const& operator=(T const& x) const { *t_ = x; return *this; }
+        T& get() const { return *t_; }
+        T* get_pointer() const { return t_; }
+    
+    private:
+    
+        T* t_;
+    };
+    
+    template <typename T>
+    struct unwrap_local_reference
+    {
+        typedef T type; // T should be a reference
+    };
+
+    template <typename T>
+    struct unwrap_local_reference<local_reference<T> >
+    {
+        typedef T type; // unwrap the reference; T is a value
+    };
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp
new file mode 100644
index 0000000..b99ea1e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp
@@ -0,0 +1,497 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_DETAIL_TYPE_DEDUCTION_HPP
+#define PHOENIX_DETAIL_TYPE_DEDUCTION_HPP
+
+/*=============================================================================
+
+    Return Type Deduction
+    [JDG Sept. 15, 2003]
+
+    Before C++ adopts the typeof, there is currently no way to deduce the
+    result type of an expression such as x + y. This deficiency is a major
+    problem with template metaprogramming; for example, when writing
+    forwarding functions that attempt to capture the essence of an
+    expression inside a function. Consider the std::plus<T>:
+
+        template <typename T>
+        struct plus : public binary_function<T, T, T>
+        {
+            T operator()(T const& x, T const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    What's wrong with this? Well, this functor does not accurately capture
+    the behavior of the plus operator. 1) It does not handle the case where
+    x and y are of different types (e.g. x is short and y is int). 2) It
+    assumes that the arguments and return type are the same (i.e. when
+    adding a short and an int, the return type ought to be an int). Due to
+    these shortcomings, std::plus<T>(x, y) is a poor substitute for x + y.
+
+    The case where x is short and y is int does not really expose the
+    problem. We can simply use std::plus<int> and be happy that the
+    operands x and y will simply be converted to an int. The problem
+    becomes evident when an operand is a user defined type such as bigint.
+    Here, the conversion to bigint is simply not acceptable. Even if the
+    unnecessary conversion is tolerable, in generic code, it is not always
+    possible to choose the right T type that can accomodate both x and y
+    operands.
+
+    To truly model the plus operator, what we need is a polymorphic functor
+    that can take arbitrary x and y operands. Here's a rough schematic:
+
+        struct plus
+        {
+            template <typename X, typename Y>
+            unspecified-type
+            operator()(X const& x, Y const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    Now, we can handle the case where X and Y are arbitrary types. We've
+    solved the first problem. To solve the second problem, we need some
+    form of return type deduction mechanism. If we had the typeof, it would
+    be something like:
+
+        template <typename X, typename Y>
+        typeof(X() + Y())
+        operator()(X const& x, Y const& y) const
+        {
+            return x + y;
+        }
+
+    Without the typeof facility, it is only possible to wrap an expression
+    such as x + y in a function or functor if we are given a hint that
+    tells us what the actual result type of such an expression is. Such a
+    hint can be in the form of a metaprogram, that, given the types of the
+    arguments, will return the result type. Example:
+
+        template <typename X, typename Y>
+        struct result_of_plus
+        {
+            typedef unspecified-type type;
+        };
+
+    Given a result_of_plus metaprogram, we can complete our polymorphic
+    plus functor:
+
+        struct plus
+        {
+            template <typename X, typename Y>
+            typename result_of_plus<X, Y>::type
+            operator()(X const& x, Y const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    The process is not automatic. We have to specialize the metaprogram for
+    specific argument types. Examples:
+
+        template <>
+        struct result_of_plus<short, int>
+        {
+            typedef int type;
+        };
+
+        template <typename T>
+        struct result_of_plus<std::complex<T>, std::complex<T> >
+        {
+            typedef std::complex<T> type;
+        };
+
+    To make it easier for the user, specializations are provided for common
+    types such as primitive c++ types (e.g. int, char, double, etc.), and
+    standard types (e.g. std::complex, iostream, std containers and
+    iterators).
+
+    To further improve the ease of use, for user defined classes, we can
+    supply a few more basic specializations through metaprogramming using
+    heuristics based on canonical operator rules (Such heuristics can be
+    found in the LL and Phoenix, for example). For example, it is rather
+    common that the result of x += y is X& or the result of x || y is a
+    bool. The client is out of luck if her classes do not follow the
+    canonical rules. She'll then have to supply her own specialization.
+
+    The type deduction mechanism demostrated below approaches the problem
+    not through specialization and heuristics, but through a limited form
+    of typeof mechanism. The code does not use heuristics, hence, no
+    guessing games. The code takes advantage of the fact that, in general,
+    the result type of an expression is related to one its arguments' type.
+    For example, x + y, where x has type int and y has type double, has the
+    result type double (the second operand type). Another example, x[y]
+    where x is a vector<T> and y is a std::size_t, has the result type
+    vector<T>::reference (the vector<T>'s reference type type).
+
+    The limited form of type deduction presented can detect common
+    relations if the result of a binary or unary operation, given arguments
+    x and y with types X and Y (respectively), is X, Y, X&, Y&, X*, Y*, X
+    const*, Y const*, bool, int, unsigned, double, container and iterator
+    elements (e.g the T, where X is: T[N], T*, vector<T>, map<T>,
+    vector<T>::iterator). More arguments/return type relationships can be
+    established if needed.
+
+    A set of overloaded test(T) functions capture these argument related
+    types. Each test(T) function returns a distinct type that can be used
+    to determine the exact type of an expression.
+
+    Consider:
+
+        template <typename X, typename Y>
+        x_value_type
+        test(X const&);
+
+        template <typename X, typename Y>
+        y_value_type
+        test(Y const&);
+
+    Given an expression x + y, where x is int and y is double, the call to:
+
+        test<int, double>(x + y)
+
+    will return a y_value_type.
+
+    Now, if we rig x_value_type and y_value_type such that both have unique
+    sizes, we can use sizeof(test<X, Y>(x + y)) to determine if the result
+    type is either X or Y.
+
+    For example, if:
+
+        sizeof(test<X, Y>(x + y)) == sizeof(y_value_type)
+
+    then, we know for sure that the result of x + y has type Y.
+
+    The same basic scheme can be used to detect more argument-dependent
+    return types where the sizeof the test(T) return type is used to index
+    through a boost::mpl vector which holds each of the corresponding
+    result types.
+
+==============================================================================*/
+#include <boost/mpl/vector/vector20.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/spirit/home/phoenix/detail/local_reference.hpp>
+
+namespace boost
+{
+    struct error_cant_deduce_type {};
+}
+
+namespace boost { namespace type_deduction_detail
+{
+    typedef char(&bool_value_type)[1];
+    typedef char(&int_value_type)[2];
+    typedef char(&uint_value_type)[3];
+    typedef char(&double_value_type)[4];
+
+    typedef char(&bool_reference_type)[5];
+    typedef char(&int_reference_type)[6];
+    typedef char(&uint_reference_type)[7];
+    typedef char(&double_reference_type)[8];
+
+    typedef char(&x_value_type)[9];
+    typedef char(&x_reference_type)[10];
+    typedef char(&x_const_pointer_type)[11];
+    typedef char(&x_pointer_type)[12];
+
+    typedef char(&y_value_type)[13];
+    typedef char(&y_reference_type)[14];
+    typedef char(&y_const_pointer_type)[15];
+    typedef char(&y_pointer_type)[16];
+
+    typedef char(&container_reference_type)[17];
+    typedef char(&container_const_reference_type)[18];
+    typedef char(&container_mapped_type)[19];
+
+    typedef char(&cant_deduce_type)[20];
+
+    template <typename T, typename Plain = typename remove_cv<T>::type>
+    struct is_basic
+        : mpl::or_<
+            is_same<Plain, bool>
+          , is_same<Plain, int>
+          , is_same<Plain, unsigned>
+          , is_same<Plain, double>
+        > {};
+
+    template <typename C>
+    struct reference_type
+    {
+        typedef typename C::reference type;
+    };
+
+    template <typename T>
+    struct reference_type<T const>
+        : reference_type<T> {};
+
+    template <typename T, std::size_t N>
+    struct reference_type<T[N]>
+    {
+        typedef T& type;
+    };
+
+    template <typename T>
+    struct reference_type<T*>
+    {
+        typedef T& type;
+    };
+
+    template <typename T>
+    struct reference_type<T* const>
+    {
+        typedef T const& type;
+    };
+
+    template <typename C>
+    struct const_reference_type
+    {
+        typedef typename C::const_reference type;
+    };
+
+    template <typename C>
+    struct mapped_type
+    {
+        typedef typename C::mapped_type type;
+    };
+
+    struct asymmetric;
+
+    template <typename X, typename Y>
+    cant_deduce_type
+    test(...); // The black hole !!!
+
+    template <typename X, typename Y>
+    bool_value_type
+    test(bool const&);
+
+    template <typename X, typename Y>
+    int_value_type
+    test(int const&);
+
+    template <typename X, typename Y>
+    uint_value_type
+    test(unsigned const&);
+
+    template <typename X, typename Y>
+    double_value_type
+    test(double const&);
+
+    template <typename X, typename Y>
+    bool_reference_type
+    test(bool&);
+
+    template <typename X, typename Y>
+    int_reference_type
+    test(int&);
+
+    template <typename X, typename Y>
+    uint_reference_type
+    test(unsigned&);
+
+    template <typename X, typename Y>
+    double_reference_type
+    test(double&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<is_basic<X>, is_const<X> >
+      , x_value_type
+    >::type
+    test(X const&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<X>
+      , x_reference_type
+    >::type
+    test(X&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<X>
+          , is_const<X>
+        >
+      , x_const_pointer_type
+    >::type
+    test(X const*);
+
+    template <typename X, typename Y>
+    x_pointer_type
+    test(X*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_value_type
+    >::type
+    test(Y const&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_reference_type
+    >::type
+    test(Y&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_const_pointer_type
+    >::type
+    test(Y const*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_pointer_type
+    >::type
+    test(Y*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<typename X::value_type>
+          , is_same<typename add_reference<X>::type, typename X::reference>
+        >
+      , container_reference_type
+    >::type
+    test(typename X::reference);
+
+    template <typename X, typename Y, typename Z>
+    typename enable_if<
+        mpl::and_<
+            mpl::or_<is_array<X>, is_pointer<X> >
+          , mpl::not_<is_basic<Z> >
+          , mpl::not_<is_same<X, Z> >
+        >
+      , container_reference_type
+    >::type
+    test(Z&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<typename X::value_type>
+          , is_same<typename add_reference<X>::type, typename X::const_reference>
+        >
+      , container_const_reference_type
+    >::type
+    test(typename X::const_reference);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<typename X::mapped_type>
+      , container_mapped_type
+    >::type
+    test(typename X::mapped_type);
+
+    template <typename X, typename Y>
+    struct base_result_of
+    {
+        typedef typename phoenix::detail::unwrap_local_reference<X>::type x_type_;
+        typedef typename phoenix::detail::unwrap_local_reference<Y>::type y_type_;
+        typedef typename remove_reference<x_type_>::type x_type;
+        typedef typename remove_reference<y_type_>::type y_type;
+
+        typedef mpl::vector20<
+            mpl::identity<bool>
+          , mpl::identity<int>
+          , mpl::identity<unsigned>
+          , mpl::identity<double>
+          , mpl::identity<bool&>
+          , mpl::identity<int&>
+          , mpl::identity<unsigned&>
+          , mpl::identity<double&>
+          , mpl::identity<x_type>
+          , mpl::identity<x_type&>
+          , mpl::identity<x_type const*>
+          , mpl::identity<x_type*>
+          , mpl::identity<y_type>
+          , mpl::identity<y_type&>
+          , mpl::identity<y_type const*>
+          , mpl::identity<y_type*>
+          , reference_type<x_type>
+          , const_reference_type<x_type>
+          , mapped_type<x_type>
+          , mpl::identity<error_cant_deduce_type>
+        >
+        types;
+    };
+
+}} // namespace boost::type_deduction_detail
+
+#define BOOST_RESULT_OF_COMMON(expr, name, Y, SYMMETRY)                         \
+    struct name                                                                 \
+    {                                                                           \
+        typedef type_deduction_detail::base_result_of<X, Y> base_type;          \
+        static typename base_type::x_type x;                                    \
+        static typename base_type::y_type y;                                    \
+                                                                                \
+        BOOST_STATIC_CONSTANT(int,                                              \
+            size = sizeof(                                                      \
+                type_deduction_detail::test<                                    \
+                    typename base_type::x_type                                  \
+                  , SYMMETRY                                                    \
+                >(expr)                                                         \
+            ));                                                                 \
+                                                                                \
+        BOOST_STATIC_CONSTANT(int, index = (size / sizeof(char)) - 1);          \
+                                                                                \
+        typedef typename mpl::at_c<                                             \
+            typename base_type::types, index>::type id;                         \
+        typedef typename id::type type;                                         \
+    };
+
+#define BOOST_UNARY_RESULT_OF(expr, name)                                       \
+    template <typename X>                                                       \
+    BOOST_RESULT_OF_COMMON(expr, name,                                          \
+        type_deduction_detail::asymmetric, type_deduction_detail::asymmetric)
+
+#define BOOST_BINARY_RESULT_OF(expr, name)                                      \
+    template <typename X, typename Y>                                           \
+    BOOST_RESULT_OF_COMMON(expr, name, Y, typename base_type::y_type)
+
+#define BOOST_ASYMMETRIC_BINARY_RESULT_OF(expr, name)                           \
+    template <typename X, typename Y>                                           \
+    BOOST_RESULT_OF_COMMON(expr, name, Y, type_deduction_detail::asymmetric)
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp
new file mode 100644
index 0000000..5309d9a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_FUNCTION_HPP
+#define PHOENIX_FUNCTION_HPP
+
+#include <boost/spirit/home/phoenix/version.hpp>
+#include <boost/spirit/home/phoenix/function/function.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp
new file mode 100644
index 0000000..622f118
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_FUNCTION_DETAIL_FUNCTION_CALL_HPP
+#define PHOENIX_FUNCTION_DETAIL_FUNCTION_CALL_HPP
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT),                              \
+    "boost/spirit/home/phoenix/function/detail/function_call.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename A)>
+    actor<typename as_composite<detail::function_eval<N>, F
+      , BOOST_PP_ENUM_PARAMS(N, A)>::type>
+    operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) const
+    {
+        return compose<detail::function_eval<N> >(f, BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp
new file mode 100644
index 0000000..1cf4701
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp
@@ -0,0 +1,48 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_FUNCTION_FUNCTION_HPP
+#define PHOENIX_FUNCTION_FUNCTION_HPP
+
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename F>
+    struct function
+    {
+        function() : f() {}
+        function(F const& f) : f(f) {}
+
+        actor<typename as_composite<detail::function_eval<0>, F>::type>
+        operator()() const
+        {
+            return compose<detail::function_eval<0> >(f);
+        }
+
+        template <typename A0>
+        actor<typename as_composite<detail::function_eval<1>, F, A0>::type>
+        operator()(A0 const& _0) const
+        {
+            return compose<detail::function_eval<1> >(f, _0);
+        }
+
+        template <typename A0, typename A1>
+        actor<typename as_composite<detail::function_eval<2>, F, A0, A1>::type>
+        operator()(A0 const& _0, A1 const& _1) const
+        {
+            return compose<detail::function_eval<2> >(f, _0, _1);
+        }
+
+        //  Bring in the rest of the function call operators
+        #include <boost/spirit/home/phoenix/function/detail/function_call.hpp>
+
+        F f;
+    };
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp
new file mode 100644
index 0000000..2d8ee6c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_HPP
+#define PHOENIX_OPERATOR_HPP
+
+#include <boost/spirit/home/phoenix/version.hpp>
+#include <boost/spirit/home/phoenix/operator/arithmetic.hpp>
+#include <boost/spirit/home/phoenix/operator/bitwise.hpp>
+#include <boost/spirit/home/phoenix/operator/comparison.hpp>
+#include <boost/spirit/home/phoenix/operator/if_else.hpp>
+#include <boost/spirit/home/phoenix/operator/logical.hpp>
+#include <boost/spirit/home/phoenix/operator/self.hpp>
+#include <boost/spirit/home/phoenix/operator/io.hpp>
+#include <boost/spirit/home/phoenix/operator/member.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp
new file mode 100644
index 0000000..e51b23e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp
@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_ARITHMETIC_HPP
+#define PHOENIX_OPERATOR_ARITHMETIC_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp>
+
+namespace boost { namespace phoenix
+{
+    struct negate_eval;
+    struct posit_eval;
+    struct pre_increment_eval;
+    struct pre_decrement_eval;
+    struct post_increment_eval;
+    struct post_decrement_eval;
+
+    struct plus_assign_eval;
+    struct minus_assign_eval;
+    struct multiplies_assign_eval;
+    struct divides_assign_eval;
+    struct modulus_assign_eval;
+
+    struct plus_eval;
+    struct minus_eval;
+    struct multiplies_eval;
+    struct divides_eval;
+    struct modulus_eval;
+
+    BOOST_UNARY_RESULT_OF(-x, result_of_negate)
+    BOOST_UNARY_RESULT_OF(+x, result_of_posit)
+    BOOST_UNARY_RESULT_OF(++x, result_of_pre_increment)
+    BOOST_UNARY_RESULT_OF(--x, result_of_pre_decrement)
+    BOOST_UNARY_RESULT_OF(x++, result_of_post_increment)
+    BOOST_UNARY_RESULT_OF(x--, result_of_post_decrement)
+
+    BOOST_BINARY_RESULT_OF(x += y, result_of_plus_assign)
+    BOOST_BINARY_RESULT_OF(x -= y, result_of_minus_assign)
+    BOOST_BINARY_RESULT_OF(x *= y, result_of_multiplies_assign)
+    BOOST_BINARY_RESULT_OF(x /= y, result_of_divides_assign)
+    BOOST_BINARY_RESULT_OF(x %= y, result_of_modulus_assign)
+
+    BOOST_BINARY_RESULT_OF(x + y, result_of_plus)
+    BOOST_BINARY_RESULT_OF(x - y, result_of_minus)
+    BOOST_BINARY_RESULT_OF(x * y, result_of_multiplies)
+    BOOST_BINARY_RESULT_OF(x / y, result_of_divides)
+    BOOST_BINARY_RESULT_OF(x % y, result_of_modulus)
+
+#define x a0.eval(env)
+#define y a1.eval(env)
+
+    PHOENIX_UNARY_EVAL(negate_eval, result_of_negate, -x)
+    PHOENIX_UNARY_EVAL(posit_eval, result_of_posit, +x)
+    PHOENIX_UNARY_EVAL(pre_increment_eval, result_of_pre_increment, ++x)
+    PHOENIX_UNARY_EVAL(pre_decrement_eval, result_of_pre_decrement, --x)
+    PHOENIX_UNARY_EVAL(post_increment_eval, result_of_post_increment, x++)
+    PHOENIX_UNARY_EVAL(post_decrement_eval, result_of_post_decrement, x--)
+
+    PHOENIX_BINARY_EVAL(plus_assign_eval, result_of_plus_assign, x += y)
+    PHOENIX_BINARY_EVAL(minus_assign_eval, result_of_minus_assign, x -= y)
+    PHOENIX_BINARY_EVAL(multiplies_assign_eval, result_of_multiplies_assign, x *= y)
+    PHOENIX_BINARY_EVAL(divides_assign_eval, result_of_divides_assign, x /= y)
+    PHOENIX_BINARY_EVAL(modulus_assign_eval, result_of_modulus_assign, x %= y)
+
+    PHOENIX_BINARY_EVAL(plus_eval, result_of_plus, x + y)
+    PHOENIX_BINARY_EVAL(minus_eval, result_of_minus, x - y)
+    PHOENIX_BINARY_EVAL(multiplies_eval, result_of_multiplies, x * y)
+    PHOENIX_BINARY_EVAL(divides_eval, result_of_divides, x / y)
+    PHOENIX_BINARY_EVAL(modulus_eval, result_of_modulus, x % y)
+
+    PHOENIX_UNARY_COMPOSE(negate_eval, -)
+    PHOENIX_UNARY_COMPOSE(posit_eval, +)
+    PHOENIX_UNARY_COMPOSE(pre_increment_eval, ++)
+    PHOENIX_UNARY_COMPOSE(pre_decrement_eval, --)
+
+    template <typename T0>
+    inline actor<typename as_composite<post_increment_eval, actor<T0> >::type>
+    operator++(actor<T0> const& a0, int) // special case
+    {
+        return compose<post_increment_eval>(a0);
+    }
+
+    template <typename T0>
+    inline actor<typename as_composite<post_decrement_eval, actor<T0> >::type>
+    operator--(actor<T0> const& a0, int) // special case
+    {
+        return compose<post_decrement_eval>(a0);
+    }
+
+    PHOENIX_BINARY_COMPOSE(plus_assign_eval, +=)
+    PHOENIX_BINARY_COMPOSE(minus_assign_eval, -=)
+    PHOENIX_BINARY_COMPOSE(multiplies_assign_eval, *=)
+    PHOENIX_BINARY_COMPOSE(divides_assign_eval, /=)
+    PHOENIX_BINARY_COMPOSE(modulus_assign_eval, %=)
+
+    PHOENIX_BINARY_COMPOSE(plus_eval, +)
+    PHOENIX_BINARY_COMPOSE(minus_eval, -)
+    PHOENIX_BINARY_COMPOSE(multiplies_eval, *)
+    PHOENIX_BINARY_COMPOSE(divides_eval, /)
+    PHOENIX_BINARY_COMPOSE(modulus_eval, %)
+
+#undef x
+#undef y
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp
new file mode 100644
index 0000000..0450db4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp
@@ -0,0 +1,91 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_BITWISE_HPP
+#define PHOENIX_OPERATOR_BITWISE_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4800)
+#endif
+
+namespace boost { namespace phoenix
+{
+    struct invert_eval;
+
+    struct and_assign_eval;
+    struct or_assign_eval;
+    struct xor_assign_eval;
+    struct shift_left_assign_eval;
+    struct shift_right_assign_eval;
+
+    struct and_eval;
+    struct or_eval;
+    struct xor_eval;
+    struct shift_left_eval;
+    struct shift_right_eval;
+
+    BOOST_UNARY_RESULT_OF(~x, result_of_invert)
+
+    BOOST_BINARY_RESULT_OF(x &= y, result_of_and_assign)
+    BOOST_BINARY_RESULT_OF(x |= y, result_of_or_assign)
+    BOOST_BINARY_RESULT_OF(x ^= y, result_of_xor_assign)
+    BOOST_BINARY_RESULT_OF(x <<= y, result_of_shift_left_assign)
+    BOOST_BINARY_RESULT_OF(x >>= y, result_of_shift_right_assign)
+
+    BOOST_BINARY_RESULT_OF(x & y, result_of_and)
+    BOOST_BINARY_RESULT_OF(x | y, result_of_or)
+    BOOST_BINARY_RESULT_OF(x ^ y, result_of_xor)
+    BOOST_BINARY_RESULT_OF(x << y, result_of_shift_left)
+    BOOST_BINARY_RESULT_OF(x >> y, result_of_shift_right)
+
+#define x a0.eval(env)
+#define y a1.eval(env)
+
+    PHOENIX_UNARY_EVAL(invert_eval, result_of_invert, ~x)
+    PHOENIX_UNARY_COMPOSE(invert_eval, ~)
+
+    PHOENIX_BINARY_EVAL(and_assign_eval, result_of_and_assign, x &= y)
+    PHOENIX_BINARY_EVAL(or_assign_eval, result_of_or_assign, x |= y)
+    PHOENIX_BINARY_EVAL(xor_assign_eval, result_of_xor_assign, x ^= y)
+    PHOENIX_BINARY_EVAL(shift_left_assign_eval, result_of_shift_left_assign, x <<= y)
+    PHOENIX_BINARY_EVAL(shift_right_assign_eval, result_of_shift_right_assign, x >>= y)
+
+    PHOENIX_BINARY_EVAL(and_eval, result_of_and, x & y)
+    PHOENIX_BINARY_EVAL(or_eval, result_of_or, x | y)
+    PHOENIX_BINARY_EVAL(xor_eval, result_of_xor, x ^ y)
+    PHOENIX_BINARY_EVAL(shift_left_eval, result_of_shift_left, x << y)
+    PHOENIX_BINARY_EVAL(shift_right_eval, result_of_shift_right, x >> y)
+
+    PHOENIX_BINARY_COMPOSE(and_assign_eval, &=)
+    PHOENIX_BINARY_COMPOSE(or_assign_eval, |=)
+    PHOENIX_BINARY_COMPOSE(xor_assign_eval, ^=)
+    PHOENIX_BINARY_COMPOSE(shift_left_assign_eval, <<=)
+    PHOENIX_BINARY_COMPOSE(shift_right_assign_eval, >>=)
+
+    PHOENIX_BINARY_COMPOSE(and_eval, &)
+    PHOENIX_BINARY_COMPOSE(or_eval, |)
+    PHOENIX_BINARY_COMPOSE(xor_eval, ^)
+    PHOENIX_BINARY_COMPOSE(shift_left_eval, <<)
+    PHOENIX_BINARY_COMPOSE(shift_right_eval, >>)
+
+#undef x
+#undef y
+}}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp
new file mode 100644
index 0000000..fe9298c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp
@@ -0,0 +1,55 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_COMPARISON_HPP
+#define PHOENIX_OPERATOR_COMPARISON_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp>
+
+namespace boost { namespace phoenix
+{
+    struct equal_to_eval;
+    struct not_equal_to_eval;
+    struct less_eval;
+    struct less_equal_eval;
+    struct greater_eval;
+    struct greater_equal_eval;
+
+    BOOST_BINARY_RESULT_OF(x == y, result_of_equal_to)
+    BOOST_BINARY_RESULT_OF(x != y, result_of_not_equal_to)
+    BOOST_BINARY_RESULT_OF(x < y, result_of_less)
+    BOOST_BINARY_RESULT_OF(x <= y, result_of_less_equal)
+    BOOST_BINARY_RESULT_OF(x > y, result_of_greater)
+    BOOST_BINARY_RESULT_OF(x >= y, result_of_greater_equal)
+
+#define x a0.eval(env)
+#define y a1.eval(env)
+
+    PHOENIX_BINARY_EVAL(equal_to_eval, result_of_equal_to, x == y)
+    PHOENIX_BINARY_EVAL(not_equal_to_eval, result_of_not_equal_to, x != y)
+    PHOENIX_BINARY_EVAL(less_eval, result_of_less, x < y)
+    PHOENIX_BINARY_EVAL(less_equal_eval, result_of_less_equal, x <= y)
+    PHOENIX_BINARY_EVAL(greater_eval, result_of_greater, x > y)
+    PHOENIX_BINARY_EVAL(greater_equal_eval, result_of_greater_equal, x >= y)
+
+    PHOENIX_BINARY_COMPOSE(equal_to_eval, ==)
+    PHOENIX_BINARY_COMPOSE(not_equal_to_eval, !=)
+    PHOENIX_BINARY_COMPOSE(less_eval, <)
+    PHOENIX_BINARY_COMPOSE(less_equal_eval, <=)
+    PHOENIX_BINARY_COMPOSE(greater_eval, >)
+    PHOENIX_BINARY_COMPOSE(greater_equal_eval, >=)
+
+#undef x
+#undef y
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp
new file mode 100644
index 0000000..49335fd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP
+#define PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP
+
+#define PHOENIX_BINARY_COMPOSE(eval_name, op)                                   \
+    template <typename T0, typename T1>                                         \
+    inline actor<typename as_composite<eval_name, actor<T0>, actor<T1> >::type> \
+    operator op (actor<T0> const& a0, actor<T1> const& a1)                      \
+    {                                                                           \
+        return compose<eval_name>(a0, a1);                                      \
+    }                                                                           \
+                                                                                \
+    template <typename T0, typename T1>                                         \
+    inline actor<typename as_composite<eval_name, actor<T0>, T1>::type>         \
+    operator op (actor<T0> const& a0, T1 const& a1)                             \
+    {                                                                           \
+        return compose<eval_name>(a0, a1);                                      \
+    }                                                                           \
+                                                                                \
+    template <typename T0, typename T1>                                         \
+    inline actor<typename as_composite<eval_name, T0, actor<T1> >::type>        \
+    operator op (T0 const& a0, actor<T1> const& a1)                             \
+    {                                                                           \
+        return compose<eval_name>(a0, a1);                                      \
+    }
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp
new file mode 100644
index 0000000..1789882
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP
+#define PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP
+
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+
+#define PHOENIX_BINARY_EVAL(eval_name, op_result, expr)                         \
+    struct eval_name                                                            \
+    {                                                                           \
+        template <typename Env, typename A0, typename A1>                       \
+        struct result                                                            \
+        {                                                                       \
+            typedef typename A0::template result<Env>::type x_type;              \
+            typedef typename A1::template result<Env>::type y_type;              \
+                                                                                \
+            typedef typename                                                    \
+                mpl::eval_if<                                                   \
+                    mpl::or_<is_actor<x_type>, is_actor<y_type> >               \
+                  , re_curry<eval_name, x_type, y_type>                         \
+                  , op_result<x_type, y_type>                                   \
+                >::type                                                         \
+            type;                                                               \
+        };                                                                      \
+                                                                                \
+        template <typename RT, typename Env, typename A0, typename A1>          \
+        static RT                                                               \
+        eval(Env const& env, A0& a0, A1& a1)                                    \
+        {                                                                       \
+            return expr;                                                        \
+        }                                                                       \
+    };
+
+#undef x
+#undef y
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp
new file mode 100644
index 0000000..d82a153
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_DETAIL_IO_HPP
+#define PHOENIX_OPERATOR_DETAIL_IO_HPP
+
+#include <boost/spirit/home/phoenix/operator/bitwise.hpp>
+#include <boost/spirit/home/phoenix/core/reference.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <iostream>
+
+namespace boost { namespace phoenix { namespace detail
+{
+    typedef char(&no)[1];
+    typedef char(&yes)[2];
+
+    template <typename CharType, typename CharTrait>
+    yes ostream_test(std::basic_ostream<CharType, CharTrait>*);
+    no ostream_test(...);
+
+    template <typename CharType, typename CharTrait>
+    yes istream_test(std::basic_istream<CharType, CharTrait>*);
+    no istream_test(...);
+
+    template <typename T>
+    struct is_ostream
+    {
+        static T x;
+        BOOST_STATIC_CONSTANT(bool,
+            value = sizeof(detail::ostream_test(boost::addressof(x))) == sizeof(yes));
+    };
+
+    template <typename T>
+    struct is_istream
+    {
+        static T x;
+        BOOST_STATIC_CONSTANT(bool,
+            value = sizeof(detail::istream_test(boost::addressof(x))) == sizeof(yes));
+    };
+
+    template <typename T0, typename T1>
+    struct enable_if_ostream :
+        enable_if<
+            detail::is_ostream<T0>
+          , actor<
+                typename as_composite<
+                    shift_left_eval
+                  , actor<reference<T0> >
+                  , actor<T1>
+                >::type
+            >
+        >
+    {};
+
+    template <typename T0, typename T1>
+    struct enable_if_istream :
+        enable_if<
+            detail::is_istream<T0>
+          , actor<
+                typename as_composite<
+                    shift_right_eval
+                  , actor<reference<T0> >
+                  , actor<T1>
+                >::type
+            >
+        >
+    {};
+
+    typedef std::ios_base&  (*iomanip_type)(std::ios_base&);
+    typedef std::istream&   (*imanip_type)(std::istream&);
+    typedef std::ostream&   (*omanip_type)(std::ostream&);
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp
new file mode 100644
index 0000000..cb77613
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp
@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2005-2007 Dan Marsden
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP
+#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+
+#include <boost/mpl/void.hpp>
+
+#include <boost/type_traits/function_traits.hpp>
+
+#include <boost/get_pointer.hpp>
+
+#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp>
+
+namespace boost { namespace phoenix {
+
+    struct mem_fun_ptr_eval
+    {
+        template<typename Env, typename PtrActor, typename MemFunPtrActor,
+                 BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_SUB(PHOENIX_MEMBER_LIMIT, 2), typename Arg, mpl::void_)>
+
+        struct result
+            : detail::mem_fun_ptr_return<typename eval_result<MemFunPtrActor, Env>::type> { };
+
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor>
+        static typename result<Env,PtrActor,MemFunPtrActor>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))();
+        }
+
+#define BOOST_PP_ITERATION_PARAMS_1                                                                                 \
+        (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp"))
+
+#include BOOST_PP_ITERATE()
+
+    };
+}}
+
+#endif
+
+#else
+
+#define PHOENIX_ITERATION BOOST_PP_ITERATION()
+
+#define PHOENIX_EVAL_ARG(z,n,_) arg ## n.eval(env)        
+
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)> 
+        static typename result<Env,PtrActor,MemFunPtrActor, BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION,Arg)>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, Arg, & arg))
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                BOOST_PP_ENUM(PHOENIX_ITERATION,PHOENIX_EVAL_ARG,_));
+        }
+
+#undef PHOENIX_EVAL_ARG
+#undef PHOENIX_ITERATION
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp
new file mode 100644
index 0000000..31d5413
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp
@@ -0,0 +1,69 @@
+/*=============================================================================
+    Copyright (c) 2005-2007 Dan Marsden
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP
+#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/core/as_actor.hpp>
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+
+#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp>
+
+namespace boost { namespace phoenix {
+    template<typename Actor, typename MemFunPtr>
+    struct mem_fun_ptr_gen
+    {
+        mem_fun_ptr_gen(
+            const Actor& actor, MemFunPtr memFunPtr)
+            : mActor(actor), mMemFunPtr(memFunPtr) { }
+
+        actor<typename as_composite<mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type>::type>
+        operator()() const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr));
+        }
+
+#define BOOST_PP_ITERATION_PARAMS_1                                                        \
+        (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp"))
+
+#include BOOST_PP_ITERATE()
+
+        Actor mActor;
+        MemFunPtr mMemFunPtr;
+    };
+}}
+
+#endif
+#else
+
+#define PHOENIX_ITERATION BOOST_PP_ITERATION()
+
+        template<BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, Arg)>::type>
+        operator()(
+            BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, const Arg, &arg)) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, arg));
+        }
+
+#undef PHOENIX_ITERATION
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp
new file mode 100644
index 0000000..102f17f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp
@@ -0,0 +1,65 @@
+/*=============================================================================
+    Copyright (c) 2005-2007 Dan Marsden
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP
+#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+
+namespace boost { namespace phoenix {
+namespace detail
+{
+    template<typename MemFunPtr>
+    struct mem_fun_ptr_return;
+
+    template<typename Ret, typename Class>
+    struct mem_fun_ptr_return<Ret (Class::*)()>
+    {
+        typedef Ret type;
+    };
+    
+    template<typename Ret, typename Class>
+    struct mem_fun_ptr_return<Ret (Class::*)() const>
+    {
+        typedef Ret type;
+    };
+
+#define BOOST_PP_ITERATION_PARAMS_1                                                           \
+        (3, (1, PHOENIX_MEMBER_LIMIT, "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp"))
+
+#include BOOST_PP_ITERATE()
+
+}
+}}
+
+#endif
+
+#else
+
+#define PHOENIX_ITERATION BOOST_PP_ITERATION()
+
+    template<typename Ret, typename Class,
+             BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)>
+    struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T))>
+    {
+        typedef Ret type;
+    };
+
+    template<typename Ret, typename Class,
+             BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)>
+    struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T)) const>
+    {
+        typedef Ret type;
+    };
+
+#undef PHOENIX_ITERATION
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp
new file mode 100644
index 0000000..fd9a8c7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp
@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP
+#define PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP
+
+#define PHOENIX_UNARY_COMPOSE(eval_name, op)                                    \
+    template <typename T0>                                                      \
+    inline actor<typename as_composite<eval_name, actor<T0> >::type>            \
+    operator op (actor<T0> const& a0)                                           \
+    {                                                                           \
+        return compose<eval_name>(a0);                                          \
+    }
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp
new file mode 100644
index 0000000..501f6df
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp
@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP
+#define PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+
+#define PHOENIX_UNARY_EVAL(eval_name, op_result, expr)                          \
+    struct eval_name                                                            \
+    {                                                                           \
+        template <typename Env, typename A0>                                    \
+        struct result                                                            \
+        {                                                                       \
+            typedef typename A0::template result<Env>::type x_type;              \
+                                                                                \
+            typedef typename                                                    \
+                mpl::eval_if<                                                   \
+                    is_actor<x_type>                                            \
+                  , re_curry<eval_name, x_type>                                 \
+                  , op_result<x_type>                                           \
+                >::type                                                         \
+            type;                                                               \
+        };                                                                      \
+                                                                                \
+        template <typename RT, typename Env, typename A0>                       \
+        static RT                                                               \
+        eval(Env const& env, A0& a0)                                            \
+        {                                                                       \
+            return expr;                                                        \
+        }                                                                       \
+    };
+
+#endif
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp
new file mode 100644
index 0000000..8492e90
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_IF_ELSE_HPP
+#define PHOENIX_OPERATOR_IF_ELSE_HPP
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_BINARY_RESULT_OF(true ? x : y, result_of_if_else)
+
+    struct if_else_op_eval
+    {
+        template <
+            typename Env
+          , typename Cond
+          , typename Then
+          , typename Else
+        >
+        struct result
+        {
+            typedef typename Then::template result<Env>::type then_type;
+            typedef typename Else::template result<Env>::type else_type;
+
+            typedef typename
+                result_of_if_else<then_type, else_type>::type
+            ite_result;
+
+            // Note: c ? x : y can return an lvalue! Allow if_else_op_eval
+            // to return an lvalue IFF then_type and else_type are both lvalues
+            // with the same type.
+
+            typedef typename
+                mpl::if_<
+                    mpl::and_<
+                        is_same<then_type, else_type>
+                      , is_reference<then_type>
+                    >
+                  , ite_result
+                  , typename remove_reference<ite_result>::type
+                >::type
+            type;
+        };
+
+        template <
+            typename RT
+          , typename Env
+          , typename Cond
+          , typename Then
+          , typename Else
+        >
+        static RT
+        eval(Env const& env, Cond& cond, Then& then, Else& else_)
+        {
+            return cond.eval(env) ? then.eval(env) : else_.eval(env);
+        }
+    };
+
+    template <typename Cond, typename Then, typename Else>
+    inline actor<typename as_composite<if_else_op_eval, Cond, Then, Else>::type>
+    if_else(Cond const& cond, Then const& then, Else const& else_)
+    {
+        return compose<if_else_op_eval>(cond, then, else_);
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp
new file mode 100644
index 0000000..360a46f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp
@@ -0,0 +1,86 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_IO_HPP
+#define PHOENIX_OPERATOR_IO_HPP
+
+#include <boost/spirit/home/phoenix/operator/detail/io.hpp>
+
+namespace boost { namespace phoenix
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+//  overloads for std::basic_ostream and std::basic_istream
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <typename T0, typename T1>
+    inline typename detail::enable_if_ostream<T0, T1>::type
+    operator<<(T0& a0, actor<T1> const& a1)
+    {
+        return compose<shift_left_eval>(phoenix::ref(a0), a1);
+    }
+
+    template <typename T0, typename T1>
+    inline typename detail::enable_if_istream<T0, T1>::type
+    operator>>(T0& a0, actor<T1> const& a1)
+    {
+        return compose<shift_right_eval>(phoenix::ref(a0), a1);
+    }
+
+    // resolve ambiguities with fusion.
+    template <typename T1>
+    inline typename detail::enable_if_ostream<std::ostream, T1>::type
+    operator<<(std::ostream& a0, actor<T1> const& a1)
+    {
+        return compose<shift_left_eval>(phoenix::ref(a0), a1);
+    }
+
+    template <typename T1>
+    inline typename detail::enable_if_istream<std::istream, T1>::type
+        operator>>(std::istream& a0, actor<T1> const& a1)
+    {
+        return compose<shift_right_eval>(phoenix::ref(a0), a1);
+    }
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  overloads for I/O manipulators.
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_left_eval, actor<T0>, detail::omanip_type>::type>
+    operator<<(actor<T0> const& a0, detail::omanip_type a1)
+    {
+        return compose<shift_left_eval>(a0, a1);
+    }
+
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_left_eval, actor<T0>, detail::iomanip_type>::type>
+    operator<<(actor<T0> const& a0, detail::iomanip_type a1)
+    {
+        return compose<shift_left_eval>(a0, a1);
+    }
+
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_right_eval, actor<T0>, detail::imanip_type>::type>
+    operator>>(actor<T0> const& a0, detail::imanip_type a1)
+    {
+        return compose<shift_right_eval>(a0, a1);
+    }
+
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_right_eval, actor<T0>, detail::iomanip_type>::type>
+    operator>>(actor<T0> const& a0, detail::iomanip_type a1)
+    {
+        return compose<shift_right_eval>(a0, a1);
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp
new file mode 100644
index 0000000..84619aa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_LOGICAL_HPP
+#define PHOENIX_OPERATOR_LOGICAL_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp>
+
+namespace boost { namespace phoenix
+{
+    struct logical_not_eval;
+    struct logical_and_eval;
+    struct logical_or_eval;
+
+    BOOST_UNARY_RESULT_OF(!x, result_of_logical_not)
+    BOOST_BINARY_RESULT_OF(x && y, result_of_logical_and)
+    BOOST_BINARY_RESULT_OF(x || y, result_of_logical_or)
+
+#define x a0.eval(env)
+#define y a1.eval(env)
+
+    PHOENIX_UNARY_EVAL(logical_not_eval, result_of_logical_not, !x)
+    PHOENIX_BINARY_EVAL(logical_and_eval, result_of_logical_and, x && y)
+    PHOENIX_BINARY_EVAL(logical_or_eval, result_of_logical_or, x || y)
+
+    PHOENIX_UNARY_COMPOSE(logical_not_eval, !)
+    PHOENIX_BINARY_COMPOSE(logical_and_eval, &&)
+    PHOENIX_BINARY_COMPOSE(logical_or_eval, ||)
+
+#undef x
+#undef y
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp
new file mode 100644
index 0000000..27f3e8d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp
@@ -0,0 +1,145 @@
+/*=============================================================================
+    Copyright (c) 2005-2007 Dan Marsden
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#ifndef PHOENIX_OPERATOR_MEMBER_HPP
+#define PHOENIX_OPERATOR_MEMBER_HPP
+
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_member_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/get_pointer.hpp>
+
+#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp>
+
+#include <memory>
+
+namespace boost { 
+    template<typename T> class shared_ptr;
+    template<typename T> class scoped_ptr;
+
+namespace phoenix {
+    namespace detail
+    {
+        template<typename T>
+        struct member_type;
+        
+        template<typename Class, typename MemberType>
+        struct member_type<MemberType (Class::*)>
+        {
+            typedef MemberType type;
+        };
+    }
+
+    namespace meta
+    {
+        template<typename T> 
+        struct pointed_type;
+
+        template<typename T>
+        struct pointed_type<T*>
+        {
+            typedef T type;
+        };
+
+        template<typename T>
+        struct pointed_type<shared_ptr<T> >
+        {
+            typedef T type;
+        };
+        
+        template<typename T>
+        struct pointed_type<scoped_ptr<T> >
+        {
+            typedef T type;
+        };
+
+        template<typename T>
+        struct pointed_type<std::auto_ptr<T> >
+        {
+            typedef T type;
+        };
+    }
+
+    struct member_object_eval
+    {
+        template<typename Env, typename PtrActor, typename MemPtrActor>
+        struct result
+        {
+            typedef typename detail::member_type<
+                typename eval_result<MemPtrActor, Env>::type>::type member_type;
+
+            typedef typename meta::pointed_type<
+                typename remove_reference<
+                typename eval_result<PtrActor, Env>::type>::type>::type object_type;
+
+            typedef typename add_reference<
+                typename mpl::eval_if<
+                is_const<object_type>,
+                add_const<member_type>,
+                mpl::identity<member_type> >::type>::type type;
+        };
+
+        template<typename Rt, typename Env, typename PtrActor, typename MemPtrActor>
+        static typename result<Env,PtrActor,MemPtrActor>::type
+        eval(const Env& env, PtrActor& ptrActor, MemPtrActor& memPtrActor)
+        {
+            return get_pointer(ptrActor.eval(env))->*memPtrActor.eval(env);
+        }
+    };
+
+    namespace member_object
+    {
+        template<typename T0, typename MemObjPtr>
+        typename enable_if<
+            mpl::and_<is_member_pointer<MemObjPtr>, mpl::not_<is_member_function_pointer<MemObjPtr> > >,
+            actor<typename as_composite<
+            member_object_eval, actor<T0>,
+            typename as_actor<MemObjPtr>::type>::type> >::type
+        operator->*(
+            const actor<T0>& ptrActor, 
+            MemObjPtr memObjPtr)
+        {
+            return compose<member_object_eval>(
+                ptrActor,
+                as_actor<MemObjPtr>::convert(memObjPtr));
+        }
+    }
+
+    namespace member_function
+    {
+        template<typename T0, typename MemFunPtr>
+        typename enable_if<
+            is_member_function_pointer<MemFunPtr>,
+            mem_fun_ptr_gen<actor<T0>, MemFunPtr> >::type
+        operator->*(const actor<T0>& ptrActor, MemFunPtr memFunPtr)
+        {
+            return mem_fun_ptr_gen<actor<T0>, MemFunPtr>(
+                ptrActor, memFunPtr);
+        }
+    }
+
+    using member_object::operator->*;
+    using member_function::operator->*;
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp
new file mode 100644
index 0000000..294adf6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_OPERATOR_SELF_HPP
+#define PHOENIX_OPERATOR_SELF_HPP
+
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/core/compose.hpp>
+#include <boost/spirit/home/phoenix/detail/type_deduction.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp>
+#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp>
+
+namespace boost { namespace phoenix
+{
+    struct reference_eval;
+    struct dereference_eval;
+    struct assign_eval;
+    struct index_eval;
+
+    BOOST_UNARY_RESULT_OF(&x, result_of_reference)
+    BOOST_UNARY_RESULT_OF(*x, result_of_dereference)
+    BOOST_BINARY_RESULT_OF(x = y, result_of_assign)
+    BOOST_ASYMMETRIC_BINARY_RESULT_OF(x[y], result_of_index)
+
+    namespace detail
+    {
+        template <typename T0, typename T1>
+        struct make_assign_composite
+        {
+            typedef actor<typename as_composite<assign_eval, T0, T1>::type> type;
+        };
+
+        template <typename T0, typename T1>
+        struct make_index_composite
+        {
+            typedef actor<typename as_composite<index_eval, T0, T1>::type> type;
+        };
+    }
+
+    template <typename Base>
+    template <typename T1>
+    typename detail::make_assign_composite<actor<Base>, T1>::type
+    actor<Base>::operator=(T1 const& a1) const
+    {
+        return compose<assign_eval>(*this, a1);
+    }
+
+    template <typename Base>
+    template <typename T1>
+    typename detail::make_index_composite<actor<Base>, T1>::type
+    actor<Base>::operator[](T1 const& a1) const
+    {
+        return compose<index_eval>(*this, a1);
+    }
+
+#define x a0.eval(env)
+#define y a1.eval(env)
+
+    PHOENIX_UNARY_EVAL(reference_eval, result_of_reference, &x)
+    PHOENIX_UNARY_EVAL(dereference_eval, result_of_dereference, *x)
+    PHOENIX_UNARY_COMPOSE(reference_eval, &)
+    PHOENIX_UNARY_COMPOSE(dereference_eval, *)
+
+    PHOENIX_BINARY_EVAL(assign_eval, result_of_assign, x = y)
+    PHOENIX_BINARY_EVAL(index_eval, result_of_index, x[y])
+}}
+
+#undef x
+#undef y
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp
new file mode 100644
index 0000000..c1b9ae3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_HPP
+#define PHOENIX_SCOPE_HPP
+
+#include <boost/spirit/home/phoenix/version.hpp>
+#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp>
+#include <boost/spirit/home/phoenix/scope/lambda.hpp>
+#include <boost/spirit/home/phoenix/scope/let.hpp>
+#include <boost/spirit/home/phoenix/scope/local_variable.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp
new file mode 100644
index 0000000..6a74df6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp
@@ -0,0 +1,57 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+// Allow multiple inclusion. let.hpp and lambda.hpp will have the guards
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+
+#define PHOENIX_LOCAL_GEN_PARAM(z, n, data)                                     \
+    actor<composite<assign_eval                                                 \
+  , fusion::vector<local_variable<K##n>, V##n> > > const& a##n
+
+#define PHOENIX_LOCAL_GEN_ACTOR(z, n, data)                                     \
+    fusion::at_c<1>(a##n)
+
+#define BOOST_PP_ITERATION_PARAMS_1                                             \
+    (3, (3, PHOENIX_LOCAL_LIMIT,                                                \
+    "boost/spirit/home/phoenix/scope/detail/local_gen.hpp"))
+#include BOOST_PP_ITERATE()
+
+#undef PHOENIX_LOCAL_GEN_PARAM
+#undef PHOENIX_LOCAL_GEN_ACTOR
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <
+        BOOST_PP_ENUM_PARAMS(N, typename K)
+      , BOOST_PP_ENUM_PARAMS(N, typename V)
+    >
+    PHOENIX_LOCAL_GEN_NAME<
+        fusion::vector<BOOST_PP_ENUM_PARAMS(N, V)>
+      , detail::map_local_index_to_tuple<BOOST_PP_ENUM_PARAMS(N, K)>
+    >
+    operator()(
+        BOOST_PP_ENUM(N, PHOENIX_LOCAL_GEN_PARAM, _)
+    ) const
+    {
+        return fusion::vector<BOOST_PP_ENUM_PARAMS(N, V)>(
+            BOOST_PP_ENUM(N, PHOENIX_LOCAL_GEN_ACTOR, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp
new file mode 100644
index 0000000..1ad7932
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp
@@ -0,0 +1,198 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2004 Daniel Wallin
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP
+#define PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/value_at.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_reference.hpp>
+
+#define PHOENIX_MAP_LOCAL_TEMPLATE_PARAM(z, n, data) \
+    typename T##n = unused<n>
+
+#define PHOENIX_MAP_LOCAL_DISPATCH(z, n, data)  \
+    typedef char(&result##n)[n+2];              \
+    static result##n get(T##n*);
+
+namespace boost { namespace phoenix
+{
+    template <typename Env, typename OuterEnv, typename Locals, typename Map>
+    struct scoped_environment;
+
+    namespace detail
+    {
+        template <typename Env>
+        struct initialize_local
+        {
+            template <class F>
+            struct result;
+
+            template <class F, class Actor>
+            struct result<F(Actor)>
+            {
+                typedef typename remove_reference<Actor>::type actor_type;
+                typedef typename actor_type::template result<Env>::type type;
+            };
+
+            initialize_local(Env const& env)
+                : env(env) {}
+
+            template <typename Actor>
+            typename result<initialize_local(Actor)>::type
+            operator()(Actor const& actor) const
+            {
+                return actor.eval(env);
+            }
+
+            Env const& env;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            initialize_local& operator= (initialize_local const&);
+        };
+
+        template <typename T>
+        struct is_scoped_environment : mpl::false_ {};
+
+        template <typename Env, typename OuterEnv, typename Locals, typename Map>
+        struct is_scoped_environment<scoped_environment<Env, OuterEnv, Locals, Map> >
+            : mpl::true_ {};
+
+        template <int N>
+        struct unused;
+
+        template <BOOST_PP_ENUM(
+            PHOENIX_LOCAL_LIMIT, PHOENIX_MAP_LOCAL_TEMPLATE_PARAM, _)>
+        struct map_local_index_to_tuple
+        {
+            typedef char(&not_found)[1];
+            static not_found get(...);
+
+            BOOST_PP_REPEAT(PHOENIX_LOCAL_LIMIT, PHOENIX_MAP_LOCAL_DISPATCH, _)
+        };
+
+        template<typename T>
+        T* generate_pointer();
+
+        template <typename Map, typename Tag>
+        struct get_index
+        {
+            BOOST_STATIC_CONSTANT(int,
+                value = (
+                    static_cast<int>((sizeof(Map::get(generate_pointer<Tag>()))) / sizeof(char)) - 2
+                ));
+
+            // if value == -1, Tag is not found
+            typedef mpl::int_<value> type;
+        };
+
+        template <typename Local, typename Env>
+        struct apply_local;
+
+        template <typename Local, typename Env>
+        struct outer_local
+        {
+            typedef typename
+                apply_local<Local, typename Env::outer_env_type>::type
+            type;
+        };
+
+        template <typename Locals, typename Index>
+        struct get_local_or_void
+        {
+            typedef typename
+                mpl::eval_if<
+                    mpl::less<Index, mpl::size<Locals> >
+                  , fusion::result_of::at<Locals, Index>
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+
+        template <typename Local, typename Env, typename Index>
+        struct get_local_from_index
+        {
+            typedef typename
+                mpl::eval_if<
+                    mpl::equal_to<Index, mpl::int_<-1> >
+                  , outer_local<Local, Env>
+                  , get_local_or_void<typename Env::locals_type, Index>
+                >::type
+            type;
+        };
+
+        template <typename Local, typename Env>
+        struct get_local
+        {
+            typedef typename
+                get_index<
+                    typename Env::map_type, typename Local::key_type>::type
+            index_type;
+
+            typedef typename
+                get_local_from_index<Local, Env, index_type>::type
+            type;
+        };
+
+        template <typename Local, typename Env>
+        struct apply_local
+        {
+            // $$$ TODO: static assert that Env is a scoped_environment $$$
+            typedef typename get_local<Local, Env>::type type;
+        };
+
+        template <typename Key>
+        struct eval_local
+        {
+            template <typename RT, typename Env, typename Index>
+            static RT
+            get(Env const& env, Index, mpl::false_)
+            {
+                return RT(fusion::at<Index>(env.locals));
+            }
+
+            template <typename RT, typename Env, typename Index>
+            static RT
+            get(Env const& env, Index index, mpl::true_)
+            {
+                typedef typename
+                    get_index<typename Env::outer_env_type::map_type, Key>::type
+                index_type;
+
+                return get<RT>(
+                    env.outer_env
+                  , index_type()
+                  , mpl::equal_to<index_type, mpl::int_<-1> >());
+            }
+
+            template <typename RT, typename Env, typename Index>
+            static RT
+            get(Env const& env, Index index)
+            {
+                return get<RT>(
+                    env
+                  , index
+                  , mpl::equal_to<Index, mpl::int_<-1> >());
+            }
+        };
+    }
+}}
+
+#undef PHOENIX_MAP_LOCAL_TEMPLATE_PARAM
+#undef PHOENIX_MAP_LOCAL_DISPATCH
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp
new file mode 100644
index 0000000..c4a7ce8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp
@@ -0,0 +1,176 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2004 Daniel Wallin
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_LAMBDA_HPP
+#define PHOENIX_SCOPE_LAMBDA_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp>
+#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp>
+#include <boost/spirit/home/phoenix/detail/local_reference.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/fusion/include/transform.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename Base, typename OuterEnv, typename Locals, typename Map>
+    struct lambda_eval : Base
+    {
+        template <typename Env>
+        struct result
+        {
+            typedef typename Base::template
+                result<scoped_environment<Env, OuterEnv, Locals, Map> >::type
+            result_type;
+
+            typedef typename 
+                detail::unwrap_local_reference<result_type>::type 
+            type;
+        };
+
+        lambda_eval(
+            Base const& base
+          , OuterEnv const& outer_env
+          , Locals const& locals)
+            : Base(base)
+            , outer_env(outer_env)
+            , locals(locals) {}
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename result<Env>::type RT;
+            return RT(Base::eval(
+                scoped_environment<Env, OuterEnv, Locals, Map>(
+                    env, outer_env, locals)));
+        }
+
+        OuterEnv outer_env;
+        mutable Locals locals;
+    };
+    
+    template <typename Base, typename Vars, typename Map>
+    struct lambda_actor
+    {
+        typedef typename
+            mpl::fold<
+                Vars
+              , mpl::false_
+              , detail::compute_no_nullary
+            >::type
+        no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename 
+                fusion::result_of::as_vector<
+                    typename fusion::result_of::transform<
+                        Vars
+                      , detail::initialize_local<Env>
+                    >::type
+                >::type 
+            locals_type;
+
+            typedef actor<lambda_eval<Base, Env, locals_type, Map> > type;
+        };
+
+        lambda_actor(Base const& f, Vars const& vars)
+            : f(f), vars(vars) {}
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename result<Env>::type result_type;
+            
+            return result_type(
+                f, env, fusion::as_vector(
+                    fusion::transform(
+                        vars
+                      , detail::initialize_local<Env>(env)
+                    )));
+        }
+
+        Base f;
+        Vars vars;
+    };
+    
+    template <typename Vars, typename Map>
+    struct lambda_actor_gen
+    {
+        template <typename Base>
+        actor<lambda_actor<Base, Vars, Map> > const
+        operator[](actor<Base> const& f) const
+        {
+            return lambda_actor<Base, Vars, Map>(f, vars);
+        }
+
+        lambda_actor_gen(Vars const& vars)
+            : vars(vars) {}
+
+        Vars vars;
+    };
+
+    template <typename Key>
+    struct local_variable; // forward
+    struct assign_eval; // forward
+
+    struct lambda_gen 
+        : lambda_actor_gen<
+            fusion::vector<>
+          , detail::map_local_index_to_tuple<> >
+    {
+        typedef 
+            lambda_actor_gen<
+                fusion::vector<>
+              , detail::map_local_index_to_tuple<> >
+        base_type;
+
+        lambda_gen()
+            : base_type(fusion::vector<>())
+        {
+        }
+
+        template <typename K0, typename V0>
+        lambda_actor_gen<
+            fusion::vector<V0>
+          , detail::map_local_index_to_tuple<K0>
+        >
+        operator()(
+            actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0
+        ) const
+        {
+            return fusion::vector<V0>(fusion::at_c<1>(a0));
+        }
+    
+        template <typename K0, typename K1, typename V0, typename V1>
+        lambda_actor_gen<
+            fusion::vector<V0, V1>
+          , detail::map_local_index_to_tuple<K0, K1>
+        >
+        operator()(
+            actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0
+          , actor<composite<assign_eval, fusion::vector<local_variable<K1>, V1> > > const& a1
+        ) const
+        {
+            return fusion::vector<V0, V1>(fusion::at_c<1>(a0), fusion::at_c<1>(a1));
+        }
+        
+        // Bring in the rest...
+        #define PHOENIX_LOCAL_GEN_NAME lambda_actor_gen
+        #include <boost/spirit/home/phoenix/scope/detail/local_gen.hpp>
+        #undef PHOENIX_LOCAL_GEN_NAME
+    };
+
+    lambda_gen const lambda = lambda_gen();
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp
new file mode 100644
index 0000000..40e951a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp
@@ -0,0 +1,145 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2004 Daniel Wallin
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_LET_HPP
+#define PHOENIX_SCOPE_LET_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/core/composite.hpp>
+#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp>
+#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp>
+#include <boost/spirit/home/phoenix/detail/local_reference.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/fusion/include/transform.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename Base, typename Vars, typename Map>
+    struct let_actor : Base
+    {
+        typedef typename
+            mpl::fold<
+                Vars
+              , mpl::false_
+              , detail::compute_no_nullary
+            >::type
+        no_nullary;
+        
+        template <typename Env>
+        struct result
+        {
+            typedef typename 
+                fusion::result_of::as_vector<
+                    typename fusion::result_of::transform<
+                        Vars
+                      , detail::initialize_local<Env>
+                    >::type
+                >::type 
+            locals_type;
+
+            typedef typename Base::template
+                result<scoped_environment<Env, Env, locals_type, Map> >::type
+            result_type;
+            
+            typedef typename 
+                detail::unwrap_local_reference<result_type>::type 
+            type;
+        };
+
+        let_actor(Base const& base, Vars const& vars)
+            : Base(base), vars(vars) {}
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename 
+                fusion::result_of::as_vector<
+                    typename fusion::result_of::transform<
+                        Vars
+                      , detail::initialize_local<Env>
+                    >::type
+                >::type 
+            locals_type;
+
+            locals_type locals = 
+                fusion::as_vector(
+                    fusion::transform(
+                        vars
+                      , detail::initialize_local<Env>(env)));
+            
+            typedef typename result<Env>::type RT;
+            return RT(Base::eval(
+                scoped_environment<Env, Env, locals_type, Map>(
+                    env
+                  , env
+                  , locals)));
+        }
+
+        Vars vars;
+    };
+    
+    template <typename Vars, typename Map>
+    struct let_actor_gen
+    {
+        template <typename Base>
+        actor<let_actor<Base, Vars, Map> > const
+        operator[](actor<Base> const& base) const
+        {
+            return let_actor<Base, Vars, Map>(base, vars);
+        }
+
+        let_actor_gen(Vars const& vars)
+            : vars(vars) {}
+
+        Vars vars;
+    };
+
+    template <typename Key>
+    struct local_variable; // forward
+    struct assign_eval; // forward
+
+    struct let_gen
+    {
+        template <typename K0, typename V0>
+        let_actor_gen<
+            fusion::vector<V0>
+          , detail::map_local_index_to_tuple<K0>
+        >
+        operator()(
+            actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0
+        ) const
+        {
+            return fusion::vector<V0>(fusion::at_c<1>(a0));
+        }
+    
+        template <typename K0, typename K1, typename V0, typename V1>
+        let_actor_gen<
+            fusion::vector<V0, V1>
+          , detail::map_local_index_to_tuple<K0, K1>
+        >
+        operator()(
+            actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0
+          , actor<composite<assign_eval, fusion::vector<local_variable<K1>, V1> > > const& a1
+        ) const
+        {
+            return fusion::vector<V0, V1>(fusion::at_c<1>(a0), fusion::at_c<1>(a1));
+        }
+        
+        // Bring in the rest...
+        #define PHOENIX_LOCAL_GEN_NAME let_actor_gen
+        #include <boost/spirit/home/phoenix/scope/detail/local_gen.hpp>
+        #undef PHOENIX_LOCAL_GEN_NAME
+    };
+
+    let_gen const let = let_gen();
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp
new file mode 100644
index 0000000..5987ed4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp
@@ -0,0 +1,111 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2004 Daniel Wallin
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_LOCAL_VARIABLE_HPP
+#define PHOENIX_SCOPE_LOCAL_VARIABLE_HPP
+
+#include <boost/spirit/home/phoenix/core/limits.hpp>
+#include <boost/spirit/home/phoenix/detail/local_reference.hpp>
+#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp>
+#include <boost/spirit/home/phoenix/core/actor.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace phoenix
+{
+    template <typename Key>
+    struct local_variable
+    {
+        typedef Key key_type;
+
+        // This will prevent actor::operator()() from kicking in.
+        // Actually, we do not need all actor::operator()s for
+        // all arities, but this will suffice. The nullary 
+        // actor::operator() is particularly troublesome because 
+        // it is always eagerly evaluated by the compiler.
+        typedef mpl::true_ no_nullary; 
+
+        template <typename Env>
+        struct result : detail::apply_local<local_variable<Key>, Env> {};
+
+        template <typename Env>
+        typename result<Env>::type 
+        eval(Env const& env) const
+        {
+            typedef typename result<Env>::type return_type;
+            typedef typename 
+                detail::get_index<typename Env::map_type, Key>::type 
+            index_type;
+            typedef detail::eval_local<Key> eval_local;
+
+            return eval_local::template get<return_type>(
+                env
+              , index_type());
+        }
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        local_variable& operator= (local_variable const&);
+    };
+
+    namespace local_names
+    {
+        actor<local_variable<struct _a_key> > const _a 
+            = local_variable<struct _a_key>();
+        actor<local_variable<struct _b_key> > const _b 
+            = local_variable<struct _b_key>();
+        actor<local_variable<struct _c_key> > const _c 
+            = local_variable<struct _c_key>();
+        actor<local_variable<struct _d_key> > const _d 
+            = local_variable<struct _d_key>();
+        actor<local_variable<struct _e_key> > const _e 
+            = local_variable<struct _e_key>();
+        actor<local_variable<struct _f_key> > const _f 
+            = local_variable<struct _f_key>();
+        actor<local_variable<struct _g_key> > const _g 
+            = local_variable<struct _g_key>();
+        actor<local_variable<struct _h_key> > const _h 
+            = local_variable<struct _h_key>();
+        actor<local_variable<struct _i_key> > const _i 
+            = local_variable<struct _i_key>();
+        actor<local_variable<struct _j_key> > const _j 
+            = local_variable<struct _j_key>();
+        actor<local_variable<struct _k_key> > const _k 
+            = local_variable<struct _k_key>();
+        actor<local_variable<struct _l_key> > const _l 
+            = local_variable<struct _l_key>();
+        actor<local_variable<struct _m_key> > const _m 
+            = local_variable<struct _m_key>();
+        actor<local_variable<struct _n_key> > const _n 
+            = local_variable<struct _n_key>();
+        actor<local_variable<struct _o_key> > const _o 
+            = local_variable<struct _o_key>();
+        actor<local_variable<struct _p_key> > const _p 
+            = local_variable<struct _p_key>();
+        actor<local_variable<struct _q_key> > const _q 
+            = local_variable<struct _q_key>();
+        actor<local_variable<struct _r_key> > const _r 
+            = local_variable<struct _r_key>();
+        actor<local_variable<struct _s_key> > const _s 
+            = local_variable<struct _s_key>();
+        actor<local_variable<struct _t_key> > const _t 
+            = local_variable<struct _t_key>();
+        actor<local_variable<struct _u_key> > const _u 
+            = local_variable<struct _u_key>();
+        actor<local_variable<struct _v_key> > const _v 
+            = local_variable<struct _v_key>();
+        actor<local_variable<struct _w_key> > const _w 
+            = local_variable<struct _w_key>();
+        actor<local_variable<struct _x_key> > const _x 
+            = local_variable<struct _x_key>();
+        actor<local_variable<struct _y_key> > const _y 
+            = local_variable<struct _y_key>();
+        actor<local_variable<struct _z_key> > const _z 
+            = local_variable<struct _z_key>();
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp
new file mode 100644
index 0000000..b23f9ee
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp
@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2004 Daniel Wallin
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP
+#define PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP
+
+namespace boost { namespace phoenix
+{
+    template <typename Env, typename OuterEnv, typename Locals, typename Map>
+    struct scoped_environment
+    {
+        typedef Env env_type;
+        typedef OuterEnv outer_env_type;
+        typedef Locals locals_type;
+        typedef Map map_type;
+        typedef typename Env::args_type args_type;
+        typedef typename Env::tie_type tie_type;
+
+        scoped_environment(
+            Env const& env
+          , OuterEnv const& outer_env
+          , Locals& locals)
+            : env(env)
+            , outer_env(outer_env)
+            , locals(locals) {}
+
+        tie_type const& 
+        args() const
+        {
+            return env.args();
+        }
+
+        Env const& env;
+        OuterEnv const& outer_env;
+        Locals& locals;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        scoped_environment& operator= (scoped_environment const&);
+    };
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp
new file mode 100644
index 0000000..c29baf8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp
@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 2005-2008 Hartmut Kaiser
+    Copyright (c) 2005-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_VERSION_HPP
+#define PHOENIX_VERSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  This is the version of the library
+//
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_PHOENIX_VERSION   0x2000    // 2.0.0
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp
new file mode 100644
index 0000000..38142bf
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp
@@ -0,0 +1,392 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM)
+#define BOOST_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/qi/detail/construct.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/container.hpp>
+#include <boost/fusion/include/copy.hpp>
+#include <boost/ref.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  This file contains assignment utilities. The utilities provided also
+    //  accept spirit's unused_type; all no-ops. Compiler optimization will
+    //  easily strip these away.
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename T>
+        struct is_iter_range : mpl::false_ {};
+
+        template <typename I>
+        struct is_iter_range<boost::iterator_range<I> > : mpl::true_ {};
+
+        template <typename C>
+        struct is_container_of_ranges
+          : is_iter_range<typename C::value_type> {};
+    }
+
+    template <typename Attribute, typename Iterator, typename Enable>
+    struct assign_to_attribute_from_iterators
+    {
+        // Common case
+        static void
+        call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::false_)
+        {
+            if (traits::is_empty(attr))
+                attr = Attribute(first, last);
+            else {
+                for (Iterator i = first; i != last; ++i)
+                    push_back(attr, *i);
+            }
+        }
+
+        // If Attribute is a container with value_type==iterator_range<T> just push the
+        // iterator_range into it
+        static void
+        call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::true_)
+        {
+            typename Attribute::value_type rng(first, last);
+            push_back(attr, rng);
+        }
+
+        static void
+        call(Iterator const& first, Iterator const& last, Attribute& attr)
+        {
+            call(first, last, attr, detail::is_container_of_ranges<Attribute>());
+        }
+    };
+
+    template <typename Attribute, typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        reference_wrapper<Attribute>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , reference_wrapper<Attribute> attr)
+        {
+            if (traits::is_empty(attr))
+                attr = Attribute(first, last);
+            else {
+                for (Iterator i = first; i != last; ++i)
+                    push_back(attr, *i);
+            }
+        }
+    };
+
+    template <typename Attribute, typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        boost::optional<Attribute>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , boost::optional<Attribute>& attr)
+        {
+            Attribute val;
+            assign_to(first, last, val);
+            attr = val;
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        iterator_range<Iterator>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , iterator_range<Iterator>& attr)
+        {
+            attr = iterator_range<Iterator>(first, last);
+        }
+    };
+
+    template <typename Iterator, typename Attribute>
+    inline void
+    assign_to(Iterator const& first, Iterator const& last, Attribute& attr)
+    {
+        assign_to_attribute_from_iterators<Attribute, Iterator>::
+            call(first, last, attr);
+    }
+
+    template <typename Iterator>
+    inline void
+    assign_to(Iterator const&, Iterator const&, unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Attribute>
+    void assign_to(T const& val, Attribute& attr);
+
+    template <typename Attribute, typename T, typename Enable>
+    struct assign_to_attribute_from_value
+    {
+        typedef typename traits::one_element_sequence<Attribute>::type
+            is_one_element_sequence;
+
+        typedef typename mpl::eval_if<
+            is_one_element_sequence
+          , fusion::result_of::at_c<Attribute, 0>
+          , mpl::identity<Attribute&>
+        >::type type;
+
+        template <typename T_>
+        static void
+        call(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            attr = static_cast<Attribute>(val);
+        }
+
+        // This handles the case where the attribute is a single element fusion
+        // sequence. We silently assign to the only element and treat it as the
+        // attribute to parse the results into.
+        template <typename T_>
+        static void
+        call(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            typedef typename fusion::result_of::value_at_c<Attribute, 0>::type
+                element_type;
+            fusion::at_c<0>(attr) = static_cast<element_type>(val);
+        }
+
+        static void
+        call(T const& val, Attribute& attr)
+        {
+            call(val, attr, is_one_element_sequence());
+        }
+    };
+
+    template <typename Attribute>
+    struct assign_to_attribute_from_value<Attribute, Attribute>
+    {
+        static void
+        call(Attribute const& val, Attribute& attr)
+        {
+            attr = val;
+        }
+    };
+
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, reference_wrapper<T>
+      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
+    {
+        static void
+        call(reference_wrapper<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, boost::optional<T>
+      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
+    {
+        static void
+        call(boost::optional<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+
+    namespace detail
+    {
+        template <typename A, typename B>
+        struct is_same_size_sequence
+          : mpl::bool_<fusion::result_of::size<A>::value
+                == fusion::result_of::size<B>::value>
+        {};
+    }
+
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, T,
+            mpl::and_<
+                fusion::traits::is_sequence<Attribute>,
+                fusion::traits::is_sequence<T>,
+                detail::is_same_size_sequence<Attribute, T>
+            >
+        >
+    {
+        static void
+        call(T const& val, Attribute& attr)
+        {
+            fusion::copy(val, attr);
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename T, typename Enable>
+    struct assign_to_container_from_value
+    {
+        // T is not a container and not a string
+        template <typename T_>
+        static void call(T_ const& val, Attribute& attr, mpl::false_, mpl::false_)
+        {
+            traits::push_back(attr, val);
+        }
+
+        // T is a container (but not a string), and T is convertible to the 
+        // value_type of the Attribute container
+        template <typename T_>
+        static void 
+        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            traits::push_back(attr, val);
+        }
+
+        // T is a container (but not a string), generic overload
+        template <typename T_>
+        static void 
+        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            typedef typename traits::container_iterator<T_ const>::type
+                iterator_type;
+
+            iterator_type end = traits::end(val);
+            for (iterator_type i = traits::begin(val); i != end; traits::next(i))
+                traits::push_back(attr, traits::deref(i));
+        }
+
+        // T is a container (but not a string)
+        template <typename T_>
+        static void call(T_ const& val, Attribute& attr,  mpl::true_, mpl::false_)
+        {
+            typedef typename container_value<Attribute>::type value_type;
+            typedef typename is_convertible<T, value_type>::type is_value_type;
+
+            append_to_container_not_string(val, attr, is_value_type());
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        // T is a string
+        template <typename Iterator>
+        static void append_to_string(Attribute& attr, Iterator begin, Iterator end)
+        {
+            for (Iterator i = begin; i != end; ++i)
+                traits::push_back(attr, *i);
+        }
+
+        // T is string, but not convertible to value_type of container
+        template <typename T_>
+        static void append_to_container(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            typedef typename char_type_of<T_>::type char_type;
+
+            append_to_string(attr, traits::get_begin<char_type>(val)
+              , traits::get_end<char_type>(val));
+        }
+
+        // T is string, and convertible to value_type of container
+        template <typename T_>
+        static void append_to_container(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            traits::push_back(attr, val);
+        }
+
+        template <typename T_, typename Pred>
+        static void call(T_ const& val, Attribute& attr, Pred, mpl::true_)
+        {
+            typedef typename container_value<Attribute>::type value_type;
+            typedef typename is_convertible<T, value_type>::type is_value_type;
+
+            append_to_container(val, attr, is_value_type());
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        static void call(T const& val, Attribute& attr)
+        {
+            typedef typename traits::is_container<T>::type is_container;
+            typedef typename traits::is_string<T>::type is_string;
+
+            call(val, attr, is_container(), is_string());
+        }
+    };
+
+    template <typename Attribute>
+    struct assign_to_container_from_value<Attribute, Attribute>
+    {
+        static void
+        call(Attribute const& val, Attribute& attr)
+        {
+            attr = val;
+        }
+    };
+
+    template <typename Attribute, typename T>
+    struct assign_to_container_from_value<Attribute, boost::optional<T>
+      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
+    {
+        static void
+        call(boost::optional<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+
+    template <typename Attribute, typename T>
+    struct assign_to_container_from_value<Attribute, reference_wrapper<T>
+      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
+    {
+        static void
+        call(reference_wrapper<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        // overload for non-container attributes
+        template <typename T, typename Attribute>
+        inline void
+        assign_to(T const& val, Attribute& attr, mpl::false_)
+        {
+            assign_to_attribute_from_value<Attribute, T>::call(val, attr);
+        }
+
+        // overload for containers (but not for variants or optionals
+        // holding containers)
+        template <typename T, typename Attribute>
+        inline void
+        assign_to(T const& val, Attribute& attr, mpl::true_)
+        {
+            assign_to_container_from_value<Attribute, T>::call(val, attr);
+        }
+    }
+
+    template <typename T, typename Attribute>
+    inline void
+    assign_to(T const& val, Attribute& attr)
+    {
+        typedef typename mpl::and_<
+            traits::is_container<Attribute>
+          , traits::not_is_variant<Attribute>
+          , traits::not_is_optional<Attribute>
+        >::type is_not_wrapped_container;
+
+        detail::assign_to(val, attr, is_not_wrapped_container());
+    }
+
+    template <typename T>
+    inline void
+    assign_to(T const&, unused_type)
+    {
+    }
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp
new file mode 100644
index 0000000..0a66a65
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp
@@ -0,0 +1,176 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2001-2011 Joel de Guzman
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(SPIRIT_QI_DETAIL_ATTRIBUTES_APR_18_2010_0458PM)
+#define SPIRIT_QI_DETAIL_ATTRIBUTES_APR_18_2010_0458PM
+
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+#include <boost/spirit/home/support/attributes.hpp>
+#include <boost/spirit/home/support/utree/utree_traits_fwd.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Exposed, typename Transformed>
+    struct default_transform_attribute
+    {
+        typedef Transformed type;
+
+        static Transformed pre(Exposed&) { return Transformed(); }
+
+        static void post(Exposed& val, Transformed const& attr)
+        {
+            traits::assign_to(attr, val);
+        }
+
+        // fail() will be called by Qi rule's if the rhs failed parsing
+        static void fail(Exposed&) {}
+    };
+
+    // handle case where no transformation is required as the types are the same
+    template <typename Attribute>
+    struct default_transform_attribute<Attribute, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+
+    template <typename Exposed, typename Transformed>
+    struct proxy_transform_attribute
+    {
+        typedef Transformed type;
+
+        static Transformed pre(Exposed& val) { return Transformed(val); }
+        static void post(Exposed&, Transformed const&) { /* no-op */ }
+
+        // fail() will be called by Qi rule's if the rhs failed parsing
+        static void fail(Exposed&) {}
+    };
+
+    // handle case where no transformation is required as the types are the same
+    template <typename Attribute>
+    struct proxy_transform_attribute<Attribute, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+
+    // main specialization for Qi
+    template <typename Exposed, typename Transformed, typename Enable = void>
+    struct transform_attribute
+      : mpl::if_<
+            mpl::and_<
+                mpl::not_<is_const<Exposed> >
+              , mpl::not_<is_reference<Exposed> >
+              , traits::is_proxy<Transformed> >
+          , proxy_transform_attribute<Exposed, Transformed>
+          , default_transform_attribute<Exposed, Transformed> 
+        >::type 
+    {};
+
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<boost::optional<Exposed>, Transformed
+      , typename disable_if<is_same<boost::optional<Exposed>, Transformed> >::type>
+    {
+        typedef Transformed& type;
+        static Transformed& pre(boost::optional<Exposed>& val)
+        {
+            if (!val)
+                val = Transformed();
+            return boost::get<Transformed>(val);
+        }
+        static void post(boost::optional<Exposed>&, Transformed const&) {}
+        static void fail(boost::optional<Exposed>& val)
+        {
+             val = none_t();    // leave optional uninitialized if rhs failed
+        }
+    };
+
+    // reference types need special handling
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+
+    // unused_type needs some special handling as well
+    template <>
+    struct transform_attribute<unused_type, unused_type>
+    {
+        typedef unused_type type;
+        static unused_type pre(unused_type) { return unused; }
+        static void post(unused_type, unused_type) {}
+        static void fail(unused_type) {}
+    };
+
+    template <>
+    struct transform_attribute<unused_type const, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+
+    template <typename Attribute>
+    struct transform_attribute<unused_type, Attribute>
+      : transform_attribute<unused_type, unused_type>
+    {};
+
+    template <typename Attribute>
+    struct transform_attribute<unused_type const, Attribute>
+      : transform_attribute<unused_type, unused_type>
+    {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute const, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed, Transformed, qi::domain>
+      : qi::transform_attribute<Exposed, Transformed>
+    {};
+
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed&, Transformed, qi::domain>
+      : transform_attribute<Exposed, Transformed, qi::domain>
+    {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute, qi::domain>
+      : qi::transform_attribute<Attribute&, Attribute>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Exposed, typename Transformed>
+    void post_transform(Exposed& dest, Transformed const& attr)
+    {
+        return transform_attribute<Exposed, Transformed, qi::domain>::post(dest, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Exposed, typename Transformed>
+    void fail_transform(Exposed& dest, Transformed const&)
+    {
+        return transform_attribute<Exposed, Transformed, qi::domain>::fail(dest);
+    }
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp
new file mode 100644
index 0000000..5d8122f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp
@@ -0,0 +1,202 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONSTRUCT_MAR_24_2007_0629PM)
+#define BOOST_SPIRIT_CONSTRUCT_MAR_24_2007_0629PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/spirit/home/qi/parse.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  We provide overloads for the assign_to_attribute_from_iterators
+    //  customization point for all built in types
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, char& attr)
+        {
+            attr = *first;
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<signed char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, signed char& attr)
+        {
+            attr = *first;
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, unsigned char& attr)
+        {
+            attr = *first;
+        }
+    };
+
+    // wchar_t is intrinsic
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<wchar_t, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, wchar_t& attr)
+        {
+            attr = *first;
+        }
+    };
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    // wchar_t is intrinsic, have separate overload for unsigned short
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned short, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, unsigned short& attr)
+        {
+            attr = *first;
+        }
+    };
+#endif
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<bool, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, bool& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, bool_type(), attr);
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<short, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, short& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, short_type(), attr);
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<int, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, int& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, int_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned int, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, unsigned int& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, uint_type(), attr);
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned long, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, unsigned long& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, ulong_type(), attr);
+        }
+    };
+
+#ifdef BOOST_HAS_LONG_LONG
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long_long_type, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long_long_type& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_long_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<ulong_long_type, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, ulong_long_type& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, ulong_long_type(), attr);
+        }
+    };
+#endif
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<float, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, float& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, float_type(), attr);
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<double, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, double& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, double_type(), attr);
+        }
+    };
+
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long double, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long double& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_double_type(), attr);
+        }
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp
new file mode 100644
index 0000000..b81f1e7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp
@@ -0,0 +1,97 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_DETAIL_PARSE_DEC_02_2009_0411PM)
+#define BOOST_SPIRIT_DETAIL_PARSE_DEC_02_2009_0411PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/skip_flag.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Expr, typename Enable = void>
+    struct parse_impl
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        // Did you intend to use the auto_ facilities while forgetting to 
+        // #include <boost/spirit/include/qi_auto.hpp>?
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+    };
+
+    template <typename Expr>
+    struct parse_impl<Expr
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        template <typename Iterator>
+        static bool call(
+            Iterator& first
+          , Iterator last
+          , Expr const& expr)
+        {
+            return compile<qi::domain>(expr).parse(
+                first, last, unused, unused, unused);
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Expr, typename Enable = void>
+    struct phrase_parse_impl
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        // Did you intend to use the auto_ facilities while forgetting to 
+        // #include <boost/spirit/include/qi_auto.hpp>?
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+    };
+
+    template <typename Expr>
+    struct phrase_parse_impl<Expr
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        template <typename Iterator, typename Skipper>
+        static bool call(
+            Iterator& first
+          , Iterator last
+          , Expr const& expr
+          , Skipper const& skipper
+          , BOOST_SCOPED_ENUM(skip_flag) post_skip)
+        {
+            // Report invalid expression error as early as possible.
+            // If you got an error_invalid_expression error message here,
+            // then the skipper is not a valid spirit qi expression.
+            BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper);
+
+            typedef
+                typename result_of::compile<qi::domain, Skipper>::type
+            skipper_type;
+            skipper_type const skipper_ = compile<qi::domain>(skipper);
+
+            if (!compile<qi::domain>(expr).parse(
+                    first, last, unused, skipper_, unused))
+                return false;
+
+            if (post_skip == skip_flag::postskip)
+                qi::skip_over(first, last, skipper_);
+            return true;
+        }
+    };
+
+}}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp
new file mode 100644
index 0000000..c1405d6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp
@@ -0,0 +1,50 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_QI_UNUSED_SKIPPER_JUL_25_2009_0921AM)
+#define BOOST_SPIRIT_QI_UNUSED_SKIPPER_JUL_25_2009_0921AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Skipper>
+    struct unused_skipper : unused_type
+    {
+        unused_skipper(Skipper const& skipper)
+          : skipper(skipper) {}
+        Skipper const& skipper;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        unused_skipper& operator= (unused_skipper const&);
+    };
+
+    // If a surrounding lexeme[] directive was specified, the current
+    // skipper is of the type unused_skipper. In this case we 
+    // re-activate the skipper which was active before the skip[]
+    // directive.
+    template <typename Skipper>
+    inline Skipper const& 
+    get_skipper(unused_skipper<Skipper> const& u)
+    {
+        return u.skipper;
+    }
+
+    // If no surrounding lexeme[] directive was specified we keep what we got.
+    template <typename Skipper>
+    inline Skipper const& 
+    get_skipper(Skipper const& u)
+    {
+        return u;
+    }
+
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/domain.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/domain.hpp
new file mode 100644
index 0000000..cc6b8c3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/domain.hpp
@@ -0,0 +1,74 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_DOMAIN_JANUARY_29_2007_0954AM)
+#define BOOST_SPIRIT_DOMAIN_JANUARY_29_2007_0954AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/support/argument.hpp>
+#include <boost/spirit/home/support/context.hpp>
+
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    // qi's domain
+    struct domain {};
+
+    // bring in some of spirit parts into spirit::qi
+    using spirit::unused;
+    using spirit::unused_type;
+    using spirit::compile;
+    using spirit::info;
+
+    // You can bring these in with the using directive
+    // without worrying about bringing in too much.
+    namespace labels
+    {
+        BOOST_PP_REPEAT(SPIRIT_ARGUMENTS_LIMIT, SPIRIT_USING_ARGUMENT, _)
+        BOOST_PP_REPEAT(SPIRIT_ATTRIBUTES_LIMIT, SPIRIT_USING_ATTRIBUTE, _)
+
+        using spirit::_pass_type;
+        using spirit::_val_type;
+        using spirit::_a_type;
+        using spirit::_b_type;
+        using spirit::_c_type;
+        using spirit::_d_type;
+        using spirit::_e_type;
+        using spirit::_f_type;
+        using spirit::_g_type;
+        using spirit::_h_type;
+        using spirit::_i_type;
+        using spirit::_j_type;
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+        using spirit::_pass;
+        using spirit::_val;
+        using spirit::_a;
+        using spirit::_b;
+        using spirit::_c;
+        using spirit::_d;
+        using spirit::_e;
+        using spirit::_f;
+        using spirit::_g;
+        using spirit::_h;
+        using spirit::_i;
+        using spirit::_j;
+
+#endif
+    }
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/meta_compiler.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/meta_compiler.hpp
new file mode 100644
index 0000000..68649c0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/meta_compiler.hpp
@@ -0,0 +1,177 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_META_COMPILER_OCTOBER_16_2008_0347PM)
+#define BOOST_SPIRIT_META_COMPILER_OCTOBER_16_2008_0347PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/at.hpp>
+
+namespace boost { namespace spirit
+{
+    template <typename T>
+    struct use_terminal<qi::domain, T
+      , typename enable_if<traits::is_parser<T> >::type> // enables parsers
+      : mpl::true_ {};
+
+    namespace qi
+    {
+        template <typename T, typename Modifiers, typename Enable = void>
+        struct make_primitive // by default, return it as-is
+        {
+            typedef T result_type;
+
+            template <typename T_>
+            T_& operator()(T_& val, unused_type) const
+            {
+                return val;
+            }
+
+            template <typename T_>
+            T_ const& operator()(T_ const& val, unused_type) const
+            {
+                return val;
+            }
+        };
+
+        template <typename Tag, typename Elements
+          , typename Modifiers, typename Enable = void>
+        struct make_composite;
+
+        template <typename Directive, typename Body
+          , typename Modifiers, typename Enable = void>
+        struct make_directive
+        {
+            typedef Body result_type;
+            result_type operator()(unused_type, Body const& body, unused_type) const
+            {
+                return body; // By default, a directive simply returns its subject
+            }
+        };
+    }
+
+    // Qi primitive meta-compiler
+    template <>
+    struct make_component<qi::domain, proto::tag::terminal>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename qi::make_primitive<
+                typename remove_const<typename Elements::car_type>::type,
+                typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            typedef typename remove_const<typename Elements::car_type>::type term;
+            return qi::make_primitive<term, Modifiers>()(elements.car, modifiers);
+        }
+    };
+
+    // Qi composite meta-compiler
+    template <typename Tag>
+    struct make_component<qi::domain, Tag>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_composite<Tag, Elements,
+                typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_composite<Tag, Elements, Modifiers>()(
+                elements, modifiers);
+        }
+    };
+
+    // Qi function meta-compiler
+    template <>
+    struct make_component<qi::domain, proto::tag::function>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_composite<
+                    typename remove_const<typename Elements::car_type>::type,
+                    typename Elements::cdr_type,
+                    typename remove_reference<Modifiers>::type
+                >::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_composite<
+                typename remove_const<typename Elements::car_type>::type,
+                typename Elements::cdr_type,
+                Modifiers>()(elements.cdr, modifiers);
+        }
+    };
+
+    // Qi directive meta-compiler
+    template <>
+    struct make_component<qi::domain, tag::directive>
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_directive<
+                    typename remove_const<typename Elements::car_type>::type,
+                    typename remove_const<typename Elements::cdr_type::car_type>::type,
+                    typename remove_reference<Modifiers>::type
+                >::result_type
+            type;
+        };
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_directive<
+                typename remove_const<typename Elements::car_type>::type,
+                typename remove_const<typename Elements::cdr_type::car_type>::type,
+                Modifiers>()(elements.car, elements.cdr.car, modifiers);
+        }
+    };
+
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/fcall.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/fcall.hpp
new file mode 100644
index 0000000..e4fa17f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/fcall.hpp
@@ -0,0 +1,53 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_FILENAME_1 \
+    <boost/spirit/home/qi/nonterminal/detail/fcall.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, SPIRIT_ARGUMENTS_LIMIT)
+#include BOOST_PP_ITERATE()
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#else // defined(BOOST_PP_IS_ITERATING)
+
+#define N BOOST_PP_ITERATION()
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename A)>
+    typename lazy_enable_if_c<
+        (params_size == N)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector<BOOST_PP_ENUM_PARAMS(N, A)> >
+        >
+    >::type
+    operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& f)) const
+    {
+        typedef fusion::vector<BOOST_PP_ENUM_PARAMS(N, A)> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector(BOOST_PP_ENUM_PARAMS(N, f)))
+        );
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp
new file mode 100644
index 0000000..0300a06
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2009 Francois Barel
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_PARAMETERIZED_AUGUST_09_2009_0539AM)
+#define BOOST_SPIRIT_PARAMETERIZED_AUGUST_09_2009_0539AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/ref.hpp>
+
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // parameterized_nonterminal: parser representing the invocation of a
+    // nonterminal, passing inherited attributes
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename Params>
+    struct parameterized_nonterminal
+      : parser<parameterized_nonterminal<Subject, Params> >
+    {
+        parameterized_nonterminal(Subject const& subject, Params const& params)
+          : ref(subject), params(params)
+        {
+        }
+
+        template <typename Context, typename Iterator>
+        struct attribute
+            // Forward to subject.
+          : Subject::template attribute<Context, Iterator> {};
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            // Forward to subject, passing the additional
+            // params argument to parse.
+            return ref.get().parse(first, last, context, skipper, attr, params);
+        }
+
+        template <typename Context>
+        info what(Context& context) const
+        {
+            // Forward to subject.
+            return ref.get().what(context);
+        }
+
+        boost::reference_wrapper<Subject const> ref;
+        Params params;
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename Params, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::parameterized_nonterminal<Subject, Params>
+          , Attribute, Context, Iterator>
+      : handles_container<typename remove_const<Subject>::type
+        , Attribute, Context, Iterator> 
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp
new file mode 100644
index 0000000..91bceba
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_PARSER_BINDER_DECEMBER_05_2008_0516_PM)
+#define BOOST_SPIRIT_PARSER_BINDER_DECEMBER_05_2008_0516_PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/fusion/include/at.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/spirit/home/support/has_semantic_action.hpp>
+
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    // parser_binder for plain rules
+    template <typename Parser, typename Auto>
+    struct parser_binder
+    {
+        parser_binder(Parser const& p)
+          : p(p) {}
+
+        template <typename Iterator, typename Skipper, typename Context>
+        bool call(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, mpl::true_) const
+        {
+            // If DeducedAuto is false (semantic actions is present), the 
+            // component's attribute is unused.
+            return p.parse(first, last, context, skipper, unused);
+        }
+
+        template <typename Iterator, typename Skipper, typename Context>
+        bool call(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, mpl::false_) const
+        {
+            // If DeducedAuto is true (no semantic action), we pass the rule's 
+            // attribute on to the component.
+            return p.parse(first, last, context, skipper
+                , fusion::at_c<0>(context.attributes));
+        }
+
+        template <typename Iterator, typename Skipper, typename Context>
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            // If Auto is false, we need to deduce whether to apply auto rule
+            typedef typename traits::has_semantic_action<Parser>::type auto_rule;
+            return call(first, last, context, skipper, auto_rule());
+        }
+
+        Parser p;
+    };
+
+    // parser_binder for auto rules
+    template <typename Parser>
+    struct parser_binder<Parser, mpl::true_>
+    {
+        parser_binder(Parser const& p)
+          : p(p) {}
+
+        template <typename Iterator, typename Skipper, typename Context>
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            // If Auto is true, we pass the rule's attribute on to the component.
+            return p.parse(first, last, context, skipper
+                , fusion::at_c<0>(context.attributes));
+        }
+
+        Parser p;
+    };
+
+    template <typename Auto, typename Parser>
+    inline parser_binder<Parser, Auto>
+    bind_parser(Parser const& p)
+    {
+        return parser_binder<Parser, Auto>(p);
+    }
+}}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp
new file mode 100644
index 0000000..982e49b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp
@@ -0,0 +1,132 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_GRAMMAR_FEBRUARY_19_2007_0236PM)
+#define BOOST_SPIRIT_GRAMMAR_FEBRUARY_19_2007_0236PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/support/assert_msg.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/qi/nonterminal/rule.hpp>
+#include <boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp>
+#include <boost/spirit/home/qi/reference.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Iterator, typename T1, typename T2, typename T3
+      , typename T4>
+    struct grammar
+      : proto::extends<
+            typename proto::terminal<
+                reference<rule<Iterator, T1, T2, T3, T4> const>
+            >::type
+          , grammar<Iterator, T1, T2, T3, T4>
+        >
+      , parser<grammar<Iterator, T1, T2, T3, T4> >
+      , noncopyable
+    {
+        typedef Iterator iterator_type;
+        typedef rule<Iterator, T1, T2, T3, T4> start_type;
+        typedef typename start_type::sig_type sig_type;
+        typedef typename start_type::locals_type locals_type;
+        typedef typename start_type::skipper_type skipper_type;
+        typedef typename start_type::encoding_type encoding_type;
+        typedef grammar<Iterator, T1, T2, T3, T4> base_type;
+        typedef reference<start_type const> reference_;
+        typedef typename proto::terminal<reference_>::type terminal;
+
+        static size_t const params_size = start_type::params_size;
+
+        template <typename Context, typename Iterator_>
+        struct attribute
+        {
+            typedef typename start_type::attr_type type;
+        };
+
+        grammar(
+            start_type const& start
+          , std::string const& name_ = "unnamed-grammar")
+        : proto::extends<terminal, base_type>(terminal::make(reference_(start)))
+        , name_(name_)
+        {}
+
+        // This constructor is used to catch if the start rule is not
+        // compatible with the grammar.
+        template <typename Iterator_,
+            typename T1_, typename T2_, typename T3_, typename T4_>
+        grammar(
+            rule<Iterator_, T1_, T2_, T3_, T4_> const&
+          , std::string const& = "unnamed-grammar")
+        {
+            // If you see the assertion below failing then the start rule
+            // passed to the constructor of the grammar is not compatible with
+            // the grammar (i.e. it uses different template parameters).
+            BOOST_SPIRIT_ASSERT_MSG(
+                (is_same<start_type, rule<Iterator_, T1_, T2_, T3_, T4_> >::value)
+              , incompatible_start_rule, (rule<Iterator_, T1_, T2_, T3_, T4_>));
+        }
+
+        std::string name() const
+        {
+            return name_;
+        }
+
+        void name(std::string const& str)
+        {
+            name_ = str;
+        }
+
+        template <typename Context, typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return this->proto_base().child0.parse(
+                first, last, context, skipper, attr);
+        }
+
+        template <typename Context>
+        info what(Context&) const
+        {
+            return info(name_);
+        }
+
+        // bring in the operator() overloads
+        start_type const& get_parameterized_subject() const
+        { return this->proto_base().child0.ref.get(); }
+        typedef start_type parameterized_subject_type;
+        #include <boost/spirit/home/qi/nonterminal/detail/fcall.hpp>
+
+        std::string name_;
+
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <
+        typename IteratorA, typename IteratorB, typename Attribute
+      , typename Context, typename T1, typename T2, typename T3, typename T4>
+    struct handles_container<
+        qi::grammar<IteratorA, T1, T2, T3, T4>, Attribute, Context, IteratorB>
+      : traits::is_container<
+          typename attribute_of<
+              qi::grammar<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+          >::type
+        >
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp
new file mode 100644
index 0000000..9e39345
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp
@@ -0,0 +1,31 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_QI_NONTERMINAL_FWD_DEC_24_2010_1105PM)
+#define BOOST_SPIRIT_QI_NONTERMINAL_FWD_DEC_24_2010_1105PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    // forward declaration only
+    template <
+        typename Iterator, typename T1 = unused_type
+      , typename T2 = unused_type, typename T3 = unused_type
+      , typename T4 = unused_type>
+    struct rule;
+
+    template <
+        typename Iterator, typename T1 = unused_type
+      , typename T2 = unused_type, typename T3 = unused_type
+      , typename T4 = unused_type> 
+    struct grammar;
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp
new file mode 100644
index 0000000..23d2559
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp
@@ -0,0 +1,439 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_RULE_FEBRUARY_12_2007_1020AM)
+#define BOOST_SPIRIT_RULE_FEBRUARY_12_2007_1020AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/function.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/make_vector.hpp>
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/as_list.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/argument.hpp>
+#include <boost/spirit/home/support/context.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/qi/detail/attributes.hpp>
+#include <boost/spirit/home/support/nonterminal/extract_param.hpp>
+#include <boost/spirit/home/support/nonterminal/locals.hpp>
+#include <boost/spirit/home/qi/reference.hpp>
+#include <boost/spirit/home/qi/nonterminal/detail/parameterized.hpp>
+#include <boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp>
+#include <boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp>
+#include <boost/spirit/home/qi/skip_over.hpp>
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4355) // 'this' : used in base member initializer list warning
+#endif
+
+namespace boost { namespace spirit { namespace qi
+{
+    BOOST_PP_REPEAT(SPIRIT_ATTRIBUTES_LIMIT, SPIRIT_USING_ATTRIBUTE, _)
+
+    using spirit::_pass_type;
+    using spirit::_val_type;
+    using spirit::_a_type;
+    using spirit::_b_type;
+    using spirit::_c_type;
+    using spirit::_d_type;
+    using spirit::_e_type;
+    using spirit::_f_type;
+    using spirit::_g_type;
+    using spirit::_h_type;
+    using spirit::_i_type;
+    using spirit::_j_type;
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+    using spirit::_pass;
+    using spirit::_val;
+    using spirit::_a;
+    using spirit::_b;
+    using spirit::_c;
+    using spirit::_d;
+    using spirit::_e;
+    using spirit::_f;
+    using spirit::_g;
+    using spirit::_h;
+    using spirit::_i;
+    using spirit::_j;
+
+#endif
+
+    using spirit::info;
+    using spirit::locals;
+
+    template <
+        typename Iterator, typename T1, typename T2, typename T3
+      , typename T4>
+    struct rule
+      : proto::extends<
+            typename proto::terminal<
+                reference<rule<Iterator, T1, T2, T3, T4> const>
+            >::type
+          , rule<Iterator, T1, T2, T3, T4>
+        >
+      , parser<rule<Iterator, T1, T2, T3, T4> >
+    {
+        typedef Iterator iterator_type;
+        typedef rule<Iterator, T1, T2, T3, T4> this_type;
+        typedef reference<this_type const> reference_;
+        typedef typename proto::terminal<reference_>::type terminal;
+        typedef proto::extends<terminal, this_type> base_type;
+        typedef mpl::vector<T1, T2, T3, T4> template_params;
+
+        // The rule's locals_type: a sequence of types to be used as local variables
+        typedef typename
+            spirit::detail::extract_locals<template_params>::type
+        locals_type;
+
+        // The rule's skip-parser type
+        typedef typename
+            spirit::detail::extract_component<
+                qi::domain, template_params>::type
+        skipper_type;
+
+        // The rule's signature
+        typedef typename
+            spirit::detail::extract_sig<template_params>::type
+        sig_type;
+
+        // The rule's encoding type
+        typedef typename
+            spirit::detail::extract_encoding<template_params>::type
+        encoding_type;
+
+        // This is the rule's attribute type
+        typedef typename
+            spirit::detail::attr_from_sig<sig_type>::type
+        attr_type;
+        typedef typename add_reference<attr_type>::type attr_reference_type;
+
+        // parameter_types is a sequence of types passed as parameters to the rule
+        typedef typename
+            spirit::detail::params_from_sig<sig_type>::type
+        parameter_types;
+
+        static size_t const params_size =
+            fusion::result_of::size<parameter_types>::type::value;
+
+        typedef context<
+            fusion::cons<attr_reference_type, parameter_types>
+          , locals_type>
+        context_type;
+
+        typedef function<
+            bool(Iterator& first, Iterator const& last
+              , context_type& context
+              , skipper_type const& skipper
+            )>
+        function_type;
+
+        typedef typename
+            mpl::if_<
+                is_same<encoding_type, unused_type>
+              , unused_type
+              , tag::char_code<tag::encoding, encoding_type>
+            >::type
+        encoding_modifier_type;
+
+        explicit rule(std::string const& name_ = "unnamed-rule")
+          : base_type(terminal::make(reference_(*this)))
+          , name_(name_)
+        {
+        }
+
+        rule(rule const& rhs)
+          : base_type(terminal::make(reference_(*this)))
+          , name_(rhs.name_)
+          , f(rhs.f)
+        {
+        }
+
+        template <typename Auto, typename Expr>
+        static void define(rule& lhs, Expr const& expr, mpl::false_)
+        {
+            // Report invalid expression error as early as possible.
+            // If you got an error_invalid_expression error message here,
+            // then the expression (expr) is not a valid spirit qi expression.
+            BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+        }
+
+        template <typename Auto, typename Expr>
+        static void define(rule& lhs, Expr const& expr, mpl::true_)
+        {
+            lhs.f = detail::bind_parser<Auto>(
+                compile<qi::domain>(expr, encoding_modifier_type()));
+        }
+
+        template <typename Expr>
+        rule(Expr const& expr, std::string const& name_ = "unnamed-rule")
+          : base_type(terminal::make(reference_(*this)))
+          , name_(name_)
+        {
+            define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>());
+        }
+
+        rule& operator=(rule const& rhs)
+        {
+            // The following assertion fires when you try to initialize a rule
+            // from an uninitialized one. Did you mean to refer to the right
+            // hand side rule instead of assigning from it? In this case you
+            // should write lhs = rhs.alias();
+            BOOST_ASSERT(rhs.f && "Did you mean rhs.alias() instead of rhs?");
+
+            f = rhs.f;
+            name_ = rhs.name_;
+            return *this;
+        }
+
+        std::string const& name() const
+        {
+            return name_;
+        }
+
+        void name(std::string const& str)
+        {
+            name_ = str;
+        }
+
+        template <typename Expr>
+        rule& operator=(Expr const& expr)
+        {
+            define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>());
+            return *this;
+        }
+
+// VC7.1 has problems to resolve 'rule' without explicit template parameters
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+        // g++ 3.3 barfs if this is a member function :(
+        template <typename Expr>
+        friend rule& operator%=(rule& r, Expr const& expr)
+        {
+            define<mpl::true_>(r, expr, traits::matches<qi::domain, Expr>());
+            return r;
+        }
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+        // non-const version needed to suppress proto's %= kicking in
+        template <typename Expr>
+        friend rule& operator%=(rule& r, Expr& expr)
+        {
+            return r %= static_cast<Expr const&>(expr);
+        }
+#else
+        // for rvalue references
+        template <typename Expr>
+        friend rule& operator%=(rule& r, Expr&& expr)
+        {
+            define<mpl::true_>(r, expr, traits::matches<qi::domain, Expr>());
+            return r;
+        }
+#endif
+
+#else
+        // both friend functions have to be defined out of class as VC7.1
+        // will complain otherwise
+        template <typename OutputIterator_, typename T1_, typename T2_
+          , typename T3_, typename T4_, typename Expr>
+        friend rule<OutputIterator_, T1_, T2_, T3_, T4_>& operator%=(
+            rule<OutputIterator_, T1_, T2_, T3_, T4_>& r, Expr const& expr);
+
+        // non-const version needed to suppress proto's %= kicking in
+        template <typename OutputIterator_, typename T1_, typename T2_
+          , typename T3_, typename T4_, typename Expr>
+        friend rule<OutputIterator_, T1_, T2_, T3_, T4_>& operator%=(
+            rule<OutputIterator_, T1_, T2_, T3_, T4_>& r, Expr& expr);
+#endif
+
+        template <typename Context, typename Iterator_>
+        struct attribute
+        {
+            typedef attr_type type;
+        };
+
+        template <typename Context, typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            if (f)
+            {
+                // do a preskip if this is an implied lexeme
+                if (is_same<skipper_type, unused_type>::value)
+                    qi::skip_over(first, last, skipper);
+
+                typedef traits::make_attribute<attr_type, Attribute> make_attribute;
+
+                // do down-stream transformation, provides attribute for
+                // rhs parser
+                typedef traits::transform_attribute<
+                    typename make_attribute::type, attr_type, domain>
+                transform;
+
+                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename transform::type attr_ = transform::pre(made_attr);
+
+                // If you are seeing a compilation error here, you are probably
+                // trying to use a rule or a grammar which has inherited
+                // attributes, without passing values for them.
+                context_type context(attr_);
+
+                // If you are seeing a compilation error here stating that the
+                // fourth parameter can't be converted to a required target type
+                // then you are probably trying to use a rule or a grammar with
+                // an incompatible skipper type.
+                if (f(first, last, context, skipper))
+                {
+                    // do up-stream transformation, this integrates the results
+                    // back into the original attribute value, if appropriate
+                    traits::post_transform(attr, attr_);
+                    return true;
+                }
+
+                // inform attribute transformation of failed rhs
+                traits::fail_transform(attr, attr_);
+            }
+            return false;
+        }
+
+        template <typename Context, typename Skipper
+          , typename Attribute, typename Params>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& caller_context, Skipper const& skipper
+          , Attribute& attr, Params const& params) const
+        {
+            if (f)
+            {
+                // do a preskip if this is an implied lexeme
+                if (is_same<skipper_type, unused_type>::value)
+                    qi::skip_over(first, last, skipper);
+
+                typedef traits::make_attribute<attr_type, Attribute> make_attribute;
+
+                // do down-stream transformation, provides attribute for
+                // rhs parser
+                typedef traits::transform_attribute<
+                    typename make_attribute::type, attr_type, domain>
+                transform;
+
+                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename transform::type attr_ = transform::pre(made_attr);
+
+                // If you are seeing a compilation error here, you are probably
+                // trying to use a rule or a grammar which has inherited
+                // attributes, passing values of incompatible types for them.
+                context_type context(attr_, params, caller_context);
+
+                // If you are seeing a compilation error here stating that the
+                // fourth parameter can't be converted to a required target type
+                // then you are probably trying to use a rule or a grammar with
+                // an incompatible skipper type.
+                if (f(first, last, context, skipper))
+                {
+                    // do up-stream transformation, this integrates the results
+                    // back into the original attribute value, if appropriate
+                    traits::post_transform(attr, attr_);
+                    return true;
+                }
+
+                // inform attribute transformation of failed rhs
+                traits::fail_transform(attr, attr_);
+            }
+            return false;
+        }
+
+        template <typename Context>
+        info what(Context& /*context*/) const
+        {
+            return info(name_);
+        }
+
+        reference_ alias() const
+        {
+            return reference_(*this);
+        }
+
+        typename proto::terminal<this_type>::type copy() const
+        {
+            typename proto::terminal<this_type>::type result = {*this};
+            return result;
+        }
+
+        // bring in the operator() overloads
+        rule const& get_parameterized_subject() const { return *this; }
+        typedef rule parameterized_subject_type;
+        #include <boost/spirit/home/qi/nonterminal/detail/fcall.hpp>
+
+        std::string name_;
+        function_type f;
+    };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+    template <typename OutputIterator_, typename T1_, typename T2_
+      , typename T3_, typename T4_, typename Expr>
+    rule<OutputIterator_, T1_, T2_, T3_, T4_>& operator%=(
+        rule<OutputIterator_, T1_, T2_, T3_, T4_>& r, Expr const& expr)
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+
+        typedef typename
+            rule<OutputIterator_, T1_, T2_, T3_, T4_>::encoding_modifier_type
+        encoding_modifier_type;
+
+        r.f = detail::bind_parser<mpl::true_>(
+            compile<qi::domain>(expr, encoding_modifier_type()));
+        return r;
+    }
+
+    template <typename Iterator_, typename T1_, typename T2_
+      , typename T3_, typename T4_, typename Expr>
+    rule<Iterator_, T1_, T2_, T3_, T4_>& operator%=(
+        rule<Iterator_, T1_, T2_, T3_, T4_>& r, Expr& expr)
+    {
+        return r %= static_cast<Expr const&>(expr);
+    }
+#endif
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <
+        typename IteratorA, typename IteratorB, typename Attribute
+      , typename Context, typename T1, typename T2, typename T3, typename T4>
+    struct handles_container<
+        qi::rule<IteratorA, T1, T2, T3, T4>, Attribute, Context, IteratorB>
+      : traits::is_container<
+          typename attribute_of<
+              qi::rule<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+          >::type
+        >
+    {};
+}}}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/parse.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/parse.hpp
new file mode 100644
index 0000000..261df75
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/parse.hpp
@@ -0,0 +1,215 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_PARSE_APRIL_16_2006_0442PM)
+#define BOOST_SPIRIT_PARSE_APRIL_16_2006_0442PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/context.hpp>
+#include <boost/spirit/home/support/nonterminal/locals.hpp>
+#include <boost/spirit/home/qi/detail/parse.hpp>
+#include <boost/concept_check.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Expr>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr)
+    {
+        // Make sure the iterator is at least a forward_iterator. If you got a 
+        // compilation error here, then you are using an input_iterator while
+        // calling this function, you need to supply at least a 
+        // forward_iterator instead.
+        BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
+
+        return detail::parse_impl<Expr>::call(first, last, expr);
+    }
+
+    template <typename Iterator, typename Expr>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename T>
+        struct make_context
+        {
+            typedef context<fusion::cons<T&>, locals<> > type;
+        };
+
+        template <>
+        struct make_context<unused_type>
+        {
+            typedef unused_type type;
+        };
+    }
+
+    template <typename Iterator, typename Expr, typename Attr>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Attr& attr)
+    {
+        // Make sure the iterator is at least a forward_iterator. If you got a 
+        // compilation error here, then you are using an input_iterator while
+        // calling this function, you need to supply at least a 
+        // forward_iterator instead.
+        BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
+
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+
+        typename detail::make_context<Attr>::type context(attr);
+        return compile<qi::domain>(expr).parse(first, last, context, unused, attr);
+    }
+
+    template <typename Iterator, typename Expr, typename Attr>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Expr, typename Skipper>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip = skip_flag::postskip)
+    {
+        // Make sure the iterator is at least a forward_iterator. If you got a 
+        // compilation error here, then you are using an input_iterator while
+        // calling this function, you need to supply at least a 
+        // forward_iterator instead.
+        BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
+
+        return detail::phrase_parse_impl<Expr>::call(
+            first, last, expr, skipper, post_skip);
+    }
+
+    template <typename Iterator, typename Expr, typename Skipper>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip = skip_flag::postskip)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip
+      , Attr& attr)
+    {
+        // Make sure the iterator is at least a forward_iterator. If you got a 
+        // compilation error here, then you are using an input_iterator while
+        // calling this function, you need to supply at least a 
+        // forward_iterator instead.
+        BOOST_CONCEPT_ASSERT((ForwardIterator<Iterator>));
+
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then either the expression (expr) or skipper is not a valid
+        // spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr);
+        BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper);
+
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+
+        typename detail::make_context<Attr>::type context(attr);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, context, skipper_, attr))
+            return false;
+
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , BOOST_SCOPED_ENUM(skip_flag) post_skip
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip, attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , Attr& attr)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip, attr);
+    }
+
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip, attr);
+    }
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/parser.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/parser.hpp
new file mode 100644
index 0000000..ffd8bc9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/parser.hpp
@@ -0,0 +1,140 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_PARSER_OCTOBER_16_2008_0254PM)
+#define BOOST_SPIRIT_PARSER_OCTOBER_16_2008_0254PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+
+    //[parser_base_parser
+    template <typename Derived>
+    struct parser
+    {
+        struct parser_id;
+        typedef Derived derived_type;
+        typedef qi::domain domain;
+
+        // Requirement: p.parse(f, l, context, skip, attr) -> bool
+        //
+        //  p:          a parser
+        //  f, l:       first/last iterator pair
+        //  context:    enclosing rule context (can be unused_type)
+        //  skip:       skipper (can be unused_type)
+        //  attr:       attribute (can be unused_type)
+
+        // Requirement: p.what(context) -> info
+        //
+        //  p:          a parser
+        //  context:    enclosing rule context (can be unused_type)
+
+        // Requirement: P::template attribute<Ctx, Iter>::type
+        //
+        //  P:          a parser type
+        //  Ctx:        A context type (can be unused_type)
+        //  Iter:       An iterator type (can be unused_type)
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+    //]
+
+    template <typename Derived>
+    struct primitive_parser : parser<Derived>
+    {
+        struct primitive_parser_id;
+    };
+
+    template <typename Derived>
+    struct nary_parser : parser<Derived>
+    {
+        struct nary_parser_id;
+
+        // Requirement: p.elements -> fusion sequence
+        //
+        // p:   a composite parser
+
+        // Requirement: P::elements_type -> fusion sequence
+        //
+        // P:   a composite parser type
+    };
+
+    template <typename Derived>
+    struct unary_parser : parser<Derived>
+    {
+        struct unary_parser_id;
+
+        // Requirement: p.subject -> subject parser
+        //
+        // p:   a unary parser
+
+        // Requirement: P::subject_type -> subject parser type
+        //
+        // P:   a unary parser type
+    };
+
+    template <typename Derived>
+    struct binary_parser : parser<Derived>
+    {
+        struct binary_parser_id;
+
+        // Requirement: p.left -> left parser
+        //
+        // p:   a binary parser
+
+        // Requirement: P::left_type -> left parser type
+        //
+        // P:   a binary parser type
+
+        // Requirement: p.right -> right parser
+        //
+        // p:   a binary parser
+
+        // Requirement: P::right_type -> right parser type
+        //
+        // P:   a binary parser type
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits // classification
+{
+    namespace detail
+    {
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(parser_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(primitive_parser_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(nary_parser_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(unary_parser_id)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(binary_parser_id)
+    }
+
+    // parser type identification
+    template <typename T>
+    struct is_parser : detail::has_parser_id<T> {};
+
+    template <typename T>
+    struct is_primitive_parser : detail::has_primitive_parser_id<T> {};
+
+    template <typename T>
+    struct is_nary_parser : detail::has_nary_parser_id<T> {};
+
+    template <typename T>
+    struct is_unary_parser : detail::has_unary_parser_id<T> {};
+
+    template <typename T>
+    struct is_binary_parser : detail::has_binary_parser_id<T> {};
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp
new file mode 100644
index 0000000..f6fcabc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp
@@ -0,0 +1,69 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_REFERENCE_OCTOBER_31_2008_1218AM)
+#define BOOST_SPIRIT_REFERENCE_OCTOBER_31_2008_1218AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/qi/meta_compiler.hpp>
+#include <boost/spirit/home/qi/parser.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/home/support/handles_container.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/ref.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // reference is a parser that references another parser (its Subject)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject>
+    struct reference : parser<reference<Subject> >
+    {
+        typedef Subject subject_type;
+
+        reference(Subject& subject)
+          : ref(subject) {}
+
+        template <typename Context, typename Iterator>
+        struct attribute : Subject::template attribute<Context, Iterator> {};
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return ref.get().parse(first, last, context, skipper, attr);
+        }
+
+        template <typename Context>
+        info what(Context& context) const
+        {
+            // the reference is transparent (does not add any info)
+            return ref.get().what(context);
+        }
+
+        boost::reference_wrapper<Subject> ref;
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Subject, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::reference<Subject>, Attribute, Context
+      , Iterator>
+      : handles_container<typename remove_const<Subject>::type
+        , Attribute, Context, Iterator> 
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/skip_flag.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/skip_flag.hpp
new file mode 100644
index 0000000..28fd856
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/skip_flag.hpp
@@ -0,0 +1,29 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_SKIP_FLAG_DEC_02_2009_0412PM)
+#define BOOST_SPIRIT_SKIP_FLAG_DEC_02_2009_0412PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
+
+namespace boost { namespace spirit { namespace qi 
+{
+    ///////////////////////////////////////////////////////////////////////////
+    BOOST_SCOPED_ENUM_START(skip_flag) 
+    { 
+        postskip,           // force post-skipping in phrase_parse()
+        dont_postskip       // inhibit post-skipping in phrase_parse()
+    };
+    BOOST_SCOPED_ENUM_END
+
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/skip_over.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/skip_over.hpp
new file mode 100644
index 0000000..f46b304
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/qi/skip_over.hpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_SKIP_APRIL_16_2006_0625PM)
+#define BOOST_SPIRIT_SKIP_APRIL_16_2006_0625PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/qi/detail/unused_skipper.hpp>
+
+namespace boost { namespace spirit { namespace qi
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Move the /first/ iterator to the first non-matching position
+    // given a skip-parser. The function is a no-op if unused_type is
+    // passed as the skip-parser.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename T>
+    inline void skip_over(Iterator& first, Iterator const& last, T const& skipper)
+    {
+        while (first != last && skipper.parse(first, last, unused, unused, unused))
+            /***/;
+    }
+
+    template <typename Iterator>
+    inline void skip_over(Iterator&, Iterator const&, unused_type)
+    {
+    }
+
+    template <typename Iterator, typename Skipper>
+    inline void skip_over(Iterator&, Iterator const&
+      , detail::unused_skipper<Skipper> const&)
+    {
+    }
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/argument.hpp b/3rdParty/Boost/src/boost/spirit/home/support/argument.hpp
new file mode 100644
index 0000000..caeee0b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/argument.hpp
@@ -0,0 +1,217 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c)      2011 Thomas Heller
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_ARGUMENT_FEBRUARY_17_2007_0339PM)
+#define BOOST_SPIRIT_ARGUMENT_FEBRUARY_17_2007_0339PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/home/support/assert_msg.hpp>
+#include <boost/spirit/home/support/limits.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/at.hpp>
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define SPIRIT_DECLARE_ARG(z, n, data)                                        \
+    typedef phoenix::actor<argument<n> >                                      \
+        BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type);                \
+    phoenix::actor<argument<n> > const                                        \
+        BOOST_PP_CAT(_, BOOST_PP_INC(n)) =                                    \
+            BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type)();          \
+        /***/
+
+#define SPIRIT_USING_ARGUMENT(z, n, data)                                     \
+    using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type);                    \
+    using spirit::BOOST_PP_CAT(_, n);                                         \
+        /***/
+
+#else
+
+#define SPIRIT_DECLARE_ARG(z, n, data)                                        \
+    typedef phoenix::actor<argument<n> >                                      \
+        BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type);                \
+        /***/
+
+#define SPIRIT_USING_ARGUMENT(z, n, data)                                     \
+    using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type);                    \
+        /***/
+
+#endif
+
+namespace boost { namespace spirit
+{
+    template <int N>
+    struct argument;
+
+    template <typename Dummy>
+    struct attribute_context;
+}}
+
+BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
+    template <int N>
+  , boost::spirit::argument<N>
+  , mpl::false_                 // is not nullary
+  , v2_eval(
+        proto::make<
+            boost::spirit::argument<N>()
+        >
+      , proto::call<
+            functional::env(proto::_state)
+        >
+    )
+)
+
+BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
+    template <typename Dummy>
+  , boost::spirit::attribute_context<Dummy>
+  , mpl::false_                 // is not nullary
+  , v2_eval(
+        proto::make<
+            boost::spirit::attribute_context<Dummy>()
+        >
+      , proto::call<
+            functional::env(proto::_state)
+        >
+    )
+)
+
+namespace boost { namespace spirit
+{
+    namespace result_of
+    {
+        template <typename Sequence, int N>
+        struct get_arg
+        {
+            typedef typename
+                fusion::result_of::size<Sequence>::type
+            sequence_size;
+
+            // report invalid argument not found (N is out of bounds)
+            BOOST_SPIRIT_ASSERT_MSG(
+                (N < sequence_size::value),
+                index_is_out_of_bounds, ());
+
+            typedef typename
+                fusion::result_of::at_c<Sequence, N>::type
+            type;
+
+            static type call(Sequence& seq)
+            {
+                return fusion::at_c<N>(seq);
+            }
+        };
+
+        template <typename Sequence, int N>
+        struct get_arg<Sequence&, N> : get_arg<Sequence, N>
+        {
+        };
+    }
+
+    template <int N, typename T>
+    typename result_of::get_arg<T, N>::type
+    get_arg(T& val)
+    {
+        return result_of::get_arg<T, N>::call(val);
+    }
+
+    template <typename>
+    struct attribute_context
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            // FIXME: is this remove_const really necessary?
+            typedef typename
+                remove_const<
+                    typename mpl::at_c<typename Env::args_type, 0>::type
+                >::type
+            type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return fusion::at_c<0>(env.args());
+        }
+    };
+
+    template <int N>
+    struct argument
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                mpl::at_c<typename Env::args_type, 0>::type
+            arg_type;
+
+            typedef typename result_of::get_arg<arg_type, N>::type type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return get_arg<N>(fusion::at_c<0>(env.args()));
+        }
+    };
+
+    // _0 refers to the whole attribute as generated by the lhs parser
+    typedef phoenix::actor<attribute_context<void> > _0_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    _0_type const _0 = _0_type();
+#endif
+
+    // _1, _2, ... refer to the attributes of the single components the lhs
+    // parser is composed of
+    typedef phoenix::actor<argument<0> > _1_type;
+    typedef phoenix::actor<argument<1> > _2_type;
+    typedef phoenix::actor<argument<2> > _3_type;
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    _1_type const _1 = _1_type();
+    _2_type const _2 = _2_type();
+    _3_type const _3 = _3_type();
+#endif
+
+    // '_pass' may be used to make a match fail in retrospective
+    typedef phoenix::arg_names::_3_type _pass_type;
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    _pass_type const _pass = _pass_type();
+#endif
+
+    //  Bring in the rest of the arguments and attributes (_4 .. _N+1), using PP
+    BOOST_PP_REPEAT_FROM_TO(
+        3, SPIRIT_ARGUMENTS_LIMIT, SPIRIT_DECLARE_ARG, _)
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    // You can bring these in with the using directive
+    // without worrying about bringing in too much.
+    namespace labels
+    {
+        BOOST_PP_REPEAT(SPIRIT_ARGUMENTS_LIMIT, SPIRIT_USING_ARGUMENT, _)
+    }
+#endif
+
+}}
+
+#undef SPIRIT_DECLARE_ARG
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp b/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp
new file mode 100644
index 0000000..db36072
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp
@@ -0,0 +1,31 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ASSERT_MSG_JUN_23_2009_0836AM)
+#define BOOST_SPIRIT_ASSERT_MSG_JUN_23_2009_0836AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+// Allow to work around the MPL problem in BOOST_MPL_ASSERT_MSG generating
+// multiple definition linker errors for certain compilers (VC++)
+#if BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG != 0
+#include <boost/static_assert.hpp>
+#define BOOST_SPIRIT_ASSERT_MSG(Cond, Msg, Types)                             \
+        BOOST_STATIC_ASSERT(Cond)
+#else
+#include <boost/mpl/assert.hpp>
+#define BOOST_SPIRIT_ASSERT_MSG(Cond, Msg, Types)                             \
+        BOOST_MPL_ASSERT_MSG(Cond, Msg, Types)
+#endif
+
+#define BOOST_SPIRIT_ASSERT_MATCH(Domain, Expr)                               \
+        BOOST_SPIRIT_ASSERT_MSG((                                             \
+            boost::spirit::traits::matches<Domain, Expr>::value               \
+        ), error_invalid_expression, (Expr))
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp b/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp
new file mode 100644
index 0000000..48bff06
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp
@@ -0,0 +1,1358 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_ATTRIBUTES_JANUARY_29_2007_0954AM)
+#define BOOST_SPIRIT_ATTRIBUTES_JANUARY_29_2007_0954AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/has_semantic_action.hpp>
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+#include <boost/spirit/home/support/container.hpp>
+#include <boost/spirit/home/support/detail/hold_any.hpp>
+#include <boost/spirit/home/support/detail/as_variant.hpp>
+#include <boost/optional/optional.hpp>
+#include <boost/fusion/include/transform.hpp>
+#include <boost/fusion/include/filter_if.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/fusion/include/push_front.hpp>
+#include <boost/fusion/include/pop_front.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+#include <boost/fusion/include/for_each.hpp>
+#include <boost/fusion/include/is_view.hpp>
+#include <boost/fusion/include/mpl.hpp>
+#include <boost/foreach.hpp>
+#include <boost/utility/value_init.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/distance.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/variant.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/config.hpp>
+#include <vector>
+#include <utility>
+#include <ios>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // This file deals with attribute related functions and meta-functions
+    // including generalized attribute transformation utilities for Spirit
+    // components.
+    ///////////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Find out if T can be a (strong) substitute for Expected attribute
+    namespace detail
+    {
+        template <typename T, typename Expected>
+        struct value_type_is_substitute
+          : is_substitute<
+                typename container_value<T>::type
+              , typename container_value<Expected>::type>
+        {};
+
+        template <typename T, typename Expected, typename Enable = void>
+        struct is_substitute_impl : is_same<T, Expected> {};
+
+        template <typename T, typename Expected>
+        struct is_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<T>,
+                    fusion::traits::is_sequence<Expected>,
+                    mpl::equal<T, Expected, is_substitute<mpl::_1, mpl::_2> >
+                >
+            >::type>
+          : mpl::true_ {};
+
+        template <typename T, typename Expected>
+        struct is_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    is_container<T>,
+                    is_container<Expected>,
+                    detail::value_type_is_substitute<T, Expected>
+                >
+            >::type>
+          : mpl::true_ {};
+    }
+
+    template <typename T, typename Expected, typename Enable /*= void*/>
+    struct is_substitute
+      : detail::is_substitute_impl<T, Expected> {};
+
+    template <typename T, typename Expected>
+    struct is_substitute<optional<T>, optional<Expected> >
+      : is_substitute<T, Expected> {};
+
+    template <typename T>
+    struct is_substitute<T, T
+          , typename enable_if<not_is_optional<T> >::type>
+      : mpl::true_ {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Find out if T can be a weak substitute for Expected attribute
+    namespace detail
+    {
+        // A type, which is convertible to the attribute is at the same time
+        // usable as its weak substitute.
+        template <typename T, typename Expected, typename Enable = void>
+        struct is_weak_substitute_impl : is_convertible<T, Expected> {};
+
+//        // An exposed attribute is a weak substitute for a supplied container
+//        // attribute if it is a weak substitute for its value_type. This is
+//        // true as all character parsers are compatible with a container
+//        // attribute having the corresponding character type as its value_type.
+//        template <typename T, typename Expected>
+//        struct is_weak_substitute_for_value_type
+//          : is_weak_substitute<T, typename container_value<Expected>::type>
+//        {};
+//
+//        template <typename T, typename Expected>
+//        struct is_weak_substitute_impl<T, Expected,
+//            typename enable_if<
+//                mpl::and_<
+//                    mpl::not_<is_string<T> >
+//                  , is_string<Expected>
+//                  , is_weak_substitute_for_value_type<T, Expected> >
+//            >::type>
+//          : mpl::true_
+//        {};
+
+        // An exposed container attribute is a weak substitute for a supplied
+        // container attribute if and only if their value_types are weak
+        // substitutes.
+        template <typename T, typename Expected>
+        struct value_type_is_weak_substitute
+          : is_weak_substitute<
+                typename container_value<T>::type
+              , typename container_value<Expected>::type>
+        {};
+
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    is_container<T>
+                  , is_container<Expected>
+                  , value_type_is_weak_substitute<T, Expected> >
+            >::type>
+          : mpl::true_ {};
+
+        // Two fusion sequences are weak substitutes if and only if their
+        // elements are pairwise weak substitutes.
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<T>
+                  , fusion::traits::is_sequence<Expected>
+                  , mpl::equal<T, Expected, is_weak_substitute<mpl::_1, mpl::_2> > >
+            >::type>
+          : mpl::true_ {};
+
+        // If this is not defined, the main template definition above will return
+        // true if T is convertible to the first type in a fusion::vector. We
+        // globally declare any non-Fusion sequence T as not compatible with any
+        // Fusion sequence 'Expected'.
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    mpl::not_<fusion::traits::is_sequence<T> >
+                  , fusion::traits::is_sequence<Expected> >
+            >::type>
+          : mpl::false_ {};
+    }
+
+    // main template forwards to detail namespace, this helps older compilers
+    // to disambiguate things
+    template <typename T, typename Expected, typename Enable /*= void*/>
+    struct is_weak_substitute
+      : detail::is_weak_substitute_impl<T, Expected> {};
+
+    template <typename T, typename Expected>
+    struct is_weak_substitute<optional<T>, optional<Expected> >
+      : is_weak_substitute<T, Expected> {};
+
+    template <typename T, typename Expected>
+    struct is_weak_substitute<optional<T>, Expected>
+      : is_weak_substitute<T, Expected> {};
+
+    template <typename T, typename Expected>
+    struct is_weak_substitute<T, optional<Expected> >
+      : is_weak_substitute<T, Expected> {};
+
+#define BOOST_SPIRIT_IS_WEAK_SUBSTITUTE(z, N, _)                              \
+    is_weak_substitute<BOOST_PP_CAT(T, N), Expected>::type::value &&          \
+    /***/
+
+    // make sure unused variant parameters do not affect the outcome
+    template <typename Expected>
+    struct is_weak_substitute<boost::detail::variant::void_, Expected>
+      : mpl::true_
+    {};
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Expected>
+    struct is_weak_substitute<
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Expected>
+      : mpl::bool_<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES
+          , BOOST_SPIRIT_IS_WEAK_SUBSTITUTE, _) true>
+    {};
+
+#undef BOOST_SPIRIT_IS_WEAK_SUBSTITUTE
+
+    template <typename T>
+    struct is_weak_substitute<T, T
+          , typename enable_if<
+                mpl::and_<not_is_optional<T>, not_is_variant<T> >
+            >::type>
+      : mpl::true_ {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable/* = void*/>
+    struct is_proxy : mpl::false_ {};
+
+    template <typename T>
+    struct is_proxy<T,
+        typename enable_if<
+            mpl::and_<
+                fusion::traits::is_sequence<T>,
+                fusion::traits::is_view<T>
+            >
+        >::type>
+      : mpl::true_ {};
+
+    namespace detail
+    {
+        // By declaring a nested struct in your class/struct, you tell
+        // spirit that it is regarded as a variant type. The minimum
+        // required interface for such a variant is that it has constructors
+        // for various types supported by your variant and a typedef 'types'
+        // which is an mpl sequence of the contained types.
+        //
+        // This is an intrusive interface. For a non-intrusive interface,
+        // use the not_is_variant trait.
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(adapted_variant_tag)
+    }
+
+    template <typename T, typename Domain, typename Enable/* = void*/>
+    struct not_is_variant
+      : mpl::not_<detail::has_adapted_variant_tag<T> >
+    {};
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Domain>
+    struct not_is_variant<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Domain>
+      : mpl::false_
+    {};
+
+    template <typename T, typename Domain>
+    struct not_is_variant<boost::optional<T>, Domain>
+      : not_is_variant<T, Domain>
+    {};
+
+    // we treat every type as if it where the variant (as this meta function is
+    // invoked for variant types only)
+    template <typename T>
+    struct variant_type
+      : mpl::identity<T>
+    {};
+
+    template <typename T>
+    struct variant_type<boost::optional<T> >
+      : variant_type<T>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The compute_compatible_component_variant
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        //  A component is compatible to a given Attribute type if the
+        //  Attribute is the same as the expected type of the component or if
+        //  it is convertible to the expected type.
+        template <typename Expected, typename Attribute>
+        struct attribute_is_compatible
+          : is_convertible<Attribute, Expected>
+        {};
+
+        template <typename Expected, typename Attribute>
+        struct attribute_is_compatible<Expected, boost::optional<Attribute> >
+          : is_convertible<Attribute, Expected>
+        {};
+
+        template <typename Container>
+        struct is_hold_any_container
+          : traits::is_hold_any<typename traits::container_value<Container>::type>
+        {};
+    }
+
+    template <typename Attribute, typename Expected
+      , typename IsNotVariant = mpl::false_, typename Enable = void>
+    struct compute_compatible_component_variant
+      : mpl::or_<
+            traits::detail::attribute_is_compatible<Expected, Attribute>
+          , traits::is_hold_any<Expected>
+          , mpl::eval_if<
+                is_container<Expected>
+              , traits::detail::is_hold_any_container<Expected>
+              , mpl::false_> >
+    {};
+
+    namespace detail
+    {
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(types)
+    }
+
+    template <typename Variant, typename Expected>
+    struct compute_compatible_component_variant<Variant, Expected, mpl::false_
+      , typename enable_if<detail::has_types<Variant> >::type>
+    {
+        typedef typename traits::variant_type<Variant>::type variant_type;
+        typedef typename variant_type::types types;
+        typedef typename mpl::end<types>::type end;
+
+        typedef typename
+            mpl::find_if<types, is_same<Expected, mpl::_1> >::type
+        iter;
+
+        typedef typename mpl::distance<
+            typename mpl::begin<types>::type, iter
+        >::type distance;
+
+        // true_ if the attribute matches one of the types in the variant
+        typedef typename mpl::not_<is_same<iter, end> >::type type;
+        enum { value = type::value };
+
+        // return the type in the variant the attribute is compatible with
+        typedef typename
+            mpl::eval_if<type, mpl::deref<iter>, mpl::identity<unused_type> >::type
+        compatible_type;
+
+        // return whether the given type is compatible with the Expected type
+        static bool is_compatible(int which)
+        {
+            return which == distance::value;
+        }
+    };
+
+    template <typename Expected, typename Attribute, typename Domain>
+    struct compute_compatible_component
+      : compute_compatible_component_variant<Attribute, Expected
+          , typename spirit::traits::not_is_variant<Attribute, Domain>::type> {};
+
+    template <typename Expected, typename Domain>
+    struct compute_compatible_component<Expected, unused_type, Domain>
+      : mpl::false_ {};
+
+    template <typename Attribute, typename Domain>
+    struct compute_compatible_component<unused_type, Attribute, Domain>
+      : mpl::false_ {};
+
+    template <typename Domain>
+    struct compute_compatible_component<unused_type, unused_type, Domain>
+      : mpl::false_ {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // return the type currently stored in the given variant
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct variant_which<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    {
+        static int call(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& v)
+        {
+            return v.which();
+        }
+    };
+
+    template <typename T>
+    int which(T const& v)
+    {
+        return variant_which<T>::call(v);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Domain, typename Enable/* = void*/>
+    struct not_is_optional
+      : mpl::true_
+    {};
+
+    template <typename T, typename Domain>
+    struct not_is_optional<boost::optional<T>, Domain>
+      : mpl::false_
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // attribute_of
+    //
+    // Get the component's attribute
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Component
+      , typename Context = unused_type, typename Iterator = unused_type>
+    struct attribute_of
+    {
+        typedef typename Component::template
+            attribute<Context, Iterator>::type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // attribute_not_unused
+    //
+    // An mpl meta-function class that determines whether a component's
+    // attribute is not unused.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Context, typename Iterator = unused_type>
+    struct attribute_not_unused
+    {
+        template <typename Component>
+        struct apply
+          : not_is_unused<typename
+                attribute_of<Component, Context, Iterator>::type>
+        {};
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the attribute type to use from the given type
+    //
+    // This is needed to extract the correct attribute type from proxy classes
+    // as utilized in FUSION_ADAPT_ADT et. al.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Enable/* = void*/>
+    struct attribute_type : mpl::identity<Attribute> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the size of a fusion sequence (compile time)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct sequence_size
+      : fusion::result_of::size<T>
+    {};
+
+    template <>
+    struct sequence_size<unused_type>
+      : mpl::int_<0>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the size of an attribute (runtime)
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename Attribute, typename Enable = void>
+        struct attribute_size_impl
+        {
+            typedef std::size_t type;
+
+            static type call(Attribute const&)
+            {
+                return 1;
+            }
+        };
+
+        template <typename Attribute>
+        struct attribute_size_impl<Attribute
+          , typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<Attribute>
+                  , mpl::not_<traits::is_container<Attribute> >
+                >
+            >::type>
+        {
+            typedef typename fusion::result_of::size<Attribute>::value_type type;
+
+            static type call(Attribute const& attr)
+            {
+                return fusion::size(attr);
+            }
+        };
+
+        template <typename Attribute>
+        struct attribute_size_impl<Attribute
+          , typename enable_if<
+                mpl::and_<
+                    traits::is_container<Attribute>
+                  , mpl::not_<traits::is_iterator_range<Attribute> >
+                >
+            >::type>
+        {
+            typedef typename Attribute::size_type type;
+
+            static type call(Attribute const& attr)
+            {
+                return attr.size();
+            }
+        };
+    }
+
+    template <typename Attribute, typename Enable/* = void*/>
+    struct attribute_size
+      : detail::attribute_size_impl<Attribute>
+    {};
+
+    template <typename Attribute>
+    struct attribute_size<optional<Attribute> >
+    {
+        typedef typename attribute_size<Attribute>::type type;
+
+        static type call(optional<Attribute> const& val)
+        {
+            if (!val)
+                return 0;
+            return val.get();
+        }
+    };
+
+    template <typename Iterator>
+    struct attribute_size<iterator_range<Iterator> >
+    {
+        typedef typename boost::detail::iterator_traits<Iterator>::
+            difference_type type;
+
+        static type call(iterator_range<Iterator> const& r)
+        {
+            return boost::detail::distance(r.begin(), r.end());
+        }
+    };
+
+    template <>
+    struct attribute_size<unused_type>
+    {
+        typedef std::size_t type;
+
+        static type call(unused_type)
+        {
+            return 0;
+        }
+    };
+
+    template <typename Attribute>
+    typename attribute_size<Attribute>::type
+    size (Attribute const& attr)
+    {
+        return attribute_size<Attribute>::call(attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // pass_attribute
+    //
+    // Determines how we pass attributes to semantic actions. This
+    // may be specialized. By default, all attributes are wrapped in
+    // a fusion sequence, because the attribute has to be treated as being
+    // a single value in any case (even if it actually already is a fusion
+    // sequence in its own).
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Component, typename Attribute, typename Enable/* = void*/>
+    struct pass_attribute
+    {
+        typedef fusion::vector1<Attribute&> type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Subclass a pass_attribute specialization from this to wrap
+    // the attribute in a tuple only IFF it is not already a fusion tuple.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Force = mpl::false_>
+    struct wrap_if_not_tuple
+      : mpl::if_<
+            fusion::traits::is_sequence<Attribute>
+          , Attribute&, fusion::vector1<Attribute&> >
+    {};
+
+    template <typename Attribute>
+    struct wrap_if_not_tuple<Attribute, mpl::true_>
+    {
+        typedef fusion::vector1<Attribute&> type;
+    };
+
+    template <>
+    struct wrap_if_not_tuple<unused_type, mpl::false_>
+    {
+        typedef unused_type type;
+    };
+
+    template <>
+    struct wrap_if_not_tuple<unused_type const, mpl::false_>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // build_optional
+    //
+    // Build a boost::optional from T. Return unused_type if T is unused_type.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct build_optional
+    {
+        typedef boost::optional<T> type;
+    };
+
+    template <typename T>
+    struct build_optional<boost::optional<T> >
+    {
+        typedef boost::optional<T> type;
+    };
+
+    template <>
+    struct build_optional<unused_type>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // build_std_vector
+    //
+    // Build a std::vector from T. Return unused_type if T is unused_type.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct build_std_vector
+    {
+        typedef std::vector<T> type;
+    };
+
+    template <>
+    struct build_std_vector<unused_type>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // filter_unused_attributes
+    //
+    // Remove unused_types from a sequence
+    ///////////////////////////////////////////////////////////////////////////
+
+    // Compute the list of all *used* attributes of sub-components
+    // (filter all unused attributes from the list)
+    template <typename Sequence>
+    struct filter_unused_attributes
+      : fusion::result_of::filter_if<Sequence, not_is_unused<mpl::_> >
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // sequence_attribute_transform
+    //
+    // This transform is invoked for every attribute in a sequence allowing
+    // to modify the attribute type exposed by a component to the enclosing
+    // sequence component. By default no transformation is performed.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Domain>
+    struct sequence_attribute_transform
+      : mpl::identity<Attribute>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // permutation_attribute_transform
+    //
+    // This transform is invoked for every attribute in a sequence allowing
+    // to modify the attribute type exposed by a component to the enclosing
+    // permutation component. By default a build_optional transformation is
+    // performed.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Domain>
+    struct permutation_attribute_transform
+      : traits::build_optional<Attribute>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // sequential_or_attribute_transform
+    //
+    // This transform is invoked for every attribute in a sequential_or allowing
+    // to modify the attribute type exposed by a component to the enclosing
+    // sequential_or component. By default a build_optional transformation is
+    // performed.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Domain>
+    struct sequential_or_attribute_transform
+      : traits::build_optional<Attribute>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // build_fusion_vector
+    //
+    // Build a fusion vector from a fusion sequence. All unused attributes
+    // are filtered out. If the result is empty after the removal of unused
+    // types, return unused_type. If the input sequence is an unused_type,
+    // also return unused_type.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Sequence>
+    struct build_fusion_vector
+    {
+        // Remove all unused attributes
+        typedef typename
+            filter_unused_attributes<Sequence>::type
+        filtered_attributes;
+
+        // Build a fusion vector from a fusion sequence (Sequence),
+        // But *only if* the sequence is not empty. i.e. if the
+        // sequence is empty, our result will be unused_type.
+
+        typedef typename
+            mpl::eval_if<
+                fusion::result_of::empty<filtered_attributes>
+              , mpl::identity<unused_type>
+              , fusion::result_of::as_vector<filtered_attributes>
+            >::type
+        type;
+    };
+
+    template <>
+    struct build_fusion_vector<unused_type>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // build_attribute_sequence
+    //
+    // Build a fusion sequence attribute sequence from a sequence of
+    // components. Transform<T>::type is called on each element.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Sequence, typename Context
+      , template <typename T, typename D> class Transform
+      , typename Iterator = unused_type, typename Domain = unused_type>
+    struct build_attribute_sequence
+    {
+        struct element_attribute
+        {
+            template <typename T>
+            struct result;
+
+            template <typename F, typename Element>
+            struct result<F(Element)>
+            {
+                typedef typename
+                    Transform<
+                        typename attribute_of<Element, Context, Iterator>::type
+                      , Domain
+                    >::type
+                type;
+            };
+
+            // never called, but needed for decltype-based result_of (C++0x)
+#ifndef BOOST_NO_RVALUE_REFERENCES
+            template <typename Element>
+            typename result<element_attribute(Element)>::type
+            operator()(Element&&) const;
+#endif
+        };
+
+        // Compute the list of attributes of all sub-components
+        typedef typename
+            fusion::result_of::transform<Sequence, element_attribute>::type
+        type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // has_no_unused
+    //
+    // Test if there are no unused attributes in Sequence
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Sequence>
+    struct has_no_unused
+      : is_same<
+            typename mpl::find_if<Sequence, is_same<mpl::_, unused_type> >::type
+          , typename mpl::end<Sequence>::type>
+    {};
+
+    namespace detail
+    {
+        template <typename Sequence, bool no_unused
+            , int size = mpl::size<Sequence>::value>
+        struct build_collapsed_variant;
+
+        // N element case, no unused
+        template <typename Sequence, int size>
+        struct build_collapsed_variant<Sequence, true, size>
+            : spirit::detail::as_variant<Sequence> {};
+
+        // N element case with unused
+        template <typename Sequence, int size>
+        struct build_collapsed_variant<Sequence, false, size>
+        {
+            typedef boost::optional<
+                typename spirit::detail::as_variant<
+                    typename fusion::result_of::pop_front<Sequence>::type
+                >::type
+            > type;
+        };
+
+        // 1 element case, no unused
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, true, 1>
+            : mpl::front<Sequence> {};
+
+        // 1 element case, with unused
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, false, 1>
+            : mpl::front<Sequence> {};
+
+        // 2 element case, no unused
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, true, 2>
+            : spirit::detail::as_variant<Sequence> {};
+
+        // 2 element case, with unused
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, false, 2>
+        {
+            typedef boost::optional<
+                typename mpl::deref<
+                    typename mpl::next<
+                        typename mpl::begin<Sequence>::type
+                    >::type
+                >::type
+            >
+            type;
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // alternative_attribute_transform
+    //
+    // This transform is invoked for every attribute in an alternative allowing
+    // to modify the attribute type exposed by a component to the enclosing
+    // alternative component. By default no transformation is performed.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Domain>
+    struct alternative_attribute_transform
+      : mpl::identity<Attribute>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // build_variant
+    //
+    // Build a boost::variant from a fusion sequence. build_variant makes sure
+    // that 1) all attributes in the variant are unique 2) puts the unused
+    // attribute, if there is any, to the front and 3) collapses single element
+    // variants, variant<T> to T.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Sequence>
+    struct build_variant
+    {
+        // Remove all unused attributes.
+        typedef typename
+            filter_unused_attributes<Sequence>::type
+        filtered_attributes;
+
+        typedef has_no_unused<Sequence> no_unused;
+
+        // If the original attribute list does not contain any unused
+        // attributes, it is used, otherwise a single unused_type is
+        // pushed to the front of the list. This is to make sure that if
+        // there is an unused_type in the list, it is the first one.
+        typedef typename
+            mpl::eval_if<
+                no_unused,
+                mpl::identity<Sequence>,
+                fusion::result_of::push_front<filtered_attributes, unused_type>
+            >::type
+        attribute_sequence;
+
+        // Make sure each of the types occur only once in the type list
+        typedef typename
+            mpl::fold<
+                attribute_sequence, mpl::vector<>,
+                mpl::if_<
+                    mpl::contains<mpl::_1, mpl::_2>,
+                    mpl::_1, mpl::push_back<mpl::_1, mpl::_2>
+                >
+            >::type
+        no_duplicates;
+
+        // If there is only one type in the list of types we strip off the
+        // variant. IOTW, collapse single element variants, variant<T> to T.
+        // Take note that this also collapses variant<unused_type, T> to T.
+        typedef typename
+            traits::detail::build_collapsed_variant<
+                no_duplicates, no_unused::value>::type
+        type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  transform_attribute
+    //
+    //  Sometimes the user needs to transform the attribute types for certain
+    //  attributes. This template can be used as a customization point, where
+    //  the user is able specify specific transformation rules for any attribute
+    //  type.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Exposed, typename Transformed, typename Domain
+      , typename Enable/* = void*/>
+    struct transform_attribute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Domain, typename Transformed, typename Exposed>
+    typename spirit::result_of::pre_transform<Exposed, Transformed, Domain>::type
+    pre_transform(Exposed& attr BOOST_PROTO_DISABLE_IF_IS_CONST(Exposed))
+    {
+        return transform_attribute<Exposed, Transformed, Domain>::pre(attr);
+    }
+
+    template <typename Domain, typename Transformed, typename Exposed>
+    typename spirit::result_of::pre_transform<Exposed const, Transformed, Domain>::type
+    pre_transform(Exposed const& attr)
+    {
+        return transform_attribute<Exposed const, Transformed, Domain>::pre(attr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // make_attribute
+    //
+    // All parsers and generators have specific attribute types.
+    // Spirit parsers and generators are passed an attribute; these are either
+    // references to the expected type, or an unused_type -- to flag that we do
+    // not care about the attribute. For semantic actions, however, we need to
+    // have a real value to pass to the semantic action. If the client did not
+    // provide one, we will have to synthesize the value. This class takes care
+    // of that. *Note that this behavior has changed. From Boost 1.47, semantic
+    // actions always take in the passed attribute as-is if the PP constant:
+    // BOOST_SPIRIT_ACTIONS_ALLOW_ATTR_COMPAT is defined.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute
+    {
+        typedef typename remove_const<Attribute>::type attribute_type;
+        typedef typename
+            mpl::if_<
+                is_same<typename remove_const<ActualAttribute>::type, unused_type>
+              , attribute_type
+              , ActualAttribute&>::type
+        type;
+
+        typedef typename
+            mpl::if_<
+                is_same<typename remove_const<ActualAttribute>::type, unused_type>
+              , attribute_type
+              , ActualAttribute>::type
+        value_type;
+
+        static Attribute call(unused_type)
+        {
+             // synthesize the attribute/parameter
+            return boost::get(value_initialized<attribute_type>());
+        }
+
+        template <typename T>
+        static T& call(T& value)
+        {
+            return value; // just pass the one provided
+        }
+    };
+
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute<Attribute&, ActualAttribute>
+      : make_attribute<Attribute, ActualAttribute>
+    {};
+
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute<Attribute const&, ActualAttribute>
+      : make_attribute<Attribute const, ActualAttribute>
+    {};
+
+    template <typename ActualAttribute>
+    struct make_attribute<unused_type, ActualAttribute>
+    {
+        typedef unused_type type;
+        typedef unused_type value_type;
+        static unused_type call(unused_type)
+        {
+            return unused;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // swap_impl
+    //
+    // Swap (with proper handling of unused_types)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename A, typename B>
+    void swap_impl(A& a, B& b)
+    {
+        A temp = a;
+        a = b;
+        b = temp;
+    }
+
+    template <typename T>
+    void swap_impl(T& a, T& b)
+    {
+        using namespace std;
+        swap(a, b);
+    }
+
+    template <typename A>
+    void swap_impl(A&, unused_type)
+    {
+    }
+
+    template <typename A>
+    void swap_impl(unused_type, A&)
+    {
+    }
+
+    inline void swap_impl(unused_type, unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Strips single element fusion vectors into its 'naked'
+    //  form: vector<T> --> T
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct strip_single_element_vector
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct strip_single_element_vector<fusion::vector1<T> >
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct strip_single_element_vector<fusion::vector<T> >
+    {
+        typedef T type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // meta function to return whether the argument is a one element fusion
+    // sequence
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T
+      , bool IsFusionSeq = fusion::traits::is_sequence<T>::value
+      , bool IsProtoExpr = proto::is_expr<T>::value>
+    struct one_element_sequence
+      : mpl::false_
+    {};
+
+    template <typename T>
+    struct one_element_sequence<T, true, false>
+      : mpl::bool_<mpl::size<T>::value == 1>
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // clear
+    //
+    // Clear data efficiently
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    void clear(T& val);
+
+    namespace detail
+    {
+        // this is used by the variant and fusion sequence dispatch
+        struct clear_visitor : static_visitor<>
+        {
+            template <typename T>
+            void operator()(T& val) const
+            {
+                spirit::traits::clear(val);
+            }
+        };
+
+        // default
+        template <typename T>
+        void clear_impl2(T& val, mpl::false_)
+        {
+            val = T();
+        }
+
+        // for fusion sequences
+        template <typename T>
+        void clear_impl2(T& val, mpl::true_)
+        {
+            fusion::for_each(val, clear_visitor());
+        }
+
+        // dispatch default or fusion sequence
+        template <typename T>
+        void clear_impl(T& val, mpl::false_)
+        {
+            clear_impl2(val, fusion::traits::is_sequence<T>());
+        }
+
+        // STL containers
+        template <typename T>
+        void clear_impl(T& val, mpl::true_)
+        {
+            val.clear();
+        }
+    }
+
+    template <typename T, typename Enable/* = void*/>
+    struct clear_value
+    {
+        static void call(T& val)
+        {
+            detail::clear_impl(val, typename is_container<T>::type());
+        }
+    };
+
+    // optionals
+    template <typename T>
+    struct clear_value<boost::optional<T> >
+    {
+        static void call(boost::optional<T>& val)
+        {
+            if (val)
+                val = none_t();   // leave optional uninitialized
+        }
+    };
+
+    // variants
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct clear_value<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    {
+        static void call(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& val)
+        {
+            apply_visitor(detail::clear_visitor(), val);
+        }
+    };
+
+    // iterator range
+    template <typename T>
+    struct clear_value<iterator_range<T> >
+    {
+        static void call(iterator_range<T>& val)
+        {
+            val = iterator_range<T>(val.end(), val.end());
+        }
+    };
+
+    // main dispatch
+    template <typename T>
+    void clear(T& val)
+    {
+        clear_value<T>::call(val);
+    }
+
+    // for unused
+    inline void clear(unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename Out>
+        struct print_fusion_sequence
+        {
+            print_fusion_sequence(Out& out)
+              : out(out), is_first(true) {}
+
+            typedef void result_type;
+
+            template <typename T>
+            void operator()(T const& val) const
+            {
+                if (is_first)
+                    is_first = false;
+                else
+                    out << ", ";
+                spirit::traits::print_attribute(out, val);
+            }
+
+            Out& out;
+            mutable bool is_first;
+        };
+
+        // print elements in a variant
+        template <typename Out>
+        struct print_visitor : static_visitor<>
+        {
+            print_visitor(Out& out) : out(out) {}
+
+            template <typename T>
+            void operator()(T const& val) const
+            {
+                spirit::traits::print_attribute(out, val);
+            }
+
+            Out& out;
+        };
+    }
+
+    template <typename Out, typename T, typename Enable>
+    struct print_attribute_debug
+    {
+        // for plain data types
+        template <typename T_>
+        static void call_impl3(Out& out, T_ const& val, mpl::false_)
+        {
+            out << val;
+        }
+
+        // for fusion data types
+        template <typename T_>
+        static void call_impl3(Out& out, T_ const& val, mpl::true_)
+        {
+            out << '[';
+            fusion::for_each(val, detail::print_fusion_sequence<Out>(out));
+            out << ']';
+        }
+
+        // non-stl container
+        template <typename T_>
+        static void call_impl2(Out& out, T_ const& val, mpl::false_)
+        {
+            call_impl3(out, val, fusion::traits::is_sequence<T_>());
+        }
+
+        // stl container
+        template <typename T_>
+        static void call_impl2(Out& out, T_ const& val, mpl::true_)
+        {
+            out << '[';
+            if (!traits::is_empty(val))
+            {
+                bool first = true;
+                typename container_iterator<T_ const>::type iend = traits::end(val);
+                for (typename container_iterator<T_ const>::type i = traits::begin(val);
+                     !traits::compare(i, iend); traits::next(i))
+                {
+                    if (!first)
+                        out << ", ";
+                    first = false;
+                    spirit::traits::print_attribute(out, traits::deref(i));
+                }
+            }
+            out << ']';
+        }
+
+        // for variant types
+        template <typename T_>
+        static void call_impl(Out& out, T_ const& val, mpl::false_)
+        {
+            apply_visitor(detail::print_visitor<Out>(out), val);
+        }
+
+        // for non-variant types
+        template <typename T_>
+        static void call_impl(Out& out, T_ const& val, mpl::true_)
+        {
+            call_impl2(out, val, is_container<T_>());
+        }
+
+        // main entry point
+        static void call(Out& out, T const& val)
+        {
+            call_impl(out, val, not_is_variant<T>());
+        }
+    };
+
+    template <typename Out, typename T>
+    struct print_attribute_debug<Out, boost::optional<T> >
+    {
+        static void call(Out& out, boost::optional<T> const& val)
+        {
+            if (val)
+                spirit::traits::print_attribute(out, *val);
+            else
+                out << "[empty]";
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Out, typename T>
+    inline void print_attribute(Out& out, T const& val)
+    {
+        print_attribute_debug<Out, T>::call(out, val);
+    }
+
+    template <typename Out>
+    inline void print_attribute(Out&, unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // generate debug output for lookahead token (character) stream
+    namespace detail
+    {
+        struct token_printer_debug_for_chars
+        {
+            template<typename Out, typename Char>
+            static void print(Out& o, Char c)
+            {
+                using namespace std;    // allow for ADL to find the proper iscntrl
+
+                if (c == static_cast<Char>('\a'))
+                    o << "\\a";
+                else if (c == static_cast<Char>('\b'))
+                    o << "\\b";
+                else if (c == static_cast<Char>('\f'))
+                    o << "\\f";
+                else if (c == static_cast<Char>('\n'))
+                    o << "\\n";
+                else if (c == static_cast<Char>('\r'))
+                    o << "\\r";
+                else if (c == static_cast<Char>('\t'))
+                    o << "\\t";
+                else if (c == static_cast<Char>('\v'))
+                    o << "\\v";
+                else if (c >= 0 && c < 127 && iscntrl(c))
+                    o << "\\" << std::oct << static_cast<int>(c);
+                else
+                    o << static_cast<char>(c);
+            }
+        };
+
+        // for token types where the comparison with char constants wouldn't work
+        struct token_printer_debug
+        {
+            template<typename Out, typename T>
+            static void print(Out& o, T const& val)
+            {
+                o << val;
+            }
+        };
+    }
+
+    template <typename T, typename Enable>
+    struct token_printer_debug
+      : mpl::if_<
+            mpl::and_<
+                is_convertible<T, char>, is_convertible<char, T> >
+          , detail::token_printer_debug_for_chars
+          , detail::token_printer_debug>::type
+    {};
+
+    template <typename Out, typename T>
+    inline void print_token(Out& out, T const& val)
+    {
+        // allow to customize the token printer routine
+        token_printer_debug<T>::print(out, val);
+    }
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace result_of
+{
+    template <typename Exposed, typename Transformed, typename Domain>
+    struct pre_transform
+      : traits::transform_attribute<Exposed, Transformed, Domain>
+    {};
+}}}
+
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/attributes_fwd.hpp b/3rdParty/Boost/src/boost/spirit/home/support/attributes_fwd.hpp
new file mode 100644
index 0000000..6086d37
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/attributes_fwd.hpp
@@ -0,0 +1,297 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c)      2010 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_ATTRIBUTES_FWD_OCT_01_2009_0715AM)
+#define BOOST_SPIRIT_ATTRIBUTES_FWD_OCT_01_2009_0715AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#if (defined(__GNUC__) && (__GNUC__ < 4)) || \
+    (defined(__APPLE__) && defined(__INTEL_COMPILER))
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/spirit/home/support/unused.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace result_of
+{
+    // forward declaration only
+    template <typename Exposed, typename Attribute>
+    struct extract_from;
+
+    template <typename T, typename Attribute>
+    struct attribute_as;
+
+    template <typename Exposed, typename Transformed, typename Domain>
+    struct pre_transform;
+
+    template <typename T>
+    struct optional_value;
+
+    template <typename Container>
+    struct begin;
+
+    template <typename Container>
+    struct end;
+
+    template <typename Iterator>
+    struct deref;
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Find out if T can be a strong substitute for Expected attribute
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Expected, typename Enable = void>
+    struct is_substitute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Find out if T can be a weak substitute for Expected attribute
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Expected, typename Enable = void>
+    struct is_weak_substitute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Determine if T is a proxy
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable = void>
+    struct is_proxy;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the attribute type to use from the given type
+    //
+    // This is needed to extract the correct attribute type from proxy classes
+    // as utilized in FUSION_ADAPT_ADT et. al.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Enable = void>
+    struct attribute_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the size of a fusion sequence (compile time)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct sequence_size;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Retrieve the size of an attribute (runtime)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Enable = void>
+    struct attribute_size;
+
+    template <typename Attribute>
+    typename attribute_size<Attribute>::type
+    size(Attribute const& attr);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Determines how we pass attributes to semantic actions. This
+    // may be specialized. By default, all attributes are wrapped in
+    // a fusion sequence, because the attribute has to be treated as being
+    // a single value in any case (even if it actually already is a fusion
+    // sequence in its own).
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Component, typename Attribute, typename Enable = void>
+    struct pass_attribute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable = void>
+    struct optional_attribute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Sometimes the user needs to transform the attribute types for certain
+    // attributes. This template can be used as a customization point, where
+    // the user is able specify specific transformation rules for any attribute
+    // type.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Exposed, typename Transformed, typename Domain
+      , typename Enable = void>
+    struct transform_attribute;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Qi only
+    template <typename Attribute, typename Iterator, typename Enable = void>
+    struct assign_to_attribute_from_iterators;
+
+    template <typename Iterator, typename Attribute>
+    void assign_to(Iterator const& first, Iterator const& last, Attribute& attr);
+
+    template <typename Iterator>
+    void assign_to(Iterator const&, Iterator const&, unused_type);
+
+    template <typename Attribute, typename T, typename Enable = void>
+    struct assign_to_attribute_from_value;
+
+    template <typename Attribute, typename T, typename Enable = void>
+    struct assign_to_container_from_value;
+
+    template <typename T, typename Attribute>
+    void assign_to(T const& val, Attribute& attr);
+
+    template <typename T>
+    void assign_to(T const&, unused_type);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Karma only
+    template <typename Attribute, typename Exposed, typename Enable = void>
+    struct extract_from_attribute;
+
+    template <typename Attribute, typename Exposed, typename Enable = void>
+    struct extract_from_container;
+
+    template <typename Exposed, typename Attribute, typename Context>
+    typename spirit::result_of::extract_from<Exposed, Attribute>::type
+    extract_from(Attribute const& attr, Context& ctx
+#if (defined(__GNUC__) && (__GNUC__ < 4)) || \
+    (defined(__APPLE__) && defined(__INTEL_COMPILER))
+      , typename enable_if<traits::not_is_unused<Attribute> >::type* = NULL
+#endif
+    );
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Karma only
+    template <typename T, typename Attribute, typename Enable = void>
+    struct attribute_as;
+
+    template <typename T, typename Attribute>
+    typename spirit::result_of::attribute_as<T, Attribute>::type
+    as(Attribute const& attr);
+
+    template <typename T, typename Attribute>
+    bool valid_as(Attribute const& attr);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // return the type currently stored in the given variant
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable = void>
+    struct variant_which;
+
+    template <typename T>
+    int which(T const& v);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Determine, whether T is a variant like type
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Domain = unused_type, typename Enable = void>
+    struct not_is_variant;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Determine, whether T is a variant like type
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Domain = unused_type, typename Enable = void>
+    struct not_is_optional;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Clear data efficiently
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable = void>
+    struct clear_value;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Determine the value type of the given container type
+    ///////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable = void>
+    struct container_value;
+
+    template <typename Container, typename Enable = void>
+    struct container_iterator;
+
+    template <typename T, typename Enable = void>
+    struct is_container;
+
+    template <typename T, typename Enable = void>
+    struct is_iterator_range;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Attribute, typename Context = unused_type
+            , typename Iterator = unused_type, typename Enable = void>
+    struct handles_container;
+
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence, typename Domain, typename Enable = void>
+    struct pass_through_container;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Qi only
+    template <typename Container, typename T, typename Enable = void>
+    struct push_back_container;
+
+    template <typename Container, typename Enable = void>
+    struct is_empty_container;
+
+    template <typename Container, typename Enable = void>
+    struct make_container_attribute;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Determine the iterator type of the given container type
+    // Karma only
+    ///////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable = void>
+    struct begin_container;
+
+    template <typename Container, typename Enable = void>
+    struct end_container;
+
+    template <typename Iterator, typename Enable = void>
+    struct deref_iterator;
+
+    template <typename Iterator, typename Enable = void>
+    struct next_iterator;
+
+    template <typename Iterator, typename Enable = void>
+    struct compare_iterators;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Print the given attribute of type T to the stream given as Out
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Out, typename T, typename Enable = void>
+    struct print_attribute_debug;
+
+    template <typename Out, typename T>
+    void print_attribute(Out&, T const&);
+
+    template <typename Out>
+    void print_attribute(Out&, unused_type);
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Char, typename Enable = void>
+    struct token_printer_debug;
+
+    template<typename Out, typename T>
+    void print_token(Out&, T const&);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Access attributes from a karma symbol table
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Attribute, typename Enable = void>
+    struct symbols_lookup;
+
+    template <typename Attribute, typename T, typename Enable = void>
+    struct symbols_value;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // transform attribute types exposed from compound operator components
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Attribute, typename Domain>
+    struct alternative_attribute_transform;
+
+    template <typename Attribute, typename Domain>
+    struct sequence_attribute_transform;
+
+    template <typename Attribute, typename Domain>
+    struct permutation_attribute_transform;
+
+    template <typename Attribute, typename Domain>
+    struct sequential_or_attribute_transform;
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_class.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_class.hpp
new file mode 100644
index 0000000..574a25e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_class.hpp
@@ -0,0 +1,797 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CHAR_CLASS_NOVEMBER_10_2006_0907AM)
+#define BOOST_SPIRIT_CHAR_CLASS_NOVEMBER_10_2006_0907AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <string>
+
+#include <boost/spirit/include/phoenix_limits.hpp>      // needs to be included before proto
+#include <boost/proto/proto.hpp>
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/detail/is_spirit_tag.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/make_signed.hpp>
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4800) // 'int' : forcing value to bool 'true' or 'false' warning
+#endif
+
+namespace boost { namespace spirit { namespace detail
+{
+    // Here's the thing... typical encodings (except ASCII) deal with unsigned
+    // integers > 127. ASCII uses only 127. Yet, most char and wchar_t are signed.
+    // Thus, a char with value > 127 is negative (e.g. char 233 is -23). When you
+    // cast this to an unsigned int with 32 bits, you get 4294967273!
+    //
+    // The trick is to cast to an unsigned version of the source char first
+    // before casting to the target. {P.S. Don't worry about the code, the
+    // optimizer will optimize the if-else branches}
+
+    template <typename TargetChar, typename SourceChar>
+    TargetChar cast_char(SourceChar ch)
+    {
+        if (is_signed<TargetChar>::value != is_signed<SourceChar>::value)
+        {
+            if (is_signed<SourceChar>::value)
+            {
+                 // source is signed, target is unsigned
+                typedef typename make_unsigned<SourceChar>::type USourceChar;
+                return TargetChar(USourceChar(ch));
+            }
+            else
+            {
+                 // source is unsigned, target is signed
+                typedef typename make_signed<SourceChar>::type SSourceChar;
+                return TargetChar(SSourceChar(ch));
+            }
+        }
+        else
+        {
+            // source and target has same signedness
+            return TargetChar(ch); // just cast
+        }
+    }
+}}}
+
+namespace boost { namespace spirit { namespace tag
+{
+    struct char_ { BOOST_SPIRIT_IS_TAG() };
+    struct string { BOOST_SPIRIT_IS_TAG() };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // classification tags
+    struct alnum { BOOST_SPIRIT_IS_TAG() };
+    struct alpha { BOOST_SPIRIT_IS_TAG() };
+    struct digit { BOOST_SPIRIT_IS_TAG() };
+    struct xdigit { BOOST_SPIRIT_IS_TAG() };
+    struct cntrl { BOOST_SPIRIT_IS_TAG() };
+    struct graph { BOOST_SPIRIT_IS_TAG() };
+    struct print { BOOST_SPIRIT_IS_TAG() };
+    struct punct { BOOST_SPIRIT_IS_TAG() };
+    struct space { BOOST_SPIRIT_IS_TAG() };
+    struct blank { BOOST_SPIRIT_IS_TAG() };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // classification/conversion tags
+    struct no_case { BOOST_SPIRIT_IS_TAG() };
+    struct lower { BOOST_SPIRIT_IS_TAG() };
+    struct upper { BOOST_SPIRIT_IS_TAG() };
+    struct lowernum { BOOST_SPIRIT_IS_TAG() };
+    struct uppernum { BOOST_SPIRIT_IS_TAG() };
+    struct ucs4 { BOOST_SPIRIT_IS_TAG() };
+    struct encoding { BOOST_SPIRIT_IS_TAG() };
+
+#if defined(BOOST_SPIRIT_UNICODE)
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Major Categories
+///////////////////////////////////////////////////////////////////////////
+    struct letter { BOOST_SPIRIT_IS_TAG() };
+    struct mark { BOOST_SPIRIT_IS_TAG() };
+    struct number { BOOST_SPIRIT_IS_TAG() };
+    struct separator { BOOST_SPIRIT_IS_TAG() };
+    struct other { BOOST_SPIRIT_IS_TAG() };
+    struct punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct symbol { BOOST_SPIRIT_IS_TAG() };
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode General Categories
+///////////////////////////////////////////////////////////////////////////
+    struct uppercase_letter { BOOST_SPIRIT_IS_TAG() };
+    struct lowercase_letter { BOOST_SPIRIT_IS_TAG() };
+    struct titlecase_letter { BOOST_SPIRIT_IS_TAG() };
+    struct modifier_letter { BOOST_SPIRIT_IS_TAG() };
+    struct other_letter { BOOST_SPIRIT_IS_TAG() };
+
+    struct nonspacing_mark { BOOST_SPIRIT_IS_TAG() };
+    struct enclosing_mark { BOOST_SPIRIT_IS_TAG() };
+    struct spacing_mark { BOOST_SPIRIT_IS_TAG() };
+
+    struct decimal_number { BOOST_SPIRIT_IS_TAG() };
+    struct letter_number { BOOST_SPIRIT_IS_TAG() };
+    struct other_number { BOOST_SPIRIT_IS_TAG() };
+
+    struct space_separator { BOOST_SPIRIT_IS_TAG() };
+    struct line_separator { BOOST_SPIRIT_IS_TAG() };
+    struct paragraph_separator { BOOST_SPIRIT_IS_TAG() };
+
+    struct control { BOOST_SPIRIT_IS_TAG() };
+    struct format { BOOST_SPIRIT_IS_TAG() };
+    struct private_use { BOOST_SPIRIT_IS_TAG() };
+    struct surrogate { BOOST_SPIRIT_IS_TAG() };
+    struct unassigned { BOOST_SPIRIT_IS_TAG() };
+
+    struct dash_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct open_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct close_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct connector_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct other_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct initial_punctuation { BOOST_SPIRIT_IS_TAG() };
+    struct final_punctuation { BOOST_SPIRIT_IS_TAG() };
+
+    struct math_symbol { BOOST_SPIRIT_IS_TAG() };
+    struct currency_symbol { BOOST_SPIRIT_IS_TAG() };
+    struct modifier_symbol { BOOST_SPIRIT_IS_TAG() };
+    struct other_symbol { BOOST_SPIRIT_IS_TAG() };
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Derived Categories
+///////////////////////////////////////////////////////////////////////////
+    struct alphabetic { BOOST_SPIRIT_IS_TAG() };
+    struct uppercase { BOOST_SPIRIT_IS_TAG() };
+    struct lowercase { BOOST_SPIRIT_IS_TAG() };
+    struct white_space { BOOST_SPIRIT_IS_TAG() };
+    struct hex_digit { BOOST_SPIRIT_IS_TAG() };
+    struct noncharacter_code_point { BOOST_SPIRIT_IS_TAG() };
+    struct default_ignorable_code_point { BOOST_SPIRIT_IS_TAG() };
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Scripts
+///////////////////////////////////////////////////////////////////////////
+    struct arabic { BOOST_SPIRIT_IS_TAG() };
+    struct imperial_aramaic { BOOST_SPIRIT_IS_TAG() };
+    struct armenian { BOOST_SPIRIT_IS_TAG() };
+    struct avestan { BOOST_SPIRIT_IS_TAG() };
+    struct balinese { BOOST_SPIRIT_IS_TAG() };
+    struct bamum { BOOST_SPIRIT_IS_TAG() };
+    struct bengali { BOOST_SPIRIT_IS_TAG() };
+    struct bopomofo { BOOST_SPIRIT_IS_TAG() };
+    struct braille { BOOST_SPIRIT_IS_TAG() };
+    struct buginese { BOOST_SPIRIT_IS_TAG() };
+    struct buhid { BOOST_SPIRIT_IS_TAG() };
+    struct canadian_aboriginal { BOOST_SPIRIT_IS_TAG() };
+    struct carian { BOOST_SPIRIT_IS_TAG() };
+    struct cham { BOOST_SPIRIT_IS_TAG() };
+    struct cherokee { BOOST_SPIRIT_IS_TAG() };
+    struct coptic { BOOST_SPIRIT_IS_TAG() };
+    struct cypriot { BOOST_SPIRIT_IS_TAG() };
+    struct cyrillic { BOOST_SPIRIT_IS_TAG() };
+    struct devanagari { BOOST_SPIRIT_IS_TAG() };
+    struct deseret { BOOST_SPIRIT_IS_TAG() };
+    struct egyptian_hieroglyphs { BOOST_SPIRIT_IS_TAG() };
+    struct ethiopic { BOOST_SPIRIT_IS_TAG() };
+    struct georgian { BOOST_SPIRIT_IS_TAG() };
+    struct glagolitic { BOOST_SPIRIT_IS_TAG() };
+    struct gothic { BOOST_SPIRIT_IS_TAG() };
+    struct greek { BOOST_SPIRIT_IS_TAG() };
+    struct gujarati { BOOST_SPIRIT_IS_TAG() };
+    struct gurmukhi { BOOST_SPIRIT_IS_TAG() };
+    struct hangul { BOOST_SPIRIT_IS_TAG() };
+    struct han { BOOST_SPIRIT_IS_TAG() };
+    struct hanunoo { BOOST_SPIRIT_IS_TAG() };
+    struct hebrew { BOOST_SPIRIT_IS_TAG() };
+    struct hiragana { BOOST_SPIRIT_IS_TAG() };
+    struct katakana_or_hiragana { BOOST_SPIRIT_IS_TAG() };
+    struct old_italic { BOOST_SPIRIT_IS_TAG() };
+    struct javanese { BOOST_SPIRIT_IS_TAG() };
+    struct kayah_li { BOOST_SPIRIT_IS_TAG() };
+    struct katakana { BOOST_SPIRIT_IS_TAG() };
+    struct kharoshthi { BOOST_SPIRIT_IS_TAG() };
+    struct khmer { BOOST_SPIRIT_IS_TAG() };
+    struct kannada { BOOST_SPIRIT_IS_TAG() };
+    struct kaithi { BOOST_SPIRIT_IS_TAG() };
+    struct tai_tham { BOOST_SPIRIT_IS_TAG() };
+    struct lao { BOOST_SPIRIT_IS_TAG() };
+    struct latin { BOOST_SPIRIT_IS_TAG() };
+    struct lepcha { BOOST_SPIRIT_IS_TAG() };
+    struct limbu { BOOST_SPIRIT_IS_TAG() };
+    struct linear_b { BOOST_SPIRIT_IS_TAG() };
+    struct lisu { BOOST_SPIRIT_IS_TAG() };
+    struct lycian { BOOST_SPIRIT_IS_TAG() };
+    struct lydian { BOOST_SPIRIT_IS_TAG() };
+    struct malayalam { BOOST_SPIRIT_IS_TAG() };
+    struct mongolian { BOOST_SPIRIT_IS_TAG() };
+    struct meetei_mayek { BOOST_SPIRIT_IS_TAG() };
+    struct myanmar { BOOST_SPIRIT_IS_TAG() };
+    struct nko { BOOST_SPIRIT_IS_TAG() };
+    struct ogham { BOOST_SPIRIT_IS_TAG() };
+    struct ol_chiki { BOOST_SPIRIT_IS_TAG() };
+    struct old_turkic { BOOST_SPIRIT_IS_TAG() };
+    struct oriya { BOOST_SPIRIT_IS_TAG() };
+    struct osmanya { BOOST_SPIRIT_IS_TAG() };
+    struct phags_pa { BOOST_SPIRIT_IS_TAG() };
+    struct inscriptional_pahlavi { BOOST_SPIRIT_IS_TAG() };
+    struct phoenician { BOOST_SPIRIT_IS_TAG() };
+    struct inscriptional_parthian { BOOST_SPIRIT_IS_TAG() };
+    struct rejang { BOOST_SPIRIT_IS_TAG() };
+    struct runic { BOOST_SPIRIT_IS_TAG() };
+    struct samaritan { BOOST_SPIRIT_IS_TAG() };
+    struct old_south_arabian { BOOST_SPIRIT_IS_TAG() };
+    struct saurashtra { BOOST_SPIRIT_IS_TAG() };
+    struct shavian { BOOST_SPIRIT_IS_TAG() };
+    struct sinhala { BOOST_SPIRIT_IS_TAG() };
+    struct sundanese { BOOST_SPIRIT_IS_TAG() };
+    struct syloti_nagri { BOOST_SPIRIT_IS_TAG() };
+    struct syriac { BOOST_SPIRIT_IS_TAG() };
+    struct tagbanwa { BOOST_SPIRIT_IS_TAG() };
+    struct tai_le { BOOST_SPIRIT_IS_TAG() };
+    struct new_tai_lue { BOOST_SPIRIT_IS_TAG() };
+    struct tamil { BOOST_SPIRIT_IS_TAG() };
+    struct tai_viet { BOOST_SPIRIT_IS_TAG() };
+    struct telugu { BOOST_SPIRIT_IS_TAG() };
+    struct tifinagh { BOOST_SPIRIT_IS_TAG() };
+    struct tagalog { BOOST_SPIRIT_IS_TAG() };
+    struct thaana { BOOST_SPIRIT_IS_TAG() };
+    struct thai { BOOST_SPIRIT_IS_TAG() };
+    struct tibetan { BOOST_SPIRIT_IS_TAG() };
+    struct ugaritic { BOOST_SPIRIT_IS_TAG() };
+    struct vai { BOOST_SPIRIT_IS_TAG() };
+    struct old_persian { BOOST_SPIRIT_IS_TAG() };
+    struct cuneiform { BOOST_SPIRIT_IS_TAG() };
+    struct yi { BOOST_SPIRIT_IS_TAG() };
+    struct inherited { BOOST_SPIRIT_IS_TAG() };
+    struct common { BOOST_SPIRIT_IS_TAG() };
+    struct unknown { BOOST_SPIRIT_IS_TAG() };
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////
+    // This composite tag type encodes both the character
+    // set and the specific char tag (used for classification
+    // or conversion). char_code_base and char_encoding_base
+    // can be used to test for modifier membership (see modifier.hpp)
+    template <typename CharClass>
+    struct char_code_base {};
+
+    template <typename CharEncoding>
+    struct char_encoding_base {};
+
+    template <typename CharClass, typename CharEncoding>
+    struct char_code
+        : char_code_base<CharClass>, char_encoding_base<CharEncoding>
+    {
+        BOOST_SPIRIT_IS_TAG()
+        typedef CharEncoding char_encoding; // e.g. ascii
+        typedef CharClass char_class;       // e.g. tag::alnum
+    };
+}}}
+
+namespace boost { namespace spirit { namespace char_class
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Test characters for classification
+    template <typename CharEncoding>
+    struct classify
+    {
+        typedef typename CharEncoding::char_type char_type;
+
+#define BOOST_SPIRIT_CLASSIFY(name, isname)                                     \
+        template <typename Char>                                                \
+        static bool                                                             \
+        is(tag::name, Char ch)                                                  \
+        {                                                                       \
+            return CharEncoding::isname                                         \
+                BOOST_PREVENT_MACRO_SUBSTITUTION                                \
+                    (detail::cast_char<char_type>(ch));                         \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_CLASSIFY(char_, ischar)
+        BOOST_SPIRIT_CLASSIFY(alnum, isalnum)
+        BOOST_SPIRIT_CLASSIFY(alpha, isalpha)
+        BOOST_SPIRIT_CLASSIFY(digit, isdigit)
+        BOOST_SPIRIT_CLASSIFY(xdigit, isxdigit)
+        BOOST_SPIRIT_CLASSIFY(cntrl, iscntrl)
+        BOOST_SPIRIT_CLASSIFY(graph, isgraph)
+        BOOST_SPIRIT_CLASSIFY(lower, islower)
+        BOOST_SPIRIT_CLASSIFY(print, isprint)
+        BOOST_SPIRIT_CLASSIFY(punct, ispunct)
+        BOOST_SPIRIT_CLASSIFY(space, isspace)
+        BOOST_SPIRIT_CLASSIFY(blank, isblank)
+        BOOST_SPIRIT_CLASSIFY(upper, isupper)
+
+#undef BOOST_SPIRIT_CLASSIFY
+
+        template <typename Char>
+        static bool
+        is(tag::lowernum, Char ch)
+        {
+            return CharEncoding::islower(detail::cast_char<char_type>(ch)) ||
+                   CharEncoding::isdigit(detail::cast_char<char_type>(ch));
+        }
+
+        template <typename Char>
+        static bool
+        is(tag::uppernum, Char ch)
+        {
+            return CharEncoding::isupper(detail::cast_char<char_type>(ch)) ||
+                   CharEncoding::isdigit(detail::cast_char<char_type>(ch));
+        }
+
+#if defined(BOOST_SPIRIT_UNICODE)
+
+#define BOOST_SPIRIT_UNICODE_CLASSIFY(name)                                     \
+        template <typename Char>                                                \
+        static bool                                                             \
+        is(tag::name, Char ch)                                                  \
+        {                                                                       \
+            return CharEncoding::is_##name(detail::cast_char<char_type>(ch));   \
+        }                                                                       \
+        /***/
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Major Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY(letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(other)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(symbol)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode General Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY(uppercase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lowercase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(titlecase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(modifier_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(other_letter)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(nonspacing_mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(enclosing_mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(spacing_mark)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(decimal_number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(letter_number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(other_number)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(space_separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(line_separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(paragraph_separator)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(control)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(format)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(private_use)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(surrogate)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(unassigned)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(dash_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(open_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(close_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(connector_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(other_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(initial_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(final_punctuation)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY(math_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(currency_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(modifier_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(other_symbol)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Derived Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY(alphabetic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(uppercase)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lowercase)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(white_space)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(hex_digit)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(noncharacter_code_point)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(default_ignorable_code_point)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Scripts
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY(arabic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(imperial_aramaic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(armenian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(avestan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(balinese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(bamum)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(bengali)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(bopomofo)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(braille)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(buginese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(buhid)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(canadian_aboriginal)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(carian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(cham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(cherokee)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(coptic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(cypriot)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(cyrillic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(devanagari)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(deseret)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(egyptian_hieroglyphs)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(ethiopic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(georgian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(glagolitic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(gothic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(greek)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(gujarati)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(gurmukhi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(hangul)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(han)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(hanunoo)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(hebrew)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(hiragana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(katakana_or_hiragana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(old_italic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(javanese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(kayah_li)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(katakana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(kharoshthi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(khmer)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(kannada)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(kaithi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tai_tham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lao)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(latin)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lepcha)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(limbu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(linear_b)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lisu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lycian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(lydian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(malayalam)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(mongolian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(meetei_mayek)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(myanmar)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(nko)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(ogham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(ol_chiki)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(old_turkic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(oriya)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(osmanya)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(phags_pa)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(inscriptional_pahlavi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(phoenician)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(inscriptional_parthian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(rejang)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(runic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(samaritan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(old_south_arabian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(saurashtra)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(shavian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(sinhala)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(sundanese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(syloti_nagri)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(syriac)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tagbanwa)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tai_le)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(new_tai_lue)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tamil)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tai_viet)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(telugu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tifinagh)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tagalog)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(thaana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(thai)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(tibetan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(ugaritic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(vai)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(old_persian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(cuneiform)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(yi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(inherited)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(common)
+    BOOST_SPIRIT_UNICODE_CLASSIFY(unknown)
+
+#undef BOOST_SPIRIT_UNICODE_CLASSIFY
+#endif
+
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Convert characters
+    template <typename CharEncoding>
+    struct convert
+    {
+        typedef typename CharEncoding::char_type char_type;
+
+        template <typename Char>
+        static Char
+        to(tag::lower, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::tolower(detail::cast_char<char_type>(ch)));
+        }
+
+        template <typename Char>
+        static Char
+        to(tag::upper, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::toupper(detail::cast_char<char_type>(ch)));
+        }
+
+        template <typename Char>
+        static Char
+        to(tag::ucs4, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::toucs4(detail::cast_char<char_type>(ch)));
+        }
+
+        template <typename Char>
+        static Char
+        to(unused_type, Char ch)
+        {
+            return ch;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Info on character classification
+    template <typename CharEncoding>
+    struct what
+    {
+#define BOOST_SPIRIT_CLASSIFY_WHAT(name, isname)                                \
+        static char const* is(tag::name)                                        \
+        {                                                                       \
+            return isname;                                                      \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_CLASSIFY_WHAT(char_, "char")
+        BOOST_SPIRIT_CLASSIFY_WHAT(alnum, "alnum")
+        BOOST_SPIRIT_CLASSIFY_WHAT(alpha, "alpha")
+        BOOST_SPIRIT_CLASSIFY_WHAT(digit, "digit")
+        BOOST_SPIRIT_CLASSIFY_WHAT(xdigit, "xdigit")
+        BOOST_SPIRIT_CLASSIFY_WHAT(cntrl, "cntrl")
+        BOOST_SPIRIT_CLASSIFY_WHAT(graph, "graph")
+        BOOST_SPIRIT_CLASSIFY_WHAT(lower, "lower")
+        BOOST_SPIRIT_CLASSIFY_WHAT(lowernum, "lowernum")
+        BOOST_SPIRIT_CLASSIFY_WHAT(print, "print")
+        BOOST_SPIRIT_CLASSIFY_WHAT(punct, "punct")
+        BOOST_SPIRIT_CLASSIFY_WHAT(space, "space")
+        BOOST_SPIRIT_CLASSIFY_WHAT(blank, "blank")
+        BOOST_SPIRIT_CLASSIFY_WHAT(upper, "upper")
+        BOOST_SPIRIT_CLASSIFY_WHAT(uppernum, "uppernum")
+        BOOST_SPIRIT_CLASSIFY_WHAT(ucs4, "ucs4")
+
+#undef BOOST_SPIRIT_CLASSIFY_WHAT
+
+#if defined(BOOST_SPIRIT_UNICODE)
+
+#define BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(name)                                \
+        static char const* is(tag::name)                                        \
+        {                                                                       \
+            return BOOST_PP_STRINGIZE(name);                                    \
+        }                                                                       \
+        /***/
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Major Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(other)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(symbol)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode General Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(uppercase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lowercase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(titlecase_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(modifier_letter)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(other_letter)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(nonspacing_mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(enclosing_mark)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(spacing_mark)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(decimal_number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(letter_number)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(other_number)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(space_separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(line_separator)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(paragraph_separator)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(control)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(format)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(private_use)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(surrogate)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(unassigned)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(dash_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(open_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(close_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(connector_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(other_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(initial_punctuation)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(final_punctuation)
+
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(math_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(currency_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(modifier_symbol)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(other_symbol)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Derived Categories
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(alphabetic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(uppercase)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lowercase)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(white_space)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(hex_digit)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(noncharacter_code_point)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(default_ignorable_code_point)
+
+///////////////////////////////////////////////////////////////////////////
+//  Unicode Scripts
+///////////////////////////////////////////////////////////////////////////
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(arabic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(imperial_aramaic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(armenian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(avestan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(balinese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(bamum)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(bengali)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(bopomofo)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(braille)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(buginese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(buhid)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(canadian_aboriginal)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(carian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(cham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(cherokee)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(coptic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(cypriot)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(cyrillic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(devanagari)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(deseret)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(egyptian_hieroglyphs)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(ethiopic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(georgian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(glagolitic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(gothic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(greek)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(gujarati)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(gurmukhi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(hangul)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(han)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(hanunoo)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(hebrew)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(hiragana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(katakana_or_hiragana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(old_italic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(javanese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(kayah_li)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(katakana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(kharoshthi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(khmer)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(kannada)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(kaithi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tai_tham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lao)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(latin)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lepcha)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(limbu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(linear_b)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lisu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lycian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(lydian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(malayalam)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(mongolian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(meetei_mayek)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(myanmar)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(nko)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(ogham)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(ol_chiki)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(old_turkic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(oriya)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(osmanya)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(phags_pa)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(inscriptional_pahlavi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(phoenician)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(inscriptional_parthian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(rejang)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(runic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(samaritan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(old_south_arabian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(saurashtra)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(shavian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(sinhala)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(sundanese)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(syloti_nagri)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(syriac)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tagbanwa)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tai_le)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(new_tai_lue)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tamil)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tai_viet)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(telugu)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tifinagh)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tagalog)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(thaana)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(thai)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(tibetan)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(ugaritic)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(vai)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(old_persian)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(cuneiform)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(yi)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(inherited)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(common)
+    BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT(unknown)
+
+#undef BOOST_SPIRIT_UNICODE_CLASSIFY_WHAT
+#endif
+
+    };
+}}}
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // This meta-function evaluates to mpl::true_ if the function
+    // char_encoding::ischar() needs to be called to ensure correct matching.
+    // This happens mainly if the character type returned from the underlying
+    // iterator is larger than the character type of the used character
+    // encoding. Additionally, this meta-function provides a customization
+    // point for the lexer library to enforce this behavior while parsing
+    // a token stream.
+    template <typename Char, typename BaseChar>
+    struct mustcheck_ischar
+      : mpl::bool_<(sizeof(Char) > sizeof(BaseChar)) ? true : false> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The following template calls char_encoding::ischar, if necessary
+    template <typename CharParam, typename CharEncoding
+      , bool MustCheck = mustcheck_ischar<
+            CharParam, typename CharEncoding::char_type>::value>
+    struct ischar
+    {
+        static bool call(CharParam)
+        {
+            return true;
+        }
+    };
+
+    template <typename CharParam, typename CharEncoding>
+    struct ischar<CharParam, CharEncoding, true>
+    {
+        static bool call(CharParam const& ch)
+        {
+            return CharEncoding::ischar(int(ch));
+        }
+    };
+
+}}}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp
new file mode 100644
index 0000000..9b8a72f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp
@@ -0,0 +1,313 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_ASCII_APRIL_26_2006_1106PM)
+#define BOOST_SPIRIT_ASCII_APRIL_26_2006_1106PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <climits>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// constants used to classify the single characters
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_CC_DIGIT    0x0001
+#define BOOST_CC_XDIGIT   0x0002
+#define BOOST_CC_ALPHA    0x0004
+#define BOOST_CC_CTRL     0x0008
+#define BOOST_CC_LOWER    0x0010
+#define BOOST_CC_UPPER    0x0020
+#define BOOST_CC_SPACE    0x0040
+#define BOOST_CC_PUNCT    0x0080
+
+namespace boost { namespace spirit { namespace char_encoding
+{
+    // The detection of isgraph(), isprint() and isblank() is done programmatically
+    // to keep the character type table small. Additionally, these functions are
+    // rather seldom used and the programmatic detection is very simple.
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ASCII character classification table
+    ///////////////////////////////////////////////////////////////////////////
+    const unsigned char ascii_char_types[] =
+    {
+        /* NUL   0   0 */   BOOST_CC_CTRL,
+        /* SOH   1   1 */   BOOST_CC_CTRL,
+        /* STX   2   2 */   BOOST_CC_CTRL,
+        /* ETX   3   3 */   BOOST_CC_CTRL,
+        /* EOT   4   4 */   BOOST_CC_CTRL,
+        /* ENQ   5   5 */   BOOST_CC_CTRL,
+        /* ACK   6   6 */   BOOST_CC_CTRL,
+        /* BEL   7   7 */   BOOST_CC_CTRL,
+        /* BS    8   8 */   BOOST_CC_CTRL,
+        /* HT    9   9 */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* NL   10   a */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* VT   11   b */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* NP   12   c */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* CR   13   d */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* SO   14   e */   BOOST_CC_CTRL,
+        /* SI   15   f */   BOOST_CC_CTRL,
+        /* DLE  16  10 */   BOOST_CC_CTRL,
+        /* DC1  17  11 */   BOOST_CC_CTRL,
+        /* DC2  18  12 */   BOOST_CC_CTRL,
+        /* DC3  19  13 */   BOOST_CC_CTRL,
+        /* DC4  20  14 */   BOOST_CC_CTRL,
+        /* NAK  21  15 */   BOOST_CC_CTRL,
+        /* SYN  22  16 */   BOOST_CC_CTRL,
+        /* ETB  23  17 */   BOOST_CC_CTRL,
+        /* CAN  24  18 */   BOOST_CC_CTRL,
+        /* EM   25  19 */   BOOST_CC_CTRL,
+        /* SUB  26  1a */   BOOST_CC_CTRL,
+        /* ESC  27  1b */   BOOST_CC_CTRL,
+        /* FS   28  1c */   BOOST_CC_CTRL,
+        /* GS   29  1d */   BOOST_CC_CTRL,
+        /* RS   30  1e */   BOOST_CC_CTRL,
+        /* US   31  1f */   BOOST_CC_CTRL,
+        /* SP   32  20 */   BOOST_CC_SPACE,
+        /*  !   33  21 */   BOOST_CC_PUNCT,
+        /*  "   34  22 */   BOOST_CC_PUNCT,
+        /*  #   35  23 */   BOOST_CC_PUNCT,
+        /*  $   36  24 */   BOOST_CC_PUNCT,
+        /*  %   37  25 */   BOOST_CC_PUNCT,
+        /*  &   38  26 */   BOOST_CC_PUNCT,
+        /*  '   39  27 */   BOOST_CC_PUNCT,
+        /*  (   40  28 */   BOOST_CC_PUNCT,
+        /*  )   41  29 */   BOOST_CC_PUNCT,
+        /*  *   42  2a */   BOOST_CC_PUNCT,
+        /*  +   43  2b */   BOOST_CC_PUNCT,
+        /*  ,   44  2c */   BOOST_CC_PUNCT,
+        /*  -   45  2d */   BOOST_CC_PUNCT,
+        /*  .   46  2e */   BOOST_CC_PUNCT,
+        /*  /   47  2f */   BOOST_CC_PUNCT,
+        /*  0   48  30 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  1   49  31 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  2   50  32 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  3   51  33 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  4   52  34 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  5   53  35 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  6   54  36 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  7   55  37 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  8   56  38 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  9   57  39 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  :   58  3a */   BOOST_CC_PUNCT,
+        /*  ;   59  3b */   BOOST_CC_PUNCT,
+        /*  <   60  3c */   BOOST_CC_PUNCT,
+        /*  =   61  3d */   BOOST_CC_PUNCT,
+        /*  >   62  3e */   BOOST_CC_PUNCT,
+        /*  ?   63  3f */   BOOST_CC_PUNCT,
+        /*  @   64  40 */   BOOST_CC_PUNCT,
+        /*  A   65  41 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  B   66  42 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  C   67  43 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  D   68  44 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  E   69  45 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  F   70  46 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  G   71  47 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  H   72  48 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  I   73  49 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  J   74  4a */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  K   75  4b */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  L   76  4c */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  M   77  4d */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  N   78  4e */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  O   79  4f */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  P   80  50 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Q   81  51 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  R   82  52 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  S   83  53 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  T   84  54 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  U   85  55 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  V   86  56 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  W   87  57 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  X   88  58 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Y   89  59 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Z   90  5a */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  [   91  5b */   BOOST_CC_PUNCT,
+        /*  \   92  5c */   BOOST_CC_PUNCT,
+        /*  ]   93  5d */   BOOST_CC_PUNCT,
+        /*  ^   94  5e */   BOOST_CC_PUNCT,
+        /*  _   95  5f */   BOOST_CC_PUNCT,
+        /*  `   96  60 */   BOOST_CC_PUNCT,
+        /*  a   97  61 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  b   98  62 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  c   99  63 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  d  100  64 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  e  101  65 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  f  102  66 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  g  103  67 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  h  104  68 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  i  105  69 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  j  106  6a */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  k  107  6b */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  l  108  6c */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  m  109  6d */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  n  110  6e */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  o  111  6f */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  p  112  70 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  q  113  71 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  r  114  72 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  s  115  73 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  t  116  74 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  u  117  75 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  v  118  76 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  w  119  77 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  x  120  78 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  y  121  79 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  z  122  7a */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  {  123  7b */   BOOST_CC_PUNCT,
+        /*  |  124  7c */   BOOST_CC_PUNCT,
+        /*  }  125  7d */   BOOST_CC_PUNCT,
+        /*  ~  126  7e */   BOOST_CC_PUNCT,
+        /* DEL 127  7f */   BOOST_CC_CTRL,
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Test characters for specified conditions (using ASCII)
+    ///////////////////////////////////////////////////////////////////////////
+    struct ascii
+    {
+        typedef char char_type;
+
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+
+        static bool
+        ischar(int ch)
+        {
+            return isascii_(ch);
+        }
+
+        static int
+        isalnum(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_ALPHA)
+                || (ascii_char_types[ch] & BOOST_CC_DIGIT);
+        }
+
+        static int
+        isalpha(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_ALPHA);
+        }
+
+        static int
+        isdigit(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_DIGIT);
+        }
+
+        static int
+        isxdigit(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_XDIGIT);
+        }
+
+        static int
+        iscntrl(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_CTRL);
+        }
+
+        static int
+        isgraph(int ch)
+        {
+            return ('\x21' <= ch && ch <= '\x7e');
+        }
+
+        static int
+        islower(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_LOWER);
+        }
+
+        static int
+        isprint(int ch)
+        {
+            return ('\x20' <= ch && ch <= '\x7e');
+        }
+
+        static int
+        ispunct(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_PUNCT);
+        }
+
+        static int
+        isspace(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_SPACE);
+        }
+
+        static int
+        isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch)
+        {
+            return ('\x09' == ch || '\x20' == ch);
+        }
+
+        static int
+        isupper(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return (ascii_char_types[ch] & BOOST_CC_UPPER);
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        //  Simple character conversions
+        ///////////////////////////////////////////////////////////////////////
+
+        static int
+        tolower(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return isupper(ch) ? (ch - 'A' + 'a') : ch;
+        }
+
+        static int
+        toupper(int ch)
+        {
+            BOOST_ASSERT(isascii_(ch));
+            return islower(ch) ? (ch - 'a' + 'A') : ch;
+        }
+
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+// undefine macros
+///////////////////////////////////////////////////////////////////////////////
+#undef BOOST_CC_DIGIT
+#undef BOOST_CC_XDIGIT
+#undef BOOST_CC_ALPHA
+#undef BOOST_CC_CTRL
+#undef BOOST_CC_LOWER
+#undef BOOST_CC_UPPER
+#undef BOOST_CC_PUNCT
+#undef BOOST_CC_SPACE
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp
new file mode 100644
index 0000000..37d2e6f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp
@@ -0,0 +1,711 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_ISO8859_1_APRIL_26_2006_1106PM)
+#define BOOST_SPIRIT_ISO8859_1_APRIL_26_2006_1106PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <climits>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// constants used to classify the single characters
+///////////////////////////////////////////////////////////////////////////////
+#define BOOST_CC_DIGIT    0x0001
+#define BOOST_CC_XDIGIT   0x0002
+#define BOOST_CC_ALPHA    0x0004
+#define BOOST_CC_CTRL     0x0008
+#define BOOST_CC_LOWER    0x0010
+#define BOOST_CC_UPPER    0x0020
+#define BOOST_CC_SPACE    0x0040
+#define BOOST_CC_PUNCT    0x0080
+
+namespace boost { namespace spirit { namespace char_encoding
+{
+    // The detection of isgraph(), isprint() and isblank() is done programmatically
+    // to keep the character type table small. Additionally, these functions are
+    // rather seldom used and the programmatic detection is very simple.
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ISO 8859-1 character classification table
+    //
+    // the comments intentionally contain non-ascii characters
+    // boostinspect:noascii
+    ///////////////////////////////////////////////////////////////////////////
+    const unsigned char iso8859_1_char_types[] =
+    {
+        /* NUL   0   0 */   BOOST_CC_CTRL,
+        /* SOH   1   1 */   BOOST_CC_CTRL,
+        /* STX   2   2 */   BOOST_CC_CTRL,
+        /* ETX   3   3 */   BOOST_CC_CTRL,
+        /* EOT   4   4 */   BOOST_CC_CTRL,
+        /* ENQ   5   5 */   BOOST_CC_CTRL,
+        /* ACK   6   6 */   BOOST_CC_CTRL,
+        /* BEL   7   7 */   BOOST_CC_CTRL,
+        /* BS    8   8 */   BOOST_CC_CTRL,
+        /* HT    9   9 */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* NL   10   a */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* VT   11   b */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* NP   12   c */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* CR   13   d */   BOOST_CC_CTRL|BOOST_CC_SPACE,
+        /* SO   14   e */   BOOST_CC_CTRL,
+        /* SI   15   f */   BOOST_CC_CTRL,
+        /* DLE  16  10 */   BOOST_CC_CTRL,
+        /* DC1  17  11 */   BOOST_CC_CTRL,
+        /* DC2  18  12 */   BOOST_CC_CTRL,
+        /* DC3  19  13 */   BOOST_CC_CTRL,
+        /* DC4  20  14 */   BOOST_CC_CTRL,
+        /* NAK  21  15 */   BOOST_CC_CTRL,
+        /* SYN  22  16 */   BOOST_CC_CTRL,
+        /* ETB  23  17 */   BOOST_CC_CTRL,
+        /* CAN  24  18 */   BOOST_CC_CTRL,
+        /* EM   25  19 */   BOOST_CC_CTRL,
+        /* SUB  26  1a */   BOOST_CC_CTRL,
+        /* ESC  27  1b */   BOOST_CC_CTRL,
+        /* FS   28  1c */   BOOST_CC_CTRL,
+        /* GS   29  1d */   BOOST_CC_CTRL,
+        /* RS   30  1e */   BOOST_CC_CTRL,
+        /* US   31  1f */   BOOST_CC_CTRL,
+        /* SP   32  20 */   BOOST_CC_SPACE,
+        /*  !   33  21 */   BOOST_CC_PUNCT,
+        /*  "   34  22 */   BOOST_CC_PUNCT,
+        /*  #   35  23 */   BOOST_CC_PUNCT,
+        /*  $   36  24 */   BOOST_CC_PUNCT,
+        /*  %   37  25 */   BOOST_CC_PUNCT,
+        /*  &   38  26 */   BOOST_CC_PUNCT,
+        /*  '   39  27 */   BOOST_CC_PUNCT,
+        /*  (   40  28 */   BOOST_CC_PUNCT,
+        /*  )   41  29 */   BOOST_CC_PUNCT,
+        /*  *   42  2a */   BOOST_CC_PUNCT,
+        /*  +   43  2b */   BOOST_CC_PUNCT,
+        /*  ,   44  2c */   BOOST_CC_PUNCT,
+        /*  -   45  2d */   BOOST_CC_PUNCT,
+        /*  .   46  2e */   BOOST_CC_PUNCT,
+        /*  /   47  2f */   BOOST_CC_PUNCT,
+        /*  0   48  30 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  1   49  31 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  2   50  32 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  3   51  33 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  4   52  34 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  5   53  35 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  6   54  36 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  7   55  37 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  8   56  38 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  9   57  39 */   BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
+        /*  :   58  3a */   BOOST_CC_PUNCT,
+        /*  ;   59  3b */   BOOST_CC_PUNCT,
+        /*  <   60  3c */   BOOST_CC_PUNCT,
+        /*  =   61  3d */   BOOST_CC_PUNCT,
+        /*  >   62  3e */   BOOST_CC_PUNCT,
+        /*  ?   63  3f */   BOOST_CC_PUNCT,
+        /*  @   64  40 */   BOOST_CC_PUNCT,
+        /*  A   65  41 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  B   66  42 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  C   67  43 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  D   68  44 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  E   69  45 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  F   70  46 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
+        /*  G   71  47 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  H   72  48 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  I   73  49 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  J   74  4a */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  K   75  4b */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  L   76  4c */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  M   77  4d */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  N   78  4e */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  O   79  4f */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  P   80  50 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Q   81  51 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  R   82  52 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  S   83  53 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  T   84  54 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  U   85  55 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  V   86  56 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  W   87  57 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  X   88  58 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Y   89  59 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  Z   90  5a */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  [   91  5b */   BOOST_CC_PUNCT,
+        /*  \   92  5c */   BOOST_CC_PUNCT,
+        /*  ]   93  5d */   BOOST_CC_PUNCT,
+        /*  ^   94  5e */   BOOST_CC_PUNCT,
+        /*  _   95  5f */   BOOST_CC_PUNCT,
+        /*  `   96  60 */   BOOST_CC_PUNCT,
+        /*  a   97  61 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  b   98  62 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  c   99  63 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  d  100  64 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  e  101  65 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  f  102  66 */   BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
+        /*  g  103  67 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  h  104  68 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  i  105  69 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  j  106  6a */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  k  107  6b */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  l  108  6c */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  m  109  6d */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  n  110  6e */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  o  111  6f */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  p  112  70 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  q  113  71 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  r  114  72 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  s  115  73 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  t  116  74 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  u  117  75 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  v  118  76 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  w  119  77 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  x  120  78 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  y  121  79 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  z  122  7a */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  {  123  7b */   BOOST_CC_PUNCT,
+        /*  |  124  7c */   BOOST_CC_PUNCT,
+        /*  }  125  7d */   BOOST_CC_PUNCT,
+        /*  ~  126  7e */   BOOST_CC_PUNCT,
+        /* DEL 127  7f */   BOOST_CC_CTRL,
+        /* --  128  80 */   BOOST_CC_CTRL,
+        /* --  129  81 */   BOOST_CC_CTRL,
+        /* --  130  82 */   BOOST_CC_CTRL,
+        /* --  131  83 */   BOOST_CC_CTRL,
+        /* --  132  84 */   BOOST_CC_CTRL,
+        /* --  133  85 */   BOOST_CC_CTRL,
+        /* --  134  86 */   BOOST_CC_CTRL,
+        /* --  135  87 */   BOOST_CC_CTRL,
+        /* --  136  88 */   BOOST_CC_CTRL,
+        /* --  137  89 */   BOOST_CC_CTRL,
+        /* --  138  8a */   BOOST_CC_CTRL,
+        /* --  139  8b */   BOOST_CC_CTRL,
+        /* --  140  8c */   BOOST_CC_CTRL,
+        /* --  141  8d */   BOOST_CC_CTRL,
+        /* --  142  8e */   BOOST_CC_CTRL,
+        /* --  143  8f */   BOOST_CC_CTRL,
+        /* --  144  90 */   BOOST_CC_CTRL,
+        /* --  145  91 */   BOOST_CC_CTRL,
+        /* --  146  92 */   BOOST_CC_CTRL,
+        /* --  147  93 */   BOOST_CC_CTRL,
+        /* --  148  94 */   BOOST_CC_CTRL,
+        /* --  149  95 */   BOOST_CC_CTRL,
+        /* --  150  96 */   BOOST_CC_CTRL,
+        /* --  151  97 */   BOOST_CC_CTRL,
+        /* --  152  98 */   BOOST_CC_CTRL,
+        /* --  153  99 */   BOOST_CC_CTRL,
+        /* --  154  9a */   BOOST_CC_CTRL,
+        /* --  155  9b */   BOOST_CC_CTRL,
+        /* --  156  9c */   BOOST_CC_CTRL,
+        /* --  157  9d */   BOOST_CC_CTRL,
+        /* --  158  9e */   BOOST_CC_CTRL,
+        /* --  159  9f */   BOOST_CC_CTRL,
+        /*     160  a0 */   BOOST_CC_SPACE,
+        /*  �  161  a1 */   BOOST_CC_PUNCT,
+        /*  �  162  a2 */   BOOST_CC_PUNCT,
+        /*  �  163  a3 */   BOOST_CC_PUNCT,
+        /*  �  164  a4 */   BOOST_CC_PUNCT,
+        /*  �  165  a5 */   BOOST_CC_PUNCT,
+        /*  �  166  a6 */   BOOST_CC_PUNCT,
+        /*  �  167  a7 */   BOOST_CC_PUNCT,
+        /*  �  168  a8 */   BOOST_CC_PUNCT,
+        /*  �  169  a9 */   BOOST_CC_PUNCT,
+        /*  �  170  aa */   BOOST_CC_PUNCT,
+        /*  �  171  ab */   BOOST_CC_PUNCT,
+        /*  �  172  ac */   BOOST_CC_PUNCT,
+        /*  �  173  ad */   BOOST_CC_PUNCT,
+        /*  �  174  ae */   BOOST_CC_PUNCT,
+        /*  �  175  af */   BOOST_CC_PUNCT,
+        /*  �  176  b0 */   BOOST_CC_PUNCT,
+        /*  �  177  b1 */   BOOST_CC_PUNCT,
+        /*  �  178  b2 */   BOOST_CC_DIGIT|BOOST_CC_PUNCT,
+        /*  �  179  b3 */   BOOST_CC_DIGIT|BOOST_CC_PUNCT,
+        /*  �  180  b4 */   BOOST_CC_PUNCT,
+        /*  �  181  b5 */   BOOST_CC_PUNCT,
+        /*  �  182  b6 */   BOOST_CC_PUNCT,
+        /*  �  183  b7 */   BOOST_CC_PUNCT,
+        /*  �  184  b8 */   BOOST_CC_PUNCT,
+        /*  �  185  b9 */   BOOST_CC_DIGIT|BOOST_CC_PUNCT,
+        /*  �  186  ba */   BOOST_CC_PUNCT,
+        /*  �  187  bb */   BOOST_CC_PUNCT,
+        /*  �  188  bc */   BOOST_CC_PUNCT,
+        /*  �  189  bd */   BOOST_CC_PUNCT,
+        /*  �  190  be */   BOOST_CC_PUNCT,
+        /*  �  191  bf */   BOOST_CC_PUNCT,
+        /*  �  192  c0 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  193  c1 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  194  c2 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  195  c3 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  196  c4 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  197  c5 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  198  c6 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  199  c7 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  200  c8 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  201  c9 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  202  ca */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  203  cb */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  204  cc */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  205  cd */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  206  ce */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  207  cf */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  208  d0 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  209  d1 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  210  d2 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  211  d3 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  212  d4 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  213  d5 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  214  d6 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  215  d7 */   BOOST_CC_PUNCT,
+        /*  �  216  d8 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  217  d9 */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  218  da */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  219  db */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  220  dc */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  221  dd */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  222  de */   BOOST_CC_ALPHA|BOOST_CC_UPPER,
+        /*  �  223  df */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  224  e0 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  225  e1 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  226  e2 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  227  e3 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  228  e4 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  229  e5 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  230  e6 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  231  e7 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  232  e8 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  233  e9 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  234  ea */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  235  eb */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  236  ec */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  237  ed */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  238  ee */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  239  ef */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  240  f0 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  241  f1 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  242  f2 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  243  f3 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  244  f4 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  245  f5 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  246  f6 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  247  f7 */   BOOST_CC_PUNCT,
+        /*  �  248  f8 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  249  f9 */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  250  fa */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  251  fb */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  252  fc */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  253  fd */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  254  fe */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+        /*  �  255  ff */   BOOST_CC_ALPHA|BOOST_CC_LOWER,
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ISO 8859-1 character conversion table
+    ///////////////////////////////////////////////////////////////////////////
+    const unsigned char iso8859_1_char_conversion[] =
+    {
+        /* NUL   0   0 */   '\0',
+        /* SOH   1   1 */   '\0',
+        /* STX   2   2 */   '\0',
+        /* ETX   3   3 */   '\0',
+        /* EOT   4   4 */   '\0',
+        /* ENQ   5   5 */   '\0',
+        /* ACK   6   6 */   '\0',
+        /* BEL   7   7 */   '\0',
+        /* BS    8   8 */   '\0',
+        /* HT    9   9 */   '\0',
+        /* NL   10   a */   '\0',
+        /* VT   11   b */   '\0',
+        /* NP   12   c */   '\0',
+        /* CR   13   d */   '\0',
+        /* SO   14   e */   '\0',
+        /* SI   15   f */   '\0',
+        /* DLE  16  10 */   '\0',
+        /* DC1  17  11 */   '\0',
+        /* DC2  18  12 */   '\0',
+        /* DC3  19  13 */   '\0',
+        /* DC4  20  14 */   '\0',
+        /* NAK  21  15 */   '\0',
+        /* SYN  22  16 */   '\0',
+        /* ETB  23  17 */   '\0',
+        /* CAN  24  18 */   '\0',
+        /* EM   25  19 */   '\0',
+        /* SUB  26  1a */   '\0',
+        /* ESC  27  1b */   '\0',
+        /* FS   28  1c */   '\0',
+        /* GS   29  1d */   '\0',
+        /* RS   30  1e */   '\0',
+        /* US   31  1f */   '\0',
+        /* SP   32  20 */   '\0',
+        /*  !   33  21 */   '\0',
+        /*  "   34  22 */   '\0',
+        /*  #   35  23 */   '\0',
+        /*  $   36  24 */   '\0',
+        /*  %   37  25 */   '\0',
+        /*  &   38  26 */   '\0',
+        /*  '   39  27 */   '\0',
+        /*  (   40  28 */   '\0',
+        /*  )   41  29 */   '\0',
+        /*  *   42  2a */   '\0',
+        /*  +   43  2b */   '\0',
+        /*  ,   44  2c */   '\0',
+        /*  -   45  2d */   '\0',
+        /*  .   46  2e */   '\0',
+        /*  /   47  2f */   '\0',
+        /*  0   48  30 */   '\0',
+        /*  1   49  31 */   '\0',
+        /*  2   50  32 */   '\0',
+        /*  3   51  33 */   '\0',
+        /*  4   52  34 */   '\0',
+        /*  5   53  35 */   '\0',
+        /*  6   54  36 */   '\0',
+        /*  7   55  37 */   '\0',
+        /*  8   56  38 */   '\0',
+        /*  9   57  39 */   '\0',
+        /*  :   58  3a */   '\0',
+        /*  ;   59  3b */   '\0',
+        /*  <   60  3c */   '\0',
+        /*  =   61  3d */   '\0',
+        /*  >   62  3e */   '\0',
+        /*  ?   63  3f */   '\0',
+        /*  @   64  40 */   '\0',
+        /*  A   65  41 */   'a',
+        /*  B   66  42 */   'b',
+        /*  C   67  43 */   'c',
+        /*  D   68  44 */   'd',
+        /*  E   69  45 */   'e',
+        /*  F   70  46 */   'f',
+        /*  G   71  47 */   'g',
+        /*  H   72  48 */   'h',
+        /*  I   73  49 */   'i',
+        /*  J   74  4a */   'j',
+        /*  K   75  4b */   'k',
+        /*  L   76  4c */   'l',
+        /*  M   77  4d */   'm',
+        /*  N   78  4e */   'n',
+        /*  O   79  4f */   'o',
+        /*  P   80  50 */   'p',
+        /*  Q   81  51 */   'q',
+        /*  R   82  52 */   'r',
+        /*  S   83  53 */   's',
+        /*  T   84  54 */   't',
+        /*  U   85  55 */   'u',
+        /*  V   86  56 */   'v',
+        /*  W   87  57 */   'w',
+        /*  X   88  58 */   'x',
+        /*  Y   89  59 */   'y',
+        /*  Z   90  5a */   'z',
+        /*  [   91  5b */   '\0',
+        /*  \   92  5c */   '\0',
+        /*  ]   93  5d */   '\0',
+        /*  ^   94  5e */   '\0',
+        /*  _   95  5f */   '\0',
+        /*  `   96  60 */   '\0',
+        /*  a   97  61 */   'A',
+        /*  b   98  62 */   'B',
+        /*  c   99  63 */   'C',
+        /*  d  100  64 */   'D',
+        /*  e  101  65 */   'E',
+        /*  f  102  66 */   'F',
+        /*  g  103  67 */   'G',
+        /*  h  104  68 */   'H',
+        /*  i  105  69 */   'I',
+        /*  j  106  6a */   'J',
+        /*  k  107  6b */   'K',
+        /*  l  108  6c */   'L',
+        /*  m  109  6d */   'M',
+        /*  n  110  6e */   'N',
+        /*  o  111  6f */   'O',
+        /*  p  112  70 */   'P',
+        /*  q  113  71 */   'Q',
+        /*  r  114  72 */   'R',
+        /*  s  115  73 */   'S',
+        /*  t  116  74 */   'T',
+        /*  u  117  75 */   'U',
+        /*  v  118  76 */   'V',
+        /*  w  119  77 */   'W',
+        /*  x  120  78 */   'X',
+        /*  y  121  79 */   'Y',
+        /*  z  122  7a */   'Z',
+        /*  {  123  7b */   '\0',
+        /*  |  124  7c */   '\0',
+        /*  }  125  7d */   '\0',
+        /*  ~  126  7e */   '\0',
+        /* DEL 127  7f */   '\0',
+        /* --  128  80 */   '\0',
+        /* --  129  81 */   '\0',
+        /* --  130  82 */   '\0',
+        /* --  131  83 */   '\0',
+        /* --  132  84 */   '\0',
+        /* --  133  85 */   '\0',
+        /* --  134  86 */   '\0',
+        /* --  135  87 */   '\0',
+        /* --  136  88 */   '\0',
+        /* --  137  89 */   '\0',
+        /* --  138  8a */   '\0',
+        /* --  139  8b */   '\0',
+        /* --  140  8c */   '\0',
+        /* --  141  8d */   '\0',
+        /* --  142  8e */   '\0',
+        /* --  143  8f */   '\0',
+        /* --  144  90 */   '\0',
+        /* --  145  91 */   '\0',
+        /* --  146  92 */   '\0',
+        /* --  147  93 */   '\0',
+        /* --  148  94 */   '\0',
+        /* --  149  95 */   '\0',
+        /* --  150  96 */   '\0',
+        /* --  151  97 */   '\0',
+        /* --  152  98 */   '\0',
+        /* --  153  99 */   '\0',
+        /* --  154  9a */   '\0',
+        /* --  155  9b */   '\0',
+        /* --  156  9c */   '\0',
+        /* --  157  9d */   '\0',
+        /* --  158  9e */   '\0',
+        /* --  159  9f */   '\0',
+        /*     160  a0 */   '\0',
+        /*  �  161  a1 */   '\0',
+        /*  �  162  a2 */   '\0',
+        /*  �  163  a3 */   '\0',
+        /*  �  164  a4 */   '\0',
+        /*  �  165  a5 */   '\0',
+        /*  �  166  a6 */   '\0',
+        /*  �  167  a7 */   '\0',
+        /*  �  168  a8 */   '\0',
+        /*  �  169  a9 */   '\0',
+        /*  �  170  aa */   '\0',
+        /*  �  171  ab */   '\0',
+        /*  �  172  ac */   '\0',
+        /*  �  173  ad */   '\0',
+        /*  �  174  ae */   '\0',
+        /*  �  175  af */   '\0',
+        /*  �  176  b0 */   '\0',
+        /*  �  177  b1 */   '\0',
+        /*  �  178  b2 */   '\0',
+        /*  �  179  b3 */   '\0',
+        /*  �  180  b4 */   '\0',
+        /*  �  181  b5 */   '\0',
+        /*  �  182  b6 */   '\0',
+        /*  �  183  b7 */   '\0',
+        /*  �  184  b8 */   '\0',
+        /*  �  185  b9 */   '\0',
+        /*  �  186  ba */   '\0',
+        /*  �  187  bb */   '\0',
+        /*  �  188  bc */   '\0',
+        /*  �  189  bd */   '\0',
+        /*  �  190  be */   '\0',
+        /*  �  191  bf */   '\0',
+        /*  �  192  c0 */   0xe0,
+        /*  �  193  c1 */   0xe1,
+        /*  �  194  c2 */   0xe2,
+        /*  �  195  c3 */   0xe3,
+        /*  �  196  c4 */   0xe4,
+        /*  �  197  c5 */   0xe5,
+        /*  �  198  c6 */   0xe6,
+        /*  �  199  c7 */   0xe7,
+        /*  �  200  c8 */   0xe8,
+        /*  �  201  c9 */   0xe9,
+        /*  �  202  ca */   0xea,
+        /*  �  203  cb */   0xeb,
+        /*  �  204  cc */   0xec,
+        /*  �  205  cd */   0xed,
+        /*  �  206  ce */   0xee,
+        /*  �  207  cf */   0xef,
+        /*  �  208  d0 */   0xf0,
+        /*  �  209  d1 */   0xf1,
+        /*  �  210  d2 */   0xf2,
+        /*  �  211  d3 */   0xf3,
+        /*  �  212  d4 */   0xf4,
+        /*  �  213  d5 */   0xf5,
+        /*  �  214  d6 */   0xf6,
+        /*  �  215  d7 */   '\0',
+        /*  �  216  d8 */   0xf8,
+        /*  �  217  d9 */   0xf9,
+        /*  �  218  da */   0xfa,
+        /*  �  219  db */   0xfb,
+        /*  �  220  dc */   0xfc,
+        /*  �  221  dd */   0xfd,
+        /*  �  222  de */   0xfe,
+        /*  �  223  df */   '\0',
+        /*  �  224  e0 */   0xc0,
+        /*  �  225  e1 */   0xc1,
+        /*  �  226  e2 */   0xc2,
+        /*  �  227  e3 */   0xc3,
+        /*  �  228  e4 */   0xc4,
+        /*  �  229  e5 */   0xc5,
+        /*  �  230  e6 */   0xc6,
+        /*  �  231  e7 */   0xc7,
+        /*  �  232  e8 */   0xc8,
+        /*  �  233  e9 */   0xc9,
+        /*  �  234  ea */   0xca,
+        /*  �  235  eb */   0xcb,
+        /*  �  236  ec */   0xcc,
+        /*  �  237  ed */   0xcd,
+        /*  �  238  ee */   0xce,
+        /*  �  239  ef */   0xcf,
+        /*  �  240  f0 */   0xd0,
+        /*  �  241  f1 */   0xd1,
+        /*  �  242  f2 */   0xd2,
+        /*  �  243  f3 */   0xd3,
+        /*  �  244  f4 */   0xd4,
+        /*  �  245  f5 */   0xd5,
+        /*  �  246  f6 */   0xd6,
+        /*  �  247  f7 */   '\0',
+        /*  �  248  f8 */   0xd8,
+        /*  �  249  f9 */   0xd9,
+        /*  �  250  fa */   0xda,
+        /*  �  251  fb */   0xdb,
+        /*  �  252  fc */   0xdc,
+        /*  �  253  fd */   0xdd,
+        /*  �  254  fe */   0xde,
+        /*  �  255  ff */   '\0',
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Test characters for specified conditions (using iso8859-1)
+    ///////////////////////////////////////////////////////////////////////////
+    struct iso8859_1
+    {
+        typedef unsigned char char_type;
+
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+
+        static bool
+        ischar(int ch)
+        {
+            // iso8859.1 uses all 8 bits
+            // we have to watch out for sign extensions
+            return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false;
+        }
+
+        static int
+        isalnum(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_ALPHA)
+                || (iso8859_1_char_types[ch] & BOOST_CC_DIGIT);
+        }
+
+        static int
+        isalpha(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_ALPHA);
+        }
+
+        static int
+        isdigit(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_DIGIT);
+        }
+
+        static int
+        isxdigit(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_XDIGIT);
+        }
+
+        static int
+        iscntrl(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_CTRL);
+        }
+
+        static int
+        isgraph(int ch)
+        {
+            return ('\x21' <= ch && ch <= '\x7e') || ('\xa1' <= ch && ch <= '\xff');
+        }
+
+        static int
+        islower(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_LOWER);
+        }
+
+        static int
+        isprint(int ch)
+        {
+            return ('\x20' <= ch && ch <= '\x7e') || ('\xa0' <= ch && ch <= '\xff');
+        }
+
+        static int
+        ispunct(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_PUNCT);
+        }
+
+        static int
+        isspace(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_SPACE);
+        }
+
+        static int
+        isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch)
+        {
+            return ('\x09' == ch || '\x20' == ch || '\xa0' == ch);
+        }
+
+        static int
+        isupper(int ch)
+        {
+            BOOST_ASSERT(0 == (ch & ~UCHAR_MAX));
+            return (iso8859_1_char_types[ch] & BOOST_CC_UPPER);
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Simple character conversions
+    ///////////////////////////////////////////////////////////////////////////
+
+        static int
+        tolower(int ch)
+        {
+            return isupper(ch) && '\0' != iso8859_1_char_conversion[ch] ?
+                iso8859_1_char_conversion[ch] : ch;
+        }
+
+        static int
+        toupper(int ch)
+        {
+            return islower(ch) && '\0' != iso8859_1_char_conversion[ch] ?
+                iso8859_1_char_conversion[ch] : ch;
+        }
+
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            // The first 256 characters in Unicode and the UCS are
+            // identical to those in ISO/IEC-8859-1.
+            return ch;
+        }
+    };
+
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+// undefine macros
+///////////////////////////////////////////////////////////////////////////////
+#undef BOOST_CC_DIGIT
+#undef BOOST_CC_XDIGIT
+#undef BOOST_CC_ALPHA
+#undef BOOST_CC_CTRL
+#undef BOOST_CC_LOWER
+#undef BOOST_CC_UPPER
+#undef BOOST_CC_PUNCT
+#undef BOOST_CC_SPACE
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp
new file mode 100644
index 0000000..c32a9e7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp
@@ -0,0 +1,137 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_STANDARD_APRIL_26_2006_1106PM)
+#define BOOST_SPIRIT_STANDARD_APRIL_26_2006_1106PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <cctype>
+#include <boost/cstdint.hpp>
+
+namespace boost { namespace spirit { namespace char_encoding
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Test characters for specified conditions (using std functions)
+    ///////////////////////////////////////////////////////////////////////////
+    struct standard
+    {
+        typedef char char_type;
+
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+
+        static bool
+        ischar(int ch)
+        {
+            // uses all 8 bits
+            // we have to watch out for sign extensions
+            return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false;
+        }
+
+        static int
+        isalnum(int ch)
+        {
+            return std::isalnum(ch);
+        }
+
+        static int
+        isalpha(int ch)
+        {
+            return std::isalpha(ch);
+        }
+
+        static int
+        isdigit(int ch)
+        {
+            return std::isdigit(ch);
+        }
+
+        static int
+        isxdigit(int ch)
+        {
+            return std::isxdigit(ch);
+        }
+
+        static int
+        iscntrl(int ch)
+        {
+            return std::iscntrl(ch);
+        }
+
+        static int
+        isgraph(int ch)
+        {
+            return std::isgraph(ch);
+        }
+
+        static int
+        islower(int ch)
+        {
+            return std::islower(ch);
+        }
+
+        static int
+        isprint(int ch)
+        {
+            return std::isprint(ch);
+        }
+
+        static int
+        ispunct(int ch)
+        {
+            return std::ispunct(ch);
+        }
+
+        static int
+        isspace(int ch)
+        {
+            return std::isspace(ch);
+        }
+
+        static int
+        isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch)
+        {
+            return (ch == ' ' || ch == '\t');
+        }
+
+        static int
+        isupper(int ch)
+        {
+            return std::isupper(ch);
+        }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Simple character conversions
+    ///////////////////////////////////////////////////////////////////////////////
+        static int
+        tolower(int ch)
+        {
+            return std::tolower(ch);
+        }
+
+        static int
+        toupper(int ch)
+        {
+            return std::toupper(ch);
+        }
+
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp
new file mode 100644
index 0000000..99c918c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp
@@ -0,0 +1,182 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_STANDARD_WIDE_NOVEMBER_10_2006_0913AM)
+#define BOOST_SPIRIT_STANDARD_WIDE_NOVEMBER_10_2006_0913AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <cwctype>
+#include <string>
+
+#include <boost/cstdint.hpp>
+#include <boost/spirit/home/support/assert_msg.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    template <std::size_t N>
+    struct wchar_t_size
+    {
+        BOOST_SPIRIT_ASSERT_MSG(N == 1 || N == 2 || N == 4,
+            not_supported_size_of_wchar_t, ());
+    };
+
+    template <> struct wchar_t_size<1> { enum { mask = 0xff }; };
+    template <> struct wchar_t_size<2> { enum { mask = 0xffff }; };
+    template <> struct wchar_t_size<4> { enum { mask = 0xffffffff }; };
+
+}}}
+
+namespace boost { namespace spirit { namespace char_encoding
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Test characters for specified conditions (using std wchar_t functions)
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct standard_wide
+    {
+        typedef wchar_t char_type;
+
+        template <typename Char>
+        static typename std::char_traits<Char>::int_type
+        to_int_type(Char ch)
+        {
+            return std::char_traits<Char>::to_int_type(ch);
+        }
+
+        template <typename Char>
+        static Char
+        to_char_type(typename std::char_traits<Char>::int_type ch)
+        {
+            return std::char_traits<Char>::to_char_type(ch);
+        }
+
+        static bool
+        ischar(int ch)
+        {
+            // we have to watch out for sign extensions (casting is there to 
+            // silence certain compilers complaining about signed/unsigned
+            // mismatch)
+            return (
+                std::size_t(0) == 
+                    std::size_t(ch & ~traits::wchar_t_size<sizeof(wchar_t)>::mask) || 
+                std::size_t(~0) == 
+                    std::size_t(ch | traits::wchar_t_size<sizeof(wchar_t)>::mask)
+            ) ? true : false;     // any wchar_t, but no other bits set
+        }
+
+        static bool
+        isalnum(wchar_t ch)
+        {
+            using namespace std;
+            return iswalnum(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isalpha(wchar_t ch)
+        {
+            using namespace std;
+            return iswalpha(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        iscntrl(wchar_t ch)
+        {
+            using namespace std;
+            return iswcntrl(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isdigit(wchar_t ch)
+        {
+            using namespace std;
+            return iswdigit(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isgraph(wchar_t ch)
+        {
+            using namespace std;
+            return iswgraph(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        islower(wchar_t ch)
+        {
+            using namespace std;
+            return iswlower(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isprint(wchar_t ch)
+        {
+            using namespace std;
+            return iswprint(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        ispunct(wchar_t ch)
+        {
+            using namespace std;
+            return iswpunct(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isspace(wchar_t ch)
+        {
+            using namespace std;
+            return iswspace(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isupper(wchar_t ch)
+        {
+            using namespace std;
+            return iswupper(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isxdigit(wchar_t ch)
+        {
+            using namespace std;
+            return iswxdigit(to_int_type(ch)) ? true : false;
+        }
+
+        static bool
+        isblank BOOST_PREVENT_MACRO_SUBSTITUTION (wchar_t ch)
+        {
+            return (ch == L' ' || ch == L'\t');
+        }
+
+        static wchar_t
+        tolower(wchar_t ch)
+        {
+            using namespace std;
+            return isupper(ch) ?
+                to_char_type<wchar_t>(towlower(to_int_type(ch))) : ch;
+        }
+
+        static wchar_t
+        toupper(wchar_t ch)
+        {
+            using namespace std;
+            return islower(ch) ?
+                to_char_type<wchar_t>(towupper(to_int_type(ch))) : ch;
+        }
+
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp
new file mode 100644
index 0000000..9febf7e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp
@@ -0,0 +1,339 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_UNICODE_1_JANUARY_12_2010_0728PM)
+#define BOOST_SPIRIT_UNICODE_1_JANUARY_12_2010_0728PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/spirit/home/support/char_encoding/unicode/query.hpp>
+
+namespace boost { namespace spirit { namespace char_encoding
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Test characters for specified conditions (using iso8859-1)
+    ///////////////////////////////////////////////////////////////////////////
+    struct unicode
+    {
+        typedef ::boost::uint32_t char_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Posix stuff
+    ///////////////////////////////////////////////////////////////////////////
+        static bool
+        isascii_(char_type ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+
+        static bool
+        ischar(char_type ch)
+        {
+            // unicode code points in the range 0x00 to 0x10FFFF
+            return ch <= 0x10FFFF;
+        }
+
+        static bool
+        isalnum(char_type ch)
+        {
+            return ucd::is_alphanumeric(ch);
+        }
+
+        static bool
+        isalpha(char_type ch)
+        {
+            return ucd::is_alphabetic(ch);
+        }
+
+        static bool
+        isdigit(char_type ch)
+        {
+            return ucd::is_decimal_number(ch);
+        }
+
+        static bool
+        isxdigit(char_type ch)
+        {
+            return ucd::is_hex_digit(ch);
+        }
+
+        static bool
+        iscntrl(char_type ch)
+        {
+            return ucd::is_control(ch);
+        }
+
+        static bool
+        isgraph(char_type ch)
+        {
+            return ucd::is_graph(ch);
+        }
+
+        static bool
+        islower(char_type ch)
+        {
+            return ucd::is_lowercase(ch);
+        }
+
+        static bool
+        isprint(char_type ch)
+        {
+            return ucd::is_print(ch);
+        }
+
+        static bool
+        ispunct(char_type ch)
+        {
+            return ucd::is_punctuation(ch);
+        }
+
+        static bool
+        isspace(char_type ch)
+        {
+            return ucd::is_white_space(ch);
+        }
+
+        static int
+        isblank BOOST_PREVENT_MACRO_SUBSTITUTION (char_type ch)
+        {
+            return ucd::is_blank(ch);
+        }
+
+        static bool
+        isupper(char_type ch)
+        {
+            return ucd::is_uppercase(ch);
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Simple character conversions
+    ///////////////////////////////////////////////////////////////////////////
+
+        static char_type
+        tolower(char_type ch)
+        {
+            return ucd::to_lowercase(ch);
+        }
+
+        static char_type
+        toupper(char_type ch)
+        {
+            return ucd::to_uppercase(ch);
+        }
+
+        static ::boost::uint32_t
+        toucs4(char_type ch)
+        {
+            return ch;
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Major Categories
+    ///////////////////////////////////////////////////////////////////////////
+#define BOOST_SPIRIT_MAJOR_CATEGORY(name)                                       \
+        static bool                                                             \
+        is_##name(char_type ch)                                                 \
+        {                                                                       \
+            return ucd::get_major_category(ch) == ucd::properties::name;        \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_MAJOR_CATEGORY(letter)
+        BOOST_SPIRIT_MAJOR_CATEGORY(mark)
+        BOOST_SPIRIT_MAJOR_CATEGORY(number)
+        BOOST_SPIRIT_MAJOR_CATEGORY(separator)
+        BOOST_SPIRIT_MAJOR_CATEGORY(other)
+        BOOST_SPIRIT_MAJOR_CATEGORY(punctuation)
+        BOOST_SPIRIT_MAJOR_CATEGORY(symbol)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  General Categories
+    ///////////////////////////////////////////////////////////////////////////
+#define BOOST_SPIRIT_CATEGORY(name)                                             \
+        static bool                                                             \
+        is_##name(char_type ch)                                                 \
+        {                                                                       \
+            return ucd::get_category(ch) == ucd::properties::name;              \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_CATEGORY(uppercase_letter)
+        BOOST_SPIRIT_CATEGORY(lowercase_letter)
+        BOOST_SPIRIT_CATEGORY(titlecase_letter)
+        BOOST_SPIRIT_CATEGORY(modifier_letter)
+        BOOST_SPIRIT_CATEGORY(other_letter)
+
+        BOOST_SPIRIT_CATEGORY(nonspacing_mark)
+        BOOST_SPIRIT_CATEGORY(enclosing_mark)
+        BOOST_SPIRIT_CATEGORY(spacing_mark)
+
+        BOOST_SPIRIT_CATEGORY(decimal_number)
+        BOOST_SPIRIT_CATEGORY(letter_number)
+        BOOST_SPIRIT_CATEGORY(other_number)
+
+        BOOST_SPIRIT_CATEGORY(space_separator)
+        BOOST_SPIRIT_CATEGORY(line_separator)
+        BOOST_SPIRIT_CATEGORY(paragraph_separator)
+
+        BOOST_SPIRIT_CATEGORY(control)
+        BOOST_SPIRIT_CATEGORY(format)
+        BOOST_SPIRIT_CATEGORY(private_use)
+        BOOST_SPIRIT_CATEGORY(surrogate)
+        BOOST_SPIRIT_CATEGORY(unassigned)
+
+        BOOST_SPIRIT_CATEGORY(dash_punctuation)
+        BOOST_SPIRIT_CATEGORY(open_punctuation)
+        BOOST_SPIRIT_CATEGORY(close_punctuation)
+        BOOST_SPIRIT_CATEGORY(connector_punctuation)
+        BOOST_SPIRIT_CATEGORY(other_punctuation)
+        BOOST_SPIRIT_CATEGORY(initial_punctuation)
+        BOOST_SPIRIT_CATEGORY(final_punctuation)
+
+        BOOST_SPIRIT_CATEGORY(math_symbol)
+        BOOST_SPIRIT_CATEGORY(currency_symbol)
+        BOOST_SPIRIT_CATEGORY(modifier_symbol)
+        BOOST_SPIRIT_CATEGORY(other_symbol)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Derived Categories
+    ///////////////////////////////////////////////////////////////////////////
+#define BOOST_SPIRIT_DERIVED_CATEGORY(name)                                     \
+        static bool                                                             \
+        is_##name(char_type ch)                                                 \
+        {                                                                       \
+            return ucd::is_##name(ch);                                          \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_DERIVED_CATEGORY(alphabetic)
+        BOOST_SPIRIT_DERIVED_CATEGORY(uppercase)
+        BOOST_SPIRIT_DERIVED_CATEGORY(lowercase)
+        BOOST_SPIRIT_DERIVED_CATEGORY(white_space)
+        BOOST_SPIRIT_DERIVED_CATEGORY(hex_digit)
+        BOOST_SPIRIT_DERIVED_CATEGORY(noncharacter_code_point)
+        BOOST_SPIRIT_DERIVED_CATEGORY(default_ignorable_code_point)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Scripts
+    ///////////////////////////////////////////////////////////////////////////
+#define BOOST_SPIRIT_SCRIPT(name)                                               \
+        static bool                                                             \
+        is_##name(char_type ch)                                                 \
+        {                                                                       \
+            return ucd::get_script(ch) == ucd::properties::name;                \
+        }                                                                       \
+        /***/
+
+        BOOST_SPIRIT_SCRIPT(arabic)
+        BOOST_SPIRIT_SCRIPT(imperial_aramaic)
+        BOOST_SPIRIT_SCRIPT(armenian)
+        BOOST_SPIRIT_SCRIPT(avestan)
+        BOOST_SPIRIT_SCRIPT(balinese)
+        BOOST_SPIRIT_SCRIPT(bamum)
+        BOOST_SPIRIT_SCRIPT(bengali)
+        BOOST_SPIRIT_SCRIPT(bopomofo)
+        BOOST_SPIRIT_SCRIPT(braille)
+        BOOST_SPIRIT_SCRIPT(buginese)
+        BOOST_SPIRIT_SCRIPT(buhid)
+        BOOST_SPIRIT_SCRIPT(canadian_aboriginal)
+        BOOST_SPIRIT_SCRIPT(carian)
+        BOOST_SPIRIT_SCRIPT(cham)
+        BOOST_SPIRIT_SCRIPT(cherokee)
+        BOOST_SPIRIT_SCRIPT(coptic)
+        BOOST_SPIRIT_SCRIPT(cypriot)
+        BOOST_SPIRIT_SCRIPT(cyrillic)
+        BOOST_SPIRIT_SCRIPT(devanagari)
+        BOOST_SPIRIT_SCRIPT(deseret)
+        BOOST_SPIRIT_SCRIPT(egyptian_hieroglyphs)
+        BOOST_SPIRIT_SCRIPT(ethiopic)
+        BOOST_SPIRIT_SCRIPT(georgian)
+        BOOST_SPIRIT_SCRIPT(glagolitic)
+        BOOST_SPIRIT_SCRIPT(gothic)
+        BOOST_SPIRIT_SCRIPT(greek)
+        BOOST_SPIRIT_SCRIPT(gujarati)
+        BOOST_SPIRIT_SCRIPT(gurmukhi)
+        BOOST_SPIRIT_SCRIPT(hangul)
+        BOOST_SPIRIT_SCRIPT(han)
+        BOOST_SPIRIT_SCRIPT(hanunoo)
+        BOOST_SPIRIT_SCRIPT(hebrew)
+        BOOST_SPIRIT_SCRIPT(hiragana)
+        BOOST_SPIRIT_SCRIPT(katakana_or_hiragana)
+        BOOST_SPIRIT_SCRIPT(old_italic)
+        BOOST_SPIRIT_SCRIPT(javanese)
+        BOOST_SPIRIT_SCRIPT(kayah_li)
+        BOOST_SPIRIT_SCRIPT(katakana)
+        BOOST_SPIRIT_SCRIPT(kharoshthi)
+        BOOST_SPIRIT_SCRIPT(khmer)
+        BOOST_SPIRIT_SCRIPT(kannada)
+        BOOST_SPIRIT_SCRIPT(kaithi)
+        BOOST_SPIRIT_SCRIPT(tai_tham)
+        BOOST_SPIRIT_SCRIPT(lao)
+        BOOST_SPIRIT_SCRIPT(latin)
+        BOOST_SPIRIT_SCRIPT(lepcha)
+        BOOST_SPIRIT_SCRIPT(limbu)
+        BOOST_SPIRIT_SCRIPT(linear_b)
+        BOOST_SPIRIT_SCRIPT(lisu)
+        BOOST_SPIRIT_SCRIPT(lycian)
+        BOOST_SPIRIT_SCRIPT(lydian)
+        BOOST_SPIRIT_SCRIPT(malayalam)
+        BOOST_SPIRIT_SCRIPT(mongolian)
+        BOOST_SPIRIT_SCRIPT(meetei_mayek)
+        BOOST_SPIRIT_SCRIPT(myanmar)
+        BOOST_SPIRIT_SCRIPT(nko)
+        BOOST_SPIRIT_SCRIPT(ogham)
+        BOOST_SPIRIT_SCRIPT(ol_chiki)
+        BOOST_SPIRIT_SCRIPT(old_turkic)
+        BOOST_SPIRIT_SCRIPT(oriya)
+        BOOST_SPIRIT_SCRIPT(osmanya)
+        BOOST_SPIRIT_SCRIPT(phags_pa)
+        BOOST_SPIRIT_SCRIPT(inscriptional_pahlavi)
+        BOOST_SPIRIT_SCRIPT(phoenician)
+        BOOST_SPIRIT_SCRIPT(inscriptional_parthian)
+        BOOST_SPIRIT_SCRIPT(rejang)
+        BOOST_SPIRIT_SCRIPT(runic)
+        BOOST_SPIRIT_SCRIPT(samaritan)
+        BOOST_SPIRIT_SCRIPT(old_south_arabian)
+        BOOST_SPIRIT_SCRIPT(saurashtra)
+        BOOST_SPIRIT_SCRIPT(shavian)
+        BOOST_SPIRIT_SCRIPT(sinhala)
+        BOOST_SPIRIT_SCRIPT(sundanese)
+        BOOST_SPIRIT_SCRIPT(syloti_nagri)
+        BOOST_SPIRIT_SCRIPT(syriac)
+        BOOST_SPIRIT_SCRIPT(tagbanwa)
+        BOOST_SPIRIT_SCRIPT(tai_le)
+        BOOST_SPIRIT_SCRIPT(new_tai_lue)
+        BOOST_SPIRIT_SCRIPT(tamil)
+        BOOST_SPIRIT_SCRIPT(tai_viet)
+        BOOST_SPIRIT_SCRIPT(telugu)
+        BOOST_SPIRIT_SCRIPT(tifinagh)
+        BOOST_SPIRIT_SCRIPT(tagalog)
+        BOOST_SPIRIT_SCRIPT(thaana)
+        BOOST_SPIRIT_SCRIPT(thai)
+        BOOST_SPIRIT_SCRIPT(tibetan)
+        BOOST_SPIRIT_SCRIPT(ugaritic)
+        BOOST_SPIRIT_SCRIPT(vai)
+        BOOST_SPIRIT_SCRIPT(old_persian)
+        BOOST_SPIRIT_SCRIPT(cuneiform)
+        BOOST_SPIRIT_SCRIPT(yi)
+        BOOST_SPIRIT_SCRIPT(inherited)
+        BOOST_SPIRIT_SCRIPT(common)
+        BOOST_SPIRIT_SCRIPT(unknown)
+
+#undef BOOST_SPIRIT_MAJOR_CATEGORY
+#undef BOOST_SPIRIT_CATEGORY
+#undef BOOST_SPIRIT_DERIVED_CATEGORY
+#undef BOOST_SPIRIT_SCRIPT
+
+    };
+
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/category_table.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/category_table.hpp
new file mode 100644
index 0000000..1b262a1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/category_table.hpp
@@ -0,0 +1,2216 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    AUTOGENERATED. DO NOT EDIT!!!
+==============================================================================*/
+#include <boost/cstdint.hpp>
+
+namespace boost { namespace spirit { namespace ucd { namespace detail
+{
+    static const ::boost::uint8_t category_stage1[] = {
+
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15, 
+     16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31, 
+     32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  34,  42,  43,  44,  45,  46, 
+     47,  48,  49,  40,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  50,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  51, 
+     52,  21,  21,  21,  53,  21,  54,  55,  56,  57,  58,  59,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  60,  61,  61,  61,  61,  61,  61,  61,  61, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  21,  63,  64,  21,  65,  66,  67, 
+     68,  69,  70,  71,  72,  73,  73,  73,  74,  75,  76,  77,  78,  73,  73,  73, 
+     79,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     21,  21,  21,  80,  81,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     82,  82,  82,  82,  83,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     84,  85,  86,  87,  88,  89,  90,  91,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     92,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  94,  82,  82,  82,  82,  82,  82,  82,  82,  82, 
+     82,  82,  82,  82,  82,  82,  82,  95,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  21,  21,  96,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     97,  98,  99,  99,  99,  99,  99,  99,  99,  99,  99,  99,  99,  99,  99,  99, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  93, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 100, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 100
+    };
+
+    static const ::boost::uint16_t category_stage2[] = {
+
+    // block 0
+      32,   32,   32,   32,   32,   32,   32,   32,   32,  544,  544,  544,  544,  544,   32,   32, 
+      32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32, 
+     536,   44,   44,   44,   49,   44,   44,   44,   41,   42,   44,   48,   44,   40,   44,   44, 
+    1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040,   44,   44,   48,   48,   48,   44, 
+      44, 1216, 1216, 1216, 1216, 1216, 1216,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,   41,   44,   42,   50,   43, 
+      50, 1345, 1345, 1345, 1345, 1345, 1345,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,   41,   48,   42,   48,   32, 
+      32,   32,   32,   32,   32,  544,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32, 
+      32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32,   32, 
+     536,   44,   49,   49,   49,   49,   51,   51,   50,   51,  321,   45,   48, 4129,   51,   50, 
+      51,   48,   18,   18,   50,  321,   51,   44,   50,   18,  321,   46,   18,   18,   18,   44, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,   48,  192,  192,  192,  192,  192,  192,  192,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,   48,  321,  321,  321,  321,  321,  321,  321,  321, 
+
+
+    // block 1
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  321,  192,  321,  192,  321,  192,  321,  192, 
+     321,  192,  321,  192,  321,  192,  321,  192,  321,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  192,  321,  192,  321,  192,  321,  321, 
+     321,  192,  192,  321,  192,  321,  192,  192,  321,  192,  192,  192,  321,  321,  192,  192, 
+     192,  192,  321,  192,  192,  321,  192,  192,  192,  321,  321,  321,  192,  192,  321,  192, 
+     192,  321,  192,  321,  192,  321,  192,  192,  321,  192,  321,  321,  192,  321,  192,  192, 
+     321,  192,  192,  192,  321,  192,  321,  192,  192,  321,  321,   68,  192,  321,  321,  321, 
+      68,   68,   68,   68,  192,   66,  321,  192,   66,  321,  192,   66,  321,  192,  321,  192, 
+     321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     321,  192,   66,  321,  192,  321,  192,  192,  192,  321,  192,  321,  192,  321,  192,  321, 
+
+
+    // block 2
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  321,  321,  321,  321,  321,  321,  192,  192,  321,  192,  192,  321, 
+     321,  192,  321,  192,  192,  192,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,   68,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,   67,   67,   67,   67,   67,   67,   67, 
+     323,  323,   50,   50,   50,   50,   67,   67,   67,   67,   67,   67,   67,   67,   67,   67, 
+      67,   67,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50, 
+     323,  323,  323,  323,  323,   50,   50,   50,   50,   50,   50,   50,   67,   50,   67,   50, 
+      50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50, 
+
+
+    // block 3
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,  328,    8,    8,    8,    8,    8,    8,    8,    8,    8, 4104, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+     192,  321,  192,  321,   67,   50,  192,  321,    0,    0,  323,  321,  321,  321,   44,    0, 
+       0,    0,    0,    0,   50,   50,  192,   44,  192,  192,  192,    0,  192,    0,  192,  192, 
+     321,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,    0,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  192, 
+     321,  321,  192,  192,  192,  321,  321,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     321,  321,  321,  321,  192,  321,   48,  192,  321,  192,  192,  321,  321,  192,  192,  192, 
+
+
+    // block 4
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,   51,    8,    8,    8,    8,    8,    9,    9,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+
+
+    // block 5
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  320,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,    0,    0,   67,   44,   44,   44,   44,   44,   44, 
+       0,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,    0,   44,   40,    0,    0,    0,    0,    0, 
+       0,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   40,   72, 
+      44,   72,   72,   44,   72,   72,   44,   72,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0, 
+      68,   68,   68,   44,   44,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 6
+      33,   33,   33,   33,    0,    0,   48,   48,   48,   44,   44,   49,   44,   44,   51,   51, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   44,    0,    0,   44,   44, 
+       0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      67,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   72,   72,   72,   72,   72, 
+      72,   72,   72,   72,   72,   72,   72,   72,    8,   72,   72,   72,   72,   72,   72,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   44,   44,   44,   44,   68,   68, 
+      72,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   44,   68,   72,   72,   72,   72,   72,   72,   72,   33,    9,    8, 
+       8,   72,   72,   72,   72,   67,   67,   72,   72,   51,    8,    8,    8,   72,   68,   68, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   68,   68,   68,   51,   51,   68, 
+
+
+    // block 7
+      44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,    0,   33, 
+      68,   72,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    0,    0,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+      72,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,   67,   67,   51,   44,   44,   44,   67,    0,    0,    0,    0,    0, 
+
+
+    // block 8
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,    0,    0,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 9
+      64,   72,   72,   74,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    8,   68,   74,   74, 
+      74,   72,   72,   72,   72,   72,   72,   72,   72,   74,   74,   74,   74,    8,   64,    0, 
+      68,    8,    8,    8,    8,   64,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   72,   72,   44,   44,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      44,   67,   68,    0,    0,    0,    0,    0,    0,   64,   64,   68,   68,   68,   68,   68, 
+       0,   72,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,   68, 
+      68,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,    0,    0,    0,   68,   68,   68,   68,    0,    0,    8,   68,   74,   74, 
+      74,   72,   72,   72,   72,    0,    0,   74,   74,    0,    0,   74,   74,    8,   68,    0, 
+       0,    0,    0,    0,    0,    0,    0,   74,    0,    0,    0,    0,   68,   68,    0,   68, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      68,   68,   49,   49,   18,   18,   18,   18,   18,   18,   51,    0,    0,    0,    0,    0, 
+
+
+    // block 10
+       0,   72,   72,   74,    0,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,   68, 
+      68,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,   68,    0,   68,   68,    0,   68,   68,    0,    0,    8,    0,   74,   74, 
+      74,   72,   72,    0,    0,    0,    0,   72,   72,    0,    0,   72,   72,    8,    0,    0, 
+       0,   72,    0,    0,    0,    0,    0,    0,    0,   68,   68,   68,   68,    0,   68,    0, 
+       0,    0,    0,    0,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      72,   72,   68,   68,   68,   72,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,   72,   72,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68, 
+      68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,   68,    0,   68,   68,   68,   68,   68,    0,    0,    8,   68,   74,   74, 
+      74,   72,   72,   72,   72,   72,    0,   72,   72,   74,    0,   74,   74,    8,    0,    0, 
+      68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+       0,   49,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 11
+       0,   72,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,   68, 
+      68,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,   68,    0,   68,   68,   68,   68,   68,    0,    0,    8,   68,   74,   72, 
+      74,   72,   72,   72,   72,    0,    0,   74,   74,    0,    0,   74,   74,    8,    0,    0, 
+       0,    0,    0,    0,    0,    0,   72,   74,    0,    0,    0,    0,   68,   68,    0,   68, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      51,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,   72,   68,    0,   68,   68,   68,   68,   68,   68,    0,    0,    0,   68,   68, 
+      68,    0,   68,   68,   68,   68,    0,    0,    0,   68,   68,    0,   68,    0,   68,   68, 
+       0,    0,    0,   68,   68,    0,    0,    0,   68,   68,   68,    0,    0,    0,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,   74,   74, 
+      72,   74,   74,    0,    0,    0,   74,   74,   74,    0,   74,   74,   74,    8,    0,    0, 
+      68,    0,    0,    0,    0,    0,    0,   74,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      18,   18,   18,   51,   51,   51,   51,   51,   51,   49,   51,    0,    0,    0,    0,    0, 
+
+
+    // block 12
+       0,   74,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68, 
+      68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    0,   68,   68,   68,   68,   68,    0,    0,    0,   68,   72,   72, 
+      72,   74,   74,   74,   74,    0,   72,   72,   72,    0,   72,   72,   72,    8,    0,    0, 
+       0,    0,    0,    0,    0,   72,   72,    0,   68,   68,    0,    0,    0,    0,    0,    0, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+       0,    0,    0,    0,    0,    0,    0,    0,   18,   18,   18,   18,   18,   18,   18,   51, 
+       0,    0,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68, 
+      68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    0,   68,   68,   68,   68,   68,    0,    0,    8,   68,   74,   72, 
+      74,   74,   74,   74,   74,    0,   72,   74,   74,    0,   74,   74,   72,    8,    0,    0, 
+       0,    0,    0,    0,    0,   74,   74,    0,    0,    0,    0,    0,    0,    0,   68,    0, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+       0,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 13
+       0,    0,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68, 
+      68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,   68,   74,   74, 
+      74,   72,   72,   72,   72,    0,   74,   74,   74,    0,   74,   74,   74,    8,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,   74,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   72,   72,    0,    0,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      18,   18,   18,   18,   18,   18,    0,    0,    0,   51,   68,   68,   68,   68,   68,   68, 
+       0,    0,   74,   74,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,    0,    0,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    8,    0,    0,    0,    0,   74, 
+      74,   74,   72,   72,   72,    0,   72,    0,   74,   74,   74,   74,   74,   74,   74,   74, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,   74,   74,   44,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 14
+       0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   72,   68,   68,   72,   72,   72,   72,   72,   72,   72,    0,    0,    0,    0,   49, 
+      68,   68,   68,   68,   68,   68,   67,    8,    8,    8,    8,    8,    8,   72,    8,   44, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   44,   44,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,   68,   68,    0,   68,    0,    0,   68,   68,    0,   68,    0,    0,   68,    0,    0, 
+       0,    0,    0,    0,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68, 
+       0,   68,   68,   68,    0,   68,    0,   68,    0,    0,   68,   68,    0,   68,   68,   68, 
+      68,   72,   68,   68,   72,   72,   72,   72,   72,   72,    0,   72,   72,   68,    0,    0, 
+      68,   68,   68,   68,   68,    0,   67,    0,    8,    8,    8,    8,    8,   72,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,   68,   68,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 15
+      68,   51,   51,   51,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44, 
+      44,   44,   44,   51,   51,   51,   51,   51,    8,    8,   51,   51,   51,   51,   51,   51, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   51,    8,   51,    8,   51,    8,   41,   42,   41,   42,   10,   10, 
+      68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0, 
+       0,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   74, 
+      72,   72,    8,    8,    8,   44,    8,    8,   68,   68,   68,   68,    0,    0,    0,    0, 
+      72,   72,   72,   72,   72,   72,   72,   72,    0,   72,   72,   72,   72,   72,   72,   72, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,    0,   51,   51, 
+      51,   51,   51,   51,   51,   51,    8,   51,   51,   51,   51,   51,   51,    0,   51,   51, 
+      44,   44,   44,   44,   44,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 16
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   74,   74,   72,   72,   72, 
+      72,   74,   72,   72,   72,   72,   72,    8,   74,    8,    8,   74,   74,   72,   72,   68, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   44,   44,   44,   44,   44,   44, 
+      68,   68,   68,   68,   68,   68,   74,   74,   72,   72,   68,   68,   68,   68,   72,   72, 
+      72,   68,   74,   10,   10,   68,   68,   74,   74,   10,   10,   10,   10,   10,   68,   68, 
+      68,   72,   72,   72,   72,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   72,   74,   74,   72,   72,   10,   10,   10,   10,   10,   10,    8,   68,   10, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,   64,   64,   51,   51, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   44,   67,    0,    0,    0, 
+
+
+    // block 17
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   64,   64,   64,   64,   64, 4164, 
+    4164,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   64,   64,   64,   64,   64,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   64,   64,   64,   64,   64,   64, 
+
+
+    // block 18
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,    0,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,   68,   68,   68,    0,    0,   68,   68,   68,   68,   68,   68,   68,    0, 
+      68,    0,   68,   68,   68,   68,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 19
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,    0,   68,   68,   68,   68,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,   72, 
+      51,   44,   44,   44,   44,   44,   44,   44,   44,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 20
+       0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 21
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 22
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   44,   44,   68, 
+      68,   68,   68,   68,   68,   68,   68,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+     536,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   41,   42,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   44,   44,   44,   81,   81, 
+      81,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 23
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68, 
+      68,   68,   72,   72,    8,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   72,   72,    8,   44,   44,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   72,   72,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68, 
+      68,    0,   72,   72,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68, 4129, 4129,   74,   72,   72,   72,   72,   72,   72,   72,   74,   74, 
+      74,   74,   74,   74,   74,   74,   72,   74,   74,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,   44,   44,   44,   67,   44,   44,   44,   49,   68,    8,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,    0,    0, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 24
+      44,   44,   44,   44,   44,   44,   40,   44,   44,   44,   44, 4104, 4104, 4104,  536,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   67,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   72,   68,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 25
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0, 
+      72,   72,   72,   74,   74,   74,   74,   72,   72,   74,   74,   74,    0,    0,    0,    0, 
+      74,   74,   72,   74,   74,   74,   74,   74,   74,    8,    8,    8,    0,    0,    0,    0, 
+      51,    0,    0,    0,   44,   44,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   64,   64,    0,    0,    0,    0, 
+      74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74, 
+      74,   68,   68,   68,   68,   68,   68,   68,   74,   74,    0,    0,    0,    0,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,   44,   44, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+
+
+    // block 26
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   72,   72,   74,   74,   74,    0,    0,   44,   44, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0, 
+       0,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,   64,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 27
+      72,   72,   72,   72,   74,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    8,   74,   72,   72,   72,   72,   72,   74,   72,   74,   74,   74, 
+      74,   74,   72,   74,   10,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   44,   44,   44,   44,   44,   44, 
+      44,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0, 
+      72,   72,   74,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   74,   72,   72,   72,   72,   74,   74,   72,   72,   10,    0,    0,    0,   68,   68, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 28
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   74,   74,   74,   74,   74,   74,   74,   74,   72,   72,   72,   72, 
+      72,   72,   72,   72,   74,   74,    8,    8,    0,    0,    0,   44,   44,   44,   44,   44, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,   68,   68,   68, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   67,   67,   67,   67,   67,   67,   44,   44, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,   64,   64,   64,   64,    0,   64,   64, 
+      64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 29
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  323,  323,  323,  323, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323, 
+     323,  323,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  323,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  323,  323,  323,  323,  323, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323, 
+     323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323,  323, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    8,    8,    8,    8,    8,    8,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    8,    8, 
+
+
+    // block 30
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  321,  321,  321,  321,  321,  321,  321,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+
+
+    // block 31
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     321,  321,  321,  321,  321,  321,    0,    0,  192,  192,  192,  192,  192,  192,    0,    0, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     321,  321,  321,  321,  321,  321,    0,    0,  192,  192,  192,  192,  192,  192,    0,    0, 
+     321,  321,  321,  321,  321,  321,  321,  321,    0,  192,    0,  192,    0,  192,    0,  192, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,    0,    0, 
+     321,  321,  321,  321,  321,  321,  321,  321,   66,   66,   66,   66,   66,   66,   66,   66, 
+     321,  321,  321,  321,  321,  321,  321,  321,   66,   66,   66,   66,   66,   66,   66,   66, 
+     321,  321,  321,  321,  321,  321,  321,  321,   66,   66,   66,   66,   66,   66,   66,   66, 
+     321,  321,  321,  321,  321,    0,  321,  321,  192,  192,  192,  192,   66,   50,  321,   50, 
+      50,   50,  321,  321,  321,    0,  321,  321,  192,  192,  192,  192,   66,   50,   50,   50, 
+     321,  321,  321,  321,    0,    0,  321,  321,  192,  192,  192,  192,    0,   50,   50,   50, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,   50,   50,   50, 
+       0,    0,  321,  321,  321,    0,  321,  321,  192,  192,  192,  192,   66,   50,   50,    0, 
+
+
+    // block 32
+     536,  536,  536,  536,  536,  536,  536,  536,  536,  536,  536, 4129, 4129, 4129, 4129, 4129, 
+      40,   40,   40,   40,   40,   40,   44,   44,   45,   46,   41,   45,   45,   46,   41,   45, 
+      44,   44,   44,   44,   44,   44,   44,   44,  537,  538, 4129, 4129, 4129, 4129, 4129,  536, 
+      44,   44,   44,   44,   44,   44,   44,   44,   44,   45,   46,   44,   44,   44,   44,   43, 
+      43,   44,   44,   44,   48,   41,   42,   44,   44,   44,   44,   44,   44,   44,   44,   44, 
+      44,   44,   48,   44,   43,   44,   44,   44,   44,   44,   44,   44,   44,   44,   44,  536, 
+    4129, 4129, 4129, 4129, 4129, 4096, 4096, 4096, 4096, 4096, 4129, 4129, 4129, 4129, 4129, 4129, 
+      18,   65,    0,    0,   18,   18,   18,   18,   18,   18,   48,   48,   48,   41,   42,   65, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   48,   48,   48,   41,   42,    0, 
+     323,  323,  323,  323,  323,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49,   49, 
+      49,   49,   49,   49,   49,   49,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    9,    9,    9, 
+       9,    8,    9,    9,    9,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8,    8, 
+       8,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 33
+      51,   51,  192,   51,   51,   51,   51,  192,   51,   51,  321,  192,  192,  192,  321,  321, 
+     192,  192,  192,  321,   51,  192,   51,   51,   51,  192,  192,  192,  192,  192,   51,   51, 
+      51,   51,   51,   51,  192,   51,  192,   51,  192,   51,  192,  192,  192,  192,   51,  321, 
+     192,  192,  192,  192,  321,   68,   68,   68,   68,  321,   51,   51,  321,  321,  192,  192, 
+      48,   48,   48,   48,   48,  192,  321,  321,  321,  321,   51,   48,   51,   51,  321,   51, 
+       0,    0,    0,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+     209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209,  209, 
+     337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337,  337, 
+      81,   81,   81,  192,  321,   81,   81,   81,   81,    0,    0,    0,    0,    0,    0,    0, 
+      48,   48,   48,   48,   48,   51,   51,   51,   51,   51,   48,   48,   51,   51,   51,   51, 
+      48,   51,   51,   48,   51,   51,   48,   51,   51,   51,   51,   51,   51,   51,   48,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   48,   48, 
+      51,   51,   48,   51,   48,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+
+
+    // block 34
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+
+
+    // block 35
+      51,   51,   51,   51,   51,   51,   51,   51,   48,   48,   48,   48,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      48,   48,   51,   51,   51,   51,   51,   51,   51,   41,   42,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   48,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   48,   48,   48,   48, 
+      48,   48,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 36
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243, 
+     243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243,  243, 
+     371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371,  371, 
+     371,  371,  371,  371,  371,  371,  371,  371,  371,  371,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+
+
+    // block 37
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   48,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   48,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   48,   48,   48,   48,   48,   48,   48,   48, 
+
+
+    // block 38
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   48, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0, 
+      51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 39
+       0,   51,   51,   51,   51,    0,   51,   51,   51,   51,    0,    0,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,    0,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,   51,    0,   51, 
+      51,   51,   51,    0,    0,    0,   51,    0,   51,   51,   51,   51,   51,   51,   51,    0, 
+       0,   51,   51,   51,   51,   51,   51,   51,   41,   42,   41,   42,   41,   42,   41,   42, 
+      41,   42,   41,   42,   41,   42,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   51,    0,    0,    0,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+       0,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0, 
+      48,   48,   48,   48,   48,   41,   42,   48,   48,   48,   48,    0,   48,    0,    0,    0, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   41,   42,   41,   42,   41,   42,   41,   42,   41,   42, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+
+
+    // block 40
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+
+
+    // block 41
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   41,   42,   41,   42,   41,   42,   41,   42,   41,   42,   41,   42,   41, 
+      42,   41,   42,   41,   42,   41,   42,   41,   42,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   41,   42,   41,   42,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   41,   42,   48,   48, 
+
+
+    // block 42
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48,   48, 
+      48,   48,   48,   48,   48,   51,   51,   48,   48,   48,   48,   48,   48,    0,    0,    0, 
+      51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 43
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,    0, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,    0, 
+     192,  321,  192,  192,  192,  321,  321,  192,  321,  192,  321,  192,  321,  192,  192,  192, 
+     192,  321,  192,  321,  321,  192,  321,  321,  321,  321,  321,  321,  321,  323,  192,  192, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  321,   51,   51,   51,   51,   51,   51,  192,  320,  192,  320,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,   44,   44,   44,   44,   18,   44,   44, 
+
+
+    // block 44
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,   67, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,    0, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,    0, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+      72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+
+
+    // block 45
+      44,   44,   45,   46,   45,   46,   44,   44,   44,   45,   46,   44,   45,   46,   44,   44, 
+      44,   44,   44,   44,   44,   44,   44,   40,   44,   44,   40,   44,   45,   46,   44,   44, 
+      45,   46,   41,   42,   41,   42,   41,   42,   41,   42,   44,   44,   44,   44,   44,   67, 
+      44,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 46
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0, 
+
+
+    // block 47
+     536,   44,   44,   44,   51,   67,   68,   81,   41,   42,   41,   42,   41,   42,   41,   42, 
+      41,   42,   51,   51,   41,   42,   41,   42,   41,   42,   41,   42,   40,   41,   42,   42, 
+      51,   81,   81,   81,   81,   81,   81,   81,   81,   81,    8,    8,    8,    8,    8,    8, 
+      40,   67,   67,   67,   67,   67,   51,   51,   81,   81,   81,   67,   68,   44,   51,   51, 
+       0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,    0,    8,    8,   50,   50,   67,   67,   68, 
+      40,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   44,   67,   67,   67,   68, 
+
+
+    // block 48
+       0,    0,    0,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+       0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68, 4164,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0, 
+      51,   51,   18,   18,   18,   18,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 49
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0, 
+
+
+    // block 50
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+
+
+    // block 51
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 52
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   67,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 53
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0, 
+
+
+    // block 54
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   67,   44,   44,   44, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   68,   68,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+       0,    0,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,   68,    8, 
+       9,    9,    9,   44,    0,    0,    0,    0,    0,    0,    0,    0,    8,    8,   44,   67, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 55
+      50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50, 
+      50,   50,   50,   50,   50,   50,   50,   67,   67,   67,   67,   67,   67,   67,   67,   67, 
+      50,   50,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     321,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321,  192,  321, 
+     323,  321,  321,  321,  321,  321,  321,  321,  321,  192,  321,  192,  321,  192,  192,  321, 
+     192,  321,  192,  321,  192,  321,  192,  321,   67,   50,   50,  192,  321,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   68,   68,   68,   68,   68, 
+
+
+    // block 56
+      68,   68,    8,   68,   68,   68,    8,   68,   68,   68,   68,    8,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   74,   74,   72,   72,   74,   51,   51,   51,   51,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   44,   44,   44,   44,    0,    0,    0,    0,    0,    0,    0,    0, 
+      74,   74,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74,   74, 
+      74,   74,   74,   74,    8,    0,    0,    0,    0,    0,    0,    0,    0,    0,   44,   44, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,   64,   64,   64,   64,   64,   64,    0,    0,    0,   64,    0,    0,    0,    0, 
+
+
+    // block 57
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   72,   72,   72,   72,   72,    8,    8,    8,   44,   44, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   72,   72,   72,   72,   72,   72,   72,   72,   72, 
+      72,   72,   74,   10,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   44, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   64, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 58
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   72,   72,   72,   72,   72,   72,   74, 
+      74,   72,   72,   74,   74,   72,   72,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   72,   68,   68,   68,   68,   68,   68,   68,   68,   72,   74,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,   44,   44,   44,   44, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,    0,    0,    0,   64,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0, 
+      64,    0,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   64,   64,   64,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 59
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 60
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0, 
+
+
+    // block 61
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+      35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35,   35, 
+
+
+    // block 62
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+
+
+    // block 63
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   64,   64,   64,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 64
+     321,  321,  321,  321,  321,  321,  321,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,  321,  321,  321,  321,  321,    0,    0,    0,    0,    0,   68,   72,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   48,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,    0,   68,    0, 
+      68,   68,    0,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+
+
+    // block 65
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   41,   42, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+       0,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0, 
+    2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 
+    2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   49,   51,    0,    0, 
+
+
+    // block 66
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+      44,   44,   44,   44,   44,   44,   44,   41,   42,   44,    0,    0,    0,    0,    0,    0, 
+       8,    8,    8,    8,    8,    8,    8,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      44,   40,   40,   43,   43,   41,   42,   41,   42,   41,   42,   41,   42,   41,   42,   41, 
+      42,   41,   42,   41,   42,   44,   44,   41,   42,   44,   44,   44,   44,   43,   43,   43, 
+      44,   44,   44,    0,   44,   44,   44,   44,   40,   41,   42,   41,   42,   41,   42,   44, 
+      44,   44,   48,   40,   48,   48,   48,    0,   44,   49,   44,   44,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 4129, 
+
+
+    // block 67
+       0,   44,   44,   44,   49,   44,   44,   44,   41,   42,   44,   48,   44,   40,   44,   44, 
+    1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040,   44,   44,   48,   48,   48,   44, 
+      44, 1216, 1216, 1216, 1216, 1216, 1216,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,   41,   44,   42,   50,   43, 
+      50, 1345, 1345, 1345, 1345, 1345, 1345,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,   41,   48,   42,   48,   41, 
+      42,   44,   41,   42,   44,   44,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      67,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   67,   67, 
+    4164,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0, 
+       0,    0,   68,   68,   68,   68,   68,   68,    0,    0,   68,   68,   68,   68,   68,   68, 
+       0,    0,   68,   68,   68,   68,   68,   68,    0,    0,   68,   68,   68,    0,    0,    0, 
+      49,   49,   48,   50,   51,   49,   49,    0,   51,   48,   48,   48,   48,   51,   51,    0, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096,   33,   33,   33,   51,   51, 2048, 2048, 
+
+
+    // block 68
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   68,   68,    0,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0, 
+
+
+    // block 69
+      44,   44,   51,    0,    0,    0,    0,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,   18,   18,    0,    0,    0,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   18,   18,   18,   18,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   18,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    8,    0,    0, 
+
+
+    // block 70
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 71
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0, 
+      18,   18,   18,   18,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   81,   68,   68,   68,   68,   68,   68,   68,   68,   81,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,   44, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    0,    0,    0,    0,   68,   68,   68,   68,   68,   68,   68,   68, 
+      44,   81,   81,   81,   81,   81,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 72
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 73
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 74
+      68,   68,   68,   68,   68,   68,    0,    0,   68,    0,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,    0,   68,   68,    0,    0,    0,   68,    0,    0,   68, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 75
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   18,   18,   18,   18,    0,    0,    0,    0,    0,   44, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,   44, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 76
+      68,   72,   72,   72,    0,   72,   72,    0,    0,    0,    0,    0,   72,   72,   72,   72, 
+      68,   68,   68,   68,    0,   68,   68,   68,    0,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,    0,    0,    0,    0,    8,    8,    8,    0,    0,    0,    0,    8, 
+      18,   18,   18,   18,   18,   18,   18,   18,    0,    0,    0,    0,    0,    0,    0,    0, 
+      44,   44,   44,   44,   44,   44,   44,   44,   44,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 77
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 78
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 79
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 80
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 81
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81,   81, 
+      81,   81,   81,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      44,   44,   44,   44,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 82
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+
+
+    // block 83
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 84
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 85
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,    0,    0,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   10,   10,    8,    8,    8,   51,   51,   51,   10,   10,   10, 
+      10,   10,   10, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129,    8,    8,    8,    8,    8, 
+       8,    8,    8,   51,   51,    8,    8,    8,    8,    8,    8,    8,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    8,    8,    8,    8,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 86
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,    8,    8,    8,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 87
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+      18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18,   18, 
+      18,   18,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 88
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321, 
+     321,  321,  321,  321,  321,    0,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  192,    0,  192,  192, 
+       0,    0,  192,    0,    0,  192,  192,    0,    0,  192,  192,  192,  192,    0,  192,  192, 
+     192,  192,  192,  192,  192,  192,  321,  321,  321,  321,    0,  321,    0,  321,  321,  321, 
+     321,  321,  321,  321,    0,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+
+
+    // block 89
+     321,  321,  321,  321,  192,  192,    0,  192,  192,  192,  192,    0,    0,  192,  192,  192, 
+     192,  192,  192,  192,  192,    0,  192,  192,  192,  192,  192,  192,  192,    0,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,    0,  192,  192,  192,  192,    0, 
+     192,  192,  192,  192,  192,    0,  192,    0,    0,    0,  192,  192,  192,  192,  192,  192, 
+     192,    0,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+
+
+    // block 90
+     321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,    0,    0,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,   48,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,   48,  321,  321,  321,  321, 
+     321,  321,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,   48,  321,  321,  321,  321, 
+
+
+    // block 91
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,   48,  321,  321,  321,  321,  321,  321,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,   48,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,   48, 
+     321,  321,  321,  321,  321,  321,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,   48, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,   48,  321,  321,  321,  321,  321,  321, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,  192, 
+     192,  192,  192,  192,  192,  192,  192,  192,  192,   48,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321,  321, 
+     321,  321,  321,   48,  321,  321,  321,  321,  321,  321,  192,  321,    0,    0,   16,   16, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+      16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16, 
+
+
+    // block 92
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,    0,    0,    0,    0, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51,   51, 
+      51,   51,   51,   51,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 93
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 2048, 2048, 
+
+
+    // block 94
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 95
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,   64, 
+      64,   64,   64,   64,   64,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 96
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68, 
+      68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+       0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+
+
+    // block 97
+    4096, 4129, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 4129, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+
+
+    // block 98
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 4104, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+
+
+    // block 99
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+    4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 
+
+
+    // block 100
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 
+      34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,   34, 2048, 2048
+    };
+
+    inline ::boost::uint16_t category_lookup(::boost::uint32_t ch)
+    {
+        ::boost::uint32_t block_offset = category_stage1[ch / 256] * 256;
+        return category_stage2[block_offset + ch % 256];
+    }
+
+}}}} // namespace boost::spirit::unicode::detail
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/lowercase_table.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/lowercase_table.hpp
new file mode 100644
index 0000000..8ccf635
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/lowercase_table.hpp
@@ -0,0 +1,620 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    AUTOGENERATED. DO NOT EDIT!!!
+==============================================================================*/
+#include <boost/cstdint.hpp>
+
+namespace boost { namespace spirit { namespace ucd { namespace detail
+{
+    static const ::boost::uint8_t lowercase_stage1[] = {
+
+      0,   1,   2,   3,   4,   5,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      7,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   8,   9, 
+      6,  10,   6,   6,  11,   6,   6,   6,   6,   6,   6,   6,  12,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,  13,  14,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,  15, 
+      6,   6,   6,   6,  16,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6
+    };
+
+    static const ::boost::uint32_t lowercase_stage2[] = {
+
+    // block 0
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,     97,     98,     99,    100,    101,    102,    103,    104,    105,    106,    107,    108,    109,    110,    111, 
+       112,    113,    114,    115,    116,    117,    118,    119,    120,    121,    122,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+       224,    225,    226,    227,    228,    229,    230,    231,    232,    233,    234,    235,    236,    237,    238,    239, 
+       240,    241,    242,    243,    244,    245,    246,      0,    248,    249,    250,    251,    252,    253,    254,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 1
+       257,      0,    259,      0,    261,      0,    263,      0,    265,      0,    267,      0,    269,      0,    271,      0, 
+       273,      0,    275,      0,    277,      0,    279,      0,    281,      0,    283,      0,    285,      0,    287,      0, 
+       289,      0,    291,      0,    293,      0,    295,      0,    297,      0,    299,      0,    301,      0,    303,      0, 
+       105,      0,    307,      0,    309,      0,    311,      0,      0,    314,      0,    316,      0,    318,      0,    320, 
+         0,    322,      0,    324,      0,    326,      0,    328,      0,      0,    331,      0,    333,      0,    335,      0, 
+       337,      0,    339,      0,    341,      0,    343,      0,    345,      0,    347,      0,    349,      0,    351,      0, 
+       353,      0,    355,      0,    357,      0,    359,      0,    361,      0,    363,      0,    365,      0,    367,      0, 
+       369,      0,    371,      0,    373,      0,    375,      0,    255,    378,      0,    380,      0,    382,      0,      0, 
+         0,    595,    387,      0,    389,      0,    596,    392,      0,    598,    599,    396,      0,      0,    477,    601, 
+       603,    402,      0,    608,    611,      0,    617,    616,    409,      0,      0,      0,    623,    626,      0,    629, 
+       417,      0,    419,      0,    421,      0,    640,    424,      0,    643,      0,      0,    429,      0,    648,    432, 
+         0,    650,    651,    436,      0,    438,      0,    658,    441,      0,      0,      0,    445,      0,      0,      0, 
+         0,      0,      0,      0,    454,    454,      0,    457,    457,      0,    460,    460,      0,    462,      0,    464, 
+         0,    466,      0,    468,      0,    470,      0,    472,      0,    474,      0,    476,      0,      0,    479,      0, 
+       481,      0,    483,      0,    485,      0,    487,      0,    489,      0,    491,      0,    493,      0,    495,      0, 
+         0,    499,    499,      0,    501,      0,    405,    447,    505,      0,    507,      0,    509,      0,    511,      0, 
+
+
+    // block 2
+       513,      0,    515,      0,    517,      0,    519,      0,    521,      0,    523,      0,    525,      0,    527,      0, 
+       529,      0,    531,      0,    533,      0,    535,      0,    537,      0,    539,      0,    541,      0,    543,      0, 
+       414,      0,    547,      0,    549,      0,    551,      0,    553,      0,    555,      0,    557,      0,    559,      0, 
+       561,      0,    563,      0,      0,      0,      0,      0,      0,      0,  11365,    572,      0,    410,  11366,      0, 
+         0,    578,      0,    384,    649,    652,    583,      0,    585,      0,    587,      0,    589,      0,    591,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 3
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+       881,      0,    883,      0,      0,      0,    887,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,    940,      0,    941,    942,    943,      0,    972,      0,    973,    974, 
+         0,    945,    946,    947,    948,    949,    950,    951,    952,    953,    954,    955,    956,    957,    958,    959, 
+       960,    961,      0,    963,    964,    965,    966,    967,    968,    969,    970,    971,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,    983, 
+         0,      0,      0,      0,      0,      0,      0,      0,    985,      0,    987,      0,    989,      0,    991,      0, 
+       993,      0,    995,      0,    997,      0,    999,      0,   1001,      0,   1003,      0,   1005,      0,   1007,      0, 
+         0,      0,      0,      0,    952,      0,      0,   1016,      0,   1010,   1019,      0,      0,    891,    892,    893, 
+
+
+    // block 4
+      1104,   1105,   1106,   1107,   1108,   1109,   1110,   1111,   1112,   1113,   1114,   1115,   1116,   1117,   1118,   1119, 
+      1072,   1073,   1074,   1075,   1076,   1077,   1078,   1079,   1080,   1081,   1082,   1083,   1084,   1085,   1086,   1087, 
+      1088,   1089,   1090,   1091,   1092,   1093,   1094,   1095,   1096,   1097,   1098,   1099,   1100,   1101,   1102,   1103, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      1121,      0,   1123,      0,   1125,      0,   1127,      0,   1129,      0,   1131,      0,   1133,      0,   1135,      0, 
+      1137,      0,   1139,      0,   1141,      0,   1143,      0,   1145,      0,   1147,      0,   1149,      0,   1151,      0, 
+      1153,      0,      0,      0,      0,      0,      0,      0,      0,      0,   1163,      0,   1165,      0,   1167,      0, 
+      1169,      0,   1171,      0,   1173,      0,   1175,      0,   1177,      0,   1179,      0,   1181,      0,   1183,      0, 
+      1185,      0,   1187,      0,   1189,      0,   1191,      0,   1193,      0,   1195,      0,   1197,      0,   1199,      0, 
+      1201,      0,   1203,      0,   1205,      0,   1207,      0,   1209,      0,   1211,      0,   1213,      0,   1215,      0, 
+      1231,   1218,      0,   1220,      0,   1222,      0,   1224,      0,   1226,      0,   1228,      0,   1230,      0,      0, 
+      1233,      0,   1235,      0,   1237,      0,   1239,      0,   1241,      0,   1243,      0,   1245,      0,   1247,      0, 
+      1249,      0,   1251,      0,   1253,      0,   1255,      0,   1257,      0,   1259,      0,   1261,      0,   1263,      0, 
+      1265,      0,   1267,      0,   1269,      0,   1271,      0,   1273,      0,   1275,      0,   1277,      0,   1279,      0, 
+
+
+    // block 5
+      1281,      0,   1283,      0,   1285,      0,   1287,      0,   1289,      0,   1291,      0,   1293,      0,   1295,      0, 
+      1297,      0,   1299,      0,   1301,      0,   1303,      0,   1305,      0,   1307,      0,   1309,      0,   1311,      0, 
+      1313,      0,   1315,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,   1377,   1378,   1379,   1380,   1381,   1382,   1383,   1384,   1385,   1386,   1387,   1388,   1389,   1390,   1391, 
+      1392,   1393,   1394,   1395,   1396,   1397,   1398,   1399,   1400,   1401,   1402,   1403,   1404,   1405,   1406,   1407, 
+      1408,   1409,   1410,   1411,   1412,   1413,   1414,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 6
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 7
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     11520,  11521,  11522,  11523,  11524,  11525,  11526,  11527,  11528,  11529,  11530,  11531,  11532,  11533,  11534,  11535, 
+     11536,  11537,  11538,  11539,  11540,  11541,  11542,  11543,  11544,  11545,  11546,  11547,  11548,  11549,  11550,  11551, 
+     11552,  11553,  11554,  11555,  11556,  11557,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 8
+      7681,      0,   7683,      0,   7685,      0,   7687,      0,   7689,      0,   7691,      0,   7693,      0,   7695,      0, 
+      7697,      0,   7699,      0,   7701,      0,   7703,      0,   7705,      0,   7707,      0,   7709,      0,   7711,      0, 
+      7713,      0,   7715,      0,   7717,      0,   7719,      0,   7721,      0,   7723,      0,   7725,      0,   7727,      0, 
+      7729,      0,   7731,      0,   7733,      0,   7735,      0,   7737,      0,   7739,      0,   7741,      0,   7743,      0, 
+      7745,      0,   7747,      0,   7749,      0,   7751,      0,   7753,      0,   7755,      0,   7757,      0,   7759,      0, 
+      7761,      0,   7763,      0,   7765,      0,   7767,      0,   7769,      0,   7771,      0,   7773,      0,   7775,      0, 
+      7777,      0,   7779,      0,   7781,      0,   7783,      0,   7785,      0,   7787,      0,   7789,      0,   7791,      0, 
+      7793,      0,   7795,      0,   7797,      0,   7799,      0,   7801,      0,   7803,      0,   7805,      0,   7807,      0, 
+      7809,      0,   7811,      0,   7813,      0,   7815,      0,   7817,      0,   7819,      0,   7821,      0,   7823,      0, 
+      7825,      0,   7827,      0,   7829,      0,      0,      0,      0,      0,      0,      0,      0,      0,    223,      0, 
+      7841,      0,   7843,      0,   7845,      0,   7847,      0,   7849,      0,   7851,      0,   7853,      0,   7855,      0, 
+      7857,      0,   7859,      0,   7861,      0,   7863,      0,   7865,      0,   7867,      0,   7869,      0,   7871,      0, 
+      7873,      0,   7875,      0,   7877,      0,   7879,      0,   7881,      0,   7883,      0,   7885,      0,   7887,      0, 
+      7889,      0,   7891,      0,   7893,      0,   7895,      0,   7897,      0,   7899,      0,   7901,      0,   7903,      0, 
+      7905,      0,   7907,      0,   7909,      0,   7911,      0,   7913,      0,   7915,      0,   7917,      0,   7919,      0, 
+      7921,      0,   7923,      0,   7925,      0,   7927,      0,   7929,      0,   7931,      0,   7933,      0,   7935,      0, 
+
+
+    // block 9
+         0,      0,      0,      0,      0,      0,      0,      0,   7936,   7937,   7938,   7939,   7940,   7941,   7942,   7943, 
+         0,      0,      0,      0,      0,      0,      0,      0,   7952,   7953,   7954,   7955,   7956,   7957,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   7968,   7969,   7970,   7971,   7972,   7973,   7974,   7975, 
+         0,      0,      0,      0,      0,      0,      0,      0,   7984,   7985,   7986,   7987,   7988,   7989,   7990,   7991, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8000,   8001,   8002,   8003,   8004,   8005,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,   8017,      0,   8019,      0,   8021,      0,   8023, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8032,   8033,   8034,   8035,   8036,   8037,   8038,   8039, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8064,   8065,   8066,   8067,   8068,   8069,   8070,   8071, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8080,   8081,   8082,   8083,   8084,   8085,   8086,   8087, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8096,   8097,   8098,   8099,   8100,   8101,   8102,   8103, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8112,   8113,   8048,   8049,   8115,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8050,   8051,   8052,   8053,   8131,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8144,   8145,   8054,   8055,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8160,   8161,   8058,   8059,   8165,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,   8056,   8057,   8060,   8061,   8179,      0,      0,      0, 
+
+
+    // block 10
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,    969,      0,      0,      0,    107,    229,      0,      0,      0,      0, 
+         0,      0,   8526,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8560,   8561,   8562,   8563,   8564,   8565,   8566,   8567,   8568,   8569,   8570,   8571,   8572,   8573,   8574,   8575, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,   8580,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 11
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,   9424,   9425,   9426,   9427,   9428,   9429,   9430,   9431,   9432,   9433, 
+      9434,   9435,   9436,   9437,   9438,   9439,   9440,   9441,   9442,   9443,   9444,   9445,   9446,   9447,   9448,   9449, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 12
+     11312,  11313,  11314,  11315,  11316,  11317,  11318,  11319,  11320,  11321,  11322,  11323,  11324,  11325,  11326,  11327, 
+     11328,  11329,  11330,  11331,  11332,  11333,  11334,  11335,  11336,  11337,  11338,  11339,  11340,  11341,  11342,  11343, 
+     11344,  11345,  11346,  11347,  11348,  11349,  11350,  11351,  11352,  11353,  11354,  11355,  11356,  11357,  11358,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     11361,      0,    619,   7549,    637,      0,      0,  11368,      0,  11370,      0,  11372,      0,    593,    625,    592, 
+         0,      0,  11379,      0,      0,  11382,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     11393,      0,  11395,      0,  11397,      0,  11399,      0,  11401,      0,  11403,      0,  11405,      0,  11407,      0, 
+     11409,      0,  11411,      0,  11413,      0,  11415,      0,  11417,      0,  11419,      0,  11421,      0,  11423,      0, 
+     11425,      0,  11427,      0,  11429,      0,  11431,      0,  11433,      0,  11435,      0,  11437,      0,  11439,      0, 
+     11441,      0,  11443,      0,  11445,      0,  11447,      0,  11449,      0,  11451,      0,  11453,      0,  11455,      0, 
+     11457,      0,  11459,      0,  11461,      0,  11463,      0,  11465,      0,  11467,      0,  11469,      0,  11471,      0, 
+     11473,      0,  11475,      0,  11477,      0,  11479,      0,  11481,      0,  11483,      0,  11485,      0,  11487,      0, 
+     11489,      0,  11491,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 13
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     42561,      0,  42563,      0,  42565,      0,  42567,      0,  42569,      0,  42571,      0,  42573,      0,  42575,      0, 
+     42577,      0,  42579,      0,  42581,      0,  42583,      0,  42585,      0,  42587,      0,  42589,      0,  42591,      0, 
+         0,      0,  42595,      0,  42597,      0,  42599,      0,  42601,      0,  42603,      0,  42605,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     42625,      0,  42627,      0,  42629,      0,  42631,      0,  42633,      0,  42635,      0,  42637,      0,  42639,      0, 
+     42641,      0,  42643,      0,  42645,      0,  42647,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 14
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,  42787,      0,  42789,      0,  42791,      0,  42793,      0,  42795,      0,  42797,      0,  42799,      0, 
+         0,      0,  42803,      0,  42805,      0,  42807,      0,  42809,      0,  42811,      0,  42813,      0,  42815,      0, 
+     42817,      0,  42819,      0,  42821,      0,  42823,      0,  42825,      0,  42827,      0,  42829,      0,  42831,      0, 
+     42833,      0,  42835,      0,  42837,      0,  42839,      0,  42841,      0,  42843,      0,  42845,      0,  42847,      0, 
+     42849,      0,  42851,      0,  42853,      0,  42855,      0,  42857,      0,  42859,      0,  42861,      0,  42863,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,  42874,      0,  42876,      0,   7545,  42879,      0, 
+     42881,      0,  42883,      0,  42885,      0,  42887,      0,      0,      0,      0,  42892,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 15
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,  65345,  65346,  65347,  65348,  65349,  65350,  65351,  65352,  65353,  65354,  65355,  65356,  65357,  65358,  65359, 
+     65360,  65361,  65362,  65363,  65364,  65365,  65366,  65367,  65368,  65369,  65370,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 16
+     66600,  66601,  66602,  66603,  66604,  66605,  66606,  66607,  66608,  66609,  66610,  66611,  66612,  66613,  66614,  66615, 
+     66616,  66617,  66618,  66619,  66620,  66621,  66622,  66623,  66624,  66625,  66626,  66627,  66628,  66629,  66630,  66631, 
+     66632,  66633,  66634,  66635,  66636,  66637,  66638,  66639,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
+    };
+
+    inline ::boost::uint32_t lowercase_lookup(::boost::uint32_t ch)
+    {
+        ::boost::uint32_t block_offset = lowercase_stage1[ch / 256] * 256;
+        return lowercase_stage2[block_offset + ch % 256];
+    }
+
+}}}} // namespace boost::spirit::unicode::detail
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp
new file mode 100644
index 0000000..3a0526c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp
@@ -0,0 +1,305 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Autogenerated by MultiStageTable.py (Unicode multi-stage
+    table builder) (c) Peter Kankowski, 2008
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_UNICODE_QUERY_FEBRUARY_2_2010)
+#define BOOST_SPIRIT_UNICODE_QUERY_FEBRUARY_2_2010
+
+#include <boost/cstdint.hpp>
+
+# include "category_table.hpp"
+# include "script_table.hpp"
+# include "lowercase_table.hpp"
+# include "uppercase_table.hpp"
+
+namespace boost { namespace spirit { namespace ucd
+{
+    // This header provides Basic (Level 1) Unicode Support
+    // See http://unicode.org/reports/tr18/ for details
+
+    struct properties
+    {
+        // bit pattern: xxMMMCCC
+        // MMM: major_category
+        // CCC: category
+
+        enum major_category
+        {
+            letter,
+            mark,
+            number,
+            separator,
+            other,
+            punctuation,
+            symbol
+        };
+
+        enum category
+        {
+            uppercase_letter = 0,   // [Lu] an uppercase letter
+            lowercase_letter,       // [Ll] a lowercase letter
+            titlecase_letter,       // [Lt] a digraphic character, with first part uppercase
+            modifier_letter,        // [Lm] a modifier letter
+            other_letter,           // [Lo] other letters, including syllables and ideographs
+
+            nonspacing_mark = 8,    // [Mn] a nonspacing combining mark (zero advance width)
+            enclosing_mark,         // [Me] an enclosing combining mark
+            spacing_mark,           // [Mc] a spacing combining mark (positive advance width)
+
+            decimal_number = 16,    // [Nd] a decimal digit
+            letter_number,          // [Nl] a letterlike numeric character
+            other_number,           // [No] a numeric character of other type
+
+            space_separator = 24,   // [Zs] a space character (of various non-zero widths)
+            line_separator,         // [Zl] U+2028 LINE SEPARATOR only
+            paragraph_separator,    // [Zp] U+2029 PARAGRAPH SEPARATOR only
+
+            control = 32,           // [Cc] a C0 or C1 control code
+            format,                 // [Cf] a format control character
+            private_use,            // [Co] a private-use character
+            surrogate,              // [Cs] a surrogate code point
+            unassigned,             // [Cn] a reserved unassigned code point or a noncharacter
+
+            dash_punctuation = 40,  // [Pd] a dash or hyphen punctuation mark
+            open_punctuation,       // [Ps] an opening punctuation mark (of a pair)
+            close_punctuation,      // [Pe] a closing punctuation mark (of a pair)
+            connector_punctuation,  // [Pc] a connecting punctuation mark, like a tie
+            other_punctuation,      // [Po] a punctuation mark of other type
+            initial_punctuation,    // [Pi] an initial quotation mark
+            final_punctuation,      // [Pf] a final quotation mark
+
+            math_symbol = 48,       // [Sm] a symbol of primarily mathematical use
+            currency_symbol,        // [Sc] a currency sign
+            modifier_symbol,        // [Sk] a non-letterlike modifier symbol
+            other_symbol            // [So] a symbol of other type
+        };
+
+        enum derived_properties
+        {
+            alphabetic = 64,
+            uppercase = 128,
+            lowercase = 256,
+            white_space = 512,
+            hex_digit = 1024,
+            noncharacter_code_point = 2048,
+            default_ignorable_code_point = 4096
+        };
+
+        enum script
+        {
+            arabic = 0,
+            imperial_aramaic = 1,
+            armenian = 2,
+            avestan = 3,
+            balinese = 4,
+            bamum = 5,
+            bengali = 6,
+            bopomofo = 7,
+            braille = 8,
+            buginese = 9,
+            buhid = 10,
+            canadian_aboriginal = 11,
+            carian = 12,
+            cham = 13,
+            cherokee = 14,
+            coptic = 15,
+            cypriot = 16,
+            cyrillic = 17,
+            devanagari = 18,
+            deseret = 19,
+            egyptian_hieroglyphs = 20,
+            ethiopic = 21,
+            georgian = 22,
+            glagolitic = 23,
+            gothic = 24,
+            greek = 25,
+            gujarati = 26,
+            gurmukhi = 27,
+            hangul = 28,
+            han = 29,
+            hanunoo = 30,
+            hebrew = 31,
+            hiragana = 32,
+            katakana_or_hiragana = 33,
+            old_italic = 34,
+            javanese = 35,
+            kayah_li = 36,
+            katakana = 37,
+            kharoshthi = 38,
+            khmer = 39,
+            kannada = 40,
+            kaithi = 41,
+            tai_tham = 42,
+            lao = 43,
+            latin = 44,
+            lepcha = 45,
+            limbu = 46,
+            linear_b = 47,
+            lisu = 48,
+            lycian = 49,
+            lydian = 50,
+            malayalam = 51,
+            mongolian = 52,
+            meetei_mayek = 53,
+            myanmar = 54,
+            nko = 55,
+            ogham = 56,
+            ol_chiki = 57,
+            old_turkic = 58,
+            oriya = 59,
+            osmanya = 60,
+            phags_pa = 61,
+            inscriptional_pahlavi = 62,
+            phoenician = 63,
+            inscriptional_parthian = 64,
+            rejang = 65,
+            runic = 66,
+            samaritan = 67,
+            old_south_arabian = 68,
+            saurashtra = 69,
+            shavian = 70,
+            sinhala = 71,
+            sundanese = 72,
+            syloti_nagri = 73,
+            syriac = 74,
+            tagbanwa = 75,
+            tai_le = 76,
+            new_tai_lue = 77,
+            tamil = 78,
+            tai_viet = 79,
+            telugu = 80,
+            tifinagh = 81,
+            tagalog = 82,
+            thaana = 83,
+            thai = 84,
+            tibetan = 85,
+            ugaritic = 86,
+            vai = 87,
+            old_persian = 88,
+            cuneiform = 89,
+            yi = 90,
+            inherited = 91,
+            common = 92,
+            unknown = 93
+        };
+    };
+
+    inline properties::category get_category(::boost::uint32_t ch)
+    {
+        return static_cast<properties::category>(detail::category_lookup(ch) & 0x3F);
+    }
+
+    inline properties::major_category get_major_category(::boost::uint32_t ch)
+    {
+        return static_cast<properties::major_category>(get_category(ch) >> 3);
+    }
+
+    inline bool is_punctuation(::boost::uint32_t ch)
+    {
+        return get_major_category(ch) == properties::punctuation;
+    }
+
+    inline bool is_decimal_number(::boost::uint32_t ch)
+    {
+        return get_category(ch) == properties::decimal_number;
+    }
+
+    inline bool is_hex_digit(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::hex_digit) != 0;
+    }
+
+    inline bool is_control(::boost::uint32_t ch)
+    {
+        return get_category(ch) == properties::control;
+    }
+
+    inline bool is_alphabetic(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::alphabetic) != 0;
+    }
+
+    inline bool is_alphanumeric(::boost::uint32_t ch)
+    {
+        return is_decimal_number(ch) || is_alphabetic(ch);
+    }
+
+    inline bool is_uppercase(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::uppercase) != 0;
+    }
+
+    inline bool is_lowercase(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::lowercase) != 0;
+    }
+
+    inline bool is_white_space(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::white_space) != 0;
+    }
+
+    inline bool is_blank(::boost::uint32_t ch)
+    {
+        switch (ch)
+        {
+            case '\n': case '\v': case '\f': case '\r':
+                return false;
+            default:
+                return is_white_space(ch)
+                && !(   get_category(ch) == properties::line_separator
+                    ||  get_category(ch) == properties::paragraph_separator
+                    );
+        }
+    }
+
+    inline bool is_graph(::boost::uint32_t ch)
+    {
+        return !(   is_white_space(ch)
+                ||  get_category(ch) == properties::control
+                ||  get_category(ch) == properties::surrogate
+                ||  get_category(ch) == properties::unassigned
+                );
+    }
+
+    inline bool is_print(::boost::uint32_t ch)
+    {
+        return (is_graph(ch) || is_blank(ch)) && !is_control(ch);
+    }
+
+    inline bool is_noncharacter_code_point(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::noncharacter_code_point) != 0;
+    }
+
+    inline bool is_default_ignorable_code_point(::boost::uint32_t ch)
+    {
+        return (detail::category_lookup(ch) & properties::default_ignorable_code_point) != 0;
+    }
+
+    inline properties::script get_script(::boost::uint32_t ch)
+    {
+        return static_cast<properties::script>(detail::script_lookup(ch) & 0x3F);
+    }
+
+    inline ::boost::uint32_t to_lowercase(::boost::uint32_t ch)
+    {
+        // The table returns 0 to signal that this code maps to itself
+        ::boost::uint32_t r = detail::lowercase_lookup(ch);
+        return (r == 0)? ch : r;
+    }
+
+    inline ::boost::uint32_t to_uppercase(::boost::uint32_t ch)
+    {
+        // The table returns 0 to signal that this code maps to itself
+        ::boost::uint32_t r = detail::uppercase_lookup(ch);
+        return (r == 0)? ch : r;
+    }
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/script_table.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/script_table.hpp
new file mode 100644
index 0000000..a4c117c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/script_table.hpp
@@ -0,0 +1,2159 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    AUTOGENERATED. DO NOT EDIT!!!
+==============================================================================*/
+#include <boost/cstdint.hpp>
+
+namespace boost { namespace spirit { namespace ucd { namespace detail
+{
+    static const ::boost::uint8_t script_stage1[] = {
+
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15, 
+     16,  17,  18,  19,  20,  20,  21,  22,  23,  24,  25,  26,  27,  28,   1,  29, 
+     30,  31,  32,  33,  34,  32,  35,  36,  37,  32,  32,  38,  39,  40,  41,  42, 
+     43,  44,  45,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  49, 
+     50,  50,  50,  50,  51,  52,  53,  54,  55,  56,  57,  58,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  59,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  47,  61,  62,  60,  63,  64,  65, 
+     66,  67,  68,  69,  70,  60,  60,  60,  71,  72,  73,  74,  75,  60,  60,  60, 
+     76,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     77,  77,  77,  78,  79,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     80,  80,  80,  80,  81,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     82,  83,  84,  85,  86,  87,  88,  89,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     90,  91,  92,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  93,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  94,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  47,  47,  95,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     96,  97,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60
+    };
+
+    static const ::boost::uint8_t script_stage2[] = {
+
+    // block 0
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  92,  92, 
+     92,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  44,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  44,  92,  92,  92,  92,  92, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  92,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  92,  44,  44,  44,  44,  44,  44,  44,  44, 
+
+
+    // block 1
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+
+
+    // block 2
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     44,  44,  44,  44,  44,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 3
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     25,  25,  25,  25,  92,  25,  25,  25,   0,   0,  25,  25,  25,  25,  92,   0, 
+      0,   0,   0,   0,  25,  92,  25,  92,  25,  25,  25,   0,  25,   0,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,   0,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+
+
+    // block 4
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  91,  91,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+
+
+    // block 5
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2, 
+      2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2, 
+      2,   2,   2,   2,   2,   2,   2,   0,   0,   2,   2,   2,   2,   2,   2,   2, 
+      0,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2, 
+      2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2, 
+      2,   2,   2,   2,   2,   2,   2,   2,   0,  92,   2,   0,   0,   0,   0,   0, 
+      0,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,  31,   0,   0,   0,   0,   0,   0,   0,   0, 
+     31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,   0,   0,   0,   0,   0, 
+     31,  31,  31,  31,  31,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 6
+     92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,   0,   0,  92, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0, 
+     91,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 7
+     74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,   0,  74, 
+     74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74, 
+     74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74, 
+     74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74, 
+     74,  74,  74,  74,  74,  74,  74,  74,  74,  74,  74,   0,   0,  74,  74,  74, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83, 
+     83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83, 
+     83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83,  83, 
+     83,  83,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55, 
+     55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55, 
+     55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55, 
+     55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,   0,   0,   0,   0,   0, 
+
+
+    // block 8
+     67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67, 
+     67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67, 
+     67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,   0,   0, 
+     67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,  67,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 9
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,   0,   0,  18,  18,  18,  18, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,   0, 
+     18,  91,  91,  18,  18,  18,   0,   0,  18,  18,  18,  18,  18,  18,  18,  18, 
+     18,  18,  18,  18,  92,  92,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18, 
+     92,  18,  18,   0,   0,   0,   0,   0,   0,  18,  18,  18,  18,  18,  18,  18, 
+      0,   6,   6,   6,   0,   6,   6,   6,   6,   6,   6,   6,   6,   0,   0,   6, 
+      6,   0,   0,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   0,   6,   6,   6,   6,   6,   6, 
+      6,   0,   6,   0,   0,   0,   6,   6,   6,   6,   0,   0,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   0,   0,   6,   6,   0,   0,   6,   6,   6,   6,   0, 
+      0,   0,   0,   0,   0,   0,   0,   6,   0,   0,   0,   0,   6,   6,   0,   6, 
+      6,   6,   6,   6,   0,   0,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   0,   0,   0,   0, 
+
+
+    // block 10
+      0,  27,  27,  27,   0,  27,  27,  27,  27,  27,  27,   0,   0,   0,   0,  27, 
+     27,   0,   0,  27,  27,  27,  27,  27,  27,  27,  27,  27,  27,  27,  27,  27, 
+     27,  27,  27,  27,  27,  27,  27,  27,  27,   0,  27,  27,  27,  27,  27,  27, 
+     27,   0,  27,  27,   0,  27,  27,   0,  27,  27,   0,   0,  27,   0,  27,  27, 
+     27,  27,  27,   0,   0,   0,   0,  27,  27,   0,   0,  27,  27,  27,   0,   0, 
+      0,  27,   0,   0,   0,   0,   0,   0,   0,  27,  27,  27,  27,   0,  27,   0, 
+      0,   0,   0,   0,   0,   0,  27,  27,  27,  27,  27,  27,  27,  27,  27,  27, 
+     27,  27,  27,  27,  27,  27,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,  26,  26,  26,   0,  26,  26,  26,  26,  26,  26,  26,  26,  26,   0,  26, 
+     26,  26,   0,  26,  26,  26,  26,  26,  26,  26,  26,  26,  26,  26,  26,  26, 
+     26,  26,  26,  26,  26,  26,  26,  26,  26,   0,  26,  26,  26,  26,  26,  26, 
+     26,   0,  26,  26,   0,  26,  26,  26,  26,  26,   0,   0,  26,  26,  26,  26, 
+     26,  26,  26,  26,  26,  26,   0,  26,  26,  26,   0,  26,  26,  26,   0,   0, 
+     26,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     26,  26,  26,  26,   0,   0,  26,  26,  26,  26,  26,  26,  26,  26,  26,  26, 
+      0,  26,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 11
+      0,  59,  59,  59,   0,  59,  59,  59,  59,  59,  59,  59,  59,   0,   0,  59, 
+     59,   0,   0,  59,  59,  59,  59,  59,  59,  59,  59,  59,  59,  59,  59,  59, 
+     59,  59,  59,  59,  59,  59,  59,  59,  59,   0,  59,  59,  59,  59,  59,  59, 
+     59,   0,  59,  59,   0,  59,  59,  59,  59,  59,   0,   0,  59,  59,  59,  59, 
+     59,  59,  59,  59,  59,   0,   0,  59,  59,   0,   0,  59,  59,  59,   0,   0, 
+      0,   0,   0,   0,   0,   0,  59,  59,   0,   0,   0,   0,  59,  59,   0,  59, 
+     59,  59,  59,  59,   0,   0,  59,  59,  59,  59,  59,  59,  59,  59,  59,  59, 
+     59,  59,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,  78,  78,   0,  78,  78,  78,  78,  78,  78,   0,   0,   0,  78,  78, 
+     78,   0,  78,  78,  78,  78,   0,   0,   0,  78,  78,   0,  78,   0,  78,  78, 
+      0,   0,   0,  78,  78,   0,   0,   0,  78,  78,  78,   0,   0,   0,  78,  78, 
+     78,  78,  78,  78,  78,  78,  78,  78,  78,  78,   0,   0,   0,   0,  78,  78, 
+     78,  78,  78,   0,   0,   0,  78,  78,  78,   0,  78,  78,  78,  78,   0,   0, 
+     78,   0,   0,   0,   0,   0,   0,  78,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,  78,  78,  78,  78,  78,  78,  78,  78,  78,  78, 
+     78,  78,  78,  78,  78,  78,  78,  78,  78,  78,  78,   0,   0,   0,   0,   0, 
+
+
+    // block 12
+      0,  80,  80,  80,   0,  80,  80,  80,  80,  80,  80,  80,  80,   0,  80,  80, 
+     80,   0,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80, 
+     80,  80,  80,  80,  80,  80,  80,  80,  80,   0,  80,  80,  80,  80,  80,  80, 
+     80,  80,  80,  80,   0,  80,  80,  80,  80,  80,   0,   0,   0,  80,  80,  80, 
+     80,  80,  80,  80,  80,   0,  80,  80,  80,   0,  80,  80,  80,  80,   0,   0, 
+      0,   0,   0,   0,   0,  80,  80,   0,  80,  80,   0,   0,   0,   0,   0,   0, 
+     80,  80,  80,  80,   0,   0,  80,  80,  80,  80,  80,  80,  80,  80,  80,  80, 
+      0,   0,   0,   0,   0,   0,   0,   0,  80,  80,  80,  80,  80,  80,  80,  80, 
+      0,   0,  40,  40,   0,  40,  40,  40,  40,  40,  40,  40,  40,   0,  40,  40, 
+     40,   0,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40, 
+     40,  40,  40,  40,  40,  40,  40,  40,  40,   0,  40,  40,  40,  40,  40,  40, 
+     40,  40,  40,  40,   0,  40,  40,  40,  40,  40,   0,   0,  40,  40,  40,  40, 
+     40,  40,  40,  40,  40,   0,  40,  40,  40,   0,  40,  40,  40,  40,   0,   0, 
+      0,   0,   0,   0,   0,  40,  40,   0,   0,   0,   0,   0,   0,   0,  40,   0, 
+     40,  40,  40,  40,   0,   0,  40,  40,  40,  40,  40,  40,  40,  40,  40,  40, 
+      0,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 13
+      0,   0,  51,  51,   0,  51,  51,  51,  51,  51,  51,  51,  51,   0,  51,  51, 
+     51,   0,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51, 
+     51,  51,  51,  51,  51,  51,  51,  51,  51,   0,  51,  51,  51,  51,  51,  51, 
+     51,  51,  51,  51,  51,  51,  51,  51,  51,  51,   0,   0,   0,  51,  51,  51, 
+     51,  51,  51,  51,  51,   0,  51,  51,  51,   0,  51,  51,  51,  51,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,  51,   0,   0,   0,   0,   0,   0,   0,   0, 
+     51,  51,  51,  51,   0,   0,  51,  51,  51,  51,  51,  51,  51,  51,  51,  51, 
+     51,  51,  51,  51,  51,  51,   0,   0,   0,  51,  51,  51,  51,  51,  51,  51, 
+      0,   0,  71,  71,   0,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71, 
+     71,  71,  71,  71,  71,  71,  71,   0,   0,   0,  71,  71,  71,  71,  71,  71, 
+     71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71,  71, 
+     71,  71,   0,  71,  71,  71,  71,  71,  71,  71,  71,  71,   0,  71,   0,   0, 
+     71,  71,  71,  71,  71,  71,  71,   0,   0,   0,  71,   0,   0,   0,   0,  71, 
+     71,  71,  71,  71,  71,   0,  71,   0,  71,  71,  71,  71,  71,  71,  71,  71, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,  71,  71,  71,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 14
+      0,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84, 
+     84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84, 
+     84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84, 
+     84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,   0,   0,   0,   0,  92, 
+     84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84, 
+     84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,  84,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,  43,  43,   0,  43,   0,   0,  43,  43,   0,  43,   0,   0,  43,   0,   0, 
+      0,   0,   0,   0,  43,  43,  43,  43,   0,  43,  43,  43,  43,  43,  43,  43, 
+      0,  43,  43,  43,   0,  43,   0,  43,   0,   0,  43,  43,   0,  43,  43,  43, 
+     43,  43,  43,  43,  43,  43,  43,  43,  43,  43,   0,  43,  43,  43,   0,   0, 
+     43,  43,  43,  43,  43,   0,  43,   0,  43,  43,  43,  43,  43,  43,   0,   0, 
+     43,  43,  43,  43,  43,  43,  43,  43,  43,  43,   0,   0,  43,  43,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 15
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,   0,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,   0,   0,   0, 
+      0,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,   0,   0,   0,   0, 
+     85,  85,  85,  85,  85,  85,  85,  85,   0,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,   0,  85,  85, 
+     85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,  85,   0,  85,  85, 
+     85,  85,  85,  85,  85,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 16
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  92,  22,   0,   0,   0, 
+
+
+    // block 17
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+
+
+    // block 18
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,   0,  21,  21,  21,  21,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,   0,  21,  21,  21,  21,   0,   0,  21,  21,  21,  21,  21,  21,  21,   0, 
+     21,   0,  21,  21,  21,  21,   0,   0,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+
+
+    // block 19
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,   0,  21,  21,  21,  21,   0,   0,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,   0,   0,   0,   0,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,   0,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,   0,   0,   0,   0,   0,   0, 
+     14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14, 
+     14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14, 
+     14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14, 
+     14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14, 
+     14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14, 
+     14,  14,  14,  14,  14,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 20
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+
+
+    // block 21
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56, 
+     56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,  56,   0,   0,   0, 
+     66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66, 
+     66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66, 
+     66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66, 
+     66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66, 
+     66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  66,  92,  92,  92,  66,  66, 
+     66,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 22
+     82,  82,  82,  82,  82,  82,  82,  82,  82,  82,  82,  82,  82,   0,  82,  82, 
+     82,  82,  82,  82,  82,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30, 
+     30,  30,  30,  30,  30,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10,  10, 
+     10,  10,  10,  10,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     75,  75,  75,  75,  75,  75,  75,  75,  75,  75,  75,  75,  75,   0,  75,  75, 
+     75,   0,  75,  75,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,   0,   0, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,   0,   0,   0,   0,   0,   0, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 23
+     52,  52,  92,  92,  52,  92,  52,  52,  52,  52,  52,  52,  52,  52,  52,   0, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,   0,   0,   0,   0,   0,   0, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,   0,   0,   0,   0,   0,   0,   0,   0, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52, 
+     52,  52,  52,  52,  52,  52,  52,  52,  52,  52,  52,   0,   0,   0,   0,   0, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11, 
+     11,  11,  11,  11,  11,  11,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 24
+     46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46, 
+     46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,   0,   0,   0, 
+     46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,   0,   0,   0,   0, 
+     46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,   0,   0,   0,   0, 
+     46,   0,   0,   0,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46,  46, 
+     76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76, 
+     76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,  76,   0,   0, 
+     76,  76,  76,  76,  76,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,   0,   0,   0,   0, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,   0,   0,   0,   0,   0,   0, 
+     77,  77,  77,  77,  77,  77,  77,  77,  77,  77,  77,   0,   0,   0,  77,  77, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+     39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39,  39, 
+
+
+    // block 25
+      9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9, 
+      9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   0,   0,   9,   9, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,   0, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,   0,   0,  42, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,   0,   0,   0,   0,   0,   0, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,   0,   0,   0,   0,   0,   0, 
+     42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 26
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   0,   0,   0,   0, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4, 
+      4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   0,   0,   0, 
+     72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72, 
+     72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72, 
+     72,  72,  72,  72,  72,  72,  72,  72,  72,  72,  72,   0,   0,   0,  72,  72, 
+     72,  72,  72,  72,  72,  72,  72,  72,  72,  72,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 27
+     45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45, 
+     45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45, 
+     45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45, 
+     45,  45,  45,  45,  45,  45,  45,  45,   0,   0,   0,  45,  45,  45,  45,  45, 
+     45,  45,  45,  45,  45,  45,  45,  45,  45,  45,   0,   0,   0,  45,  45,  45, 
+     57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57, 
+     57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57, 
+     57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57,  57, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     91,  91,  91,  92,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  92,  91,  91,  91,  91,  91,  91,  91,  92,  92,  92,  92,  91,  92,  92, 
+     92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 28
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  25,  25,  25,  25,  25,  17,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  25,  25,  25, 
+     25,  25,  44,  44,  44,  44,  25,  25,  25,  25,  25,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  17,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  25, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  91,  91,  91, 
+
+
+    // block 29
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,   0,   0,  25,  25,  25,  25,  25,  25,   0,   0, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,   0,   0,  25,  25,  25,  25,  25,  25,   0,   0, 
+     25,  25,  25,  25,  25,  25,  25,  25,   0,  25,   0,  25,   0,  25,   0,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,   0,   0, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,   0,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,   0,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,   0,   0,  25,  25,  25,  25,  25,  25,   0,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+      0,   0,  25,  25,  25,   0,  25,  25,  25,  25,  25,  25,  25,  25,  25,   0, 
+
+
+    // block 30
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  91,  91,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,   0,   0,   0,   0,   0,  92,  92,  92,  92,  92,  92, 
+     92,  44,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  44, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0, 
+     44,  44,  44,  44,  44,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 31
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  25,  92,  92,  92,  44,  44,  92,  92,  92,  92, 
+     92,  92,  44,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  44,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  92,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 32
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 33
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 34
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 35
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,   0,  92,   0,   0,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 36
+      0,  92,  92,  92,  92,   0,  92,  92,  92,  92,   0,   0,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92,   0,  92, 
+     92,  92,  92,   0,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0, 
+      0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,   0,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+      0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 37
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+      8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8, 
+
+
+    // block 38
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 39
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23, 
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23, 
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,   0, 
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23, 
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23, 
+     23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,   0, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15, 
+     15,  15,   0,   0,   0,   0,   0,   0,   0,  15,  15,  15,  15,  15,  15,  15, 
+
+
+    // block 40
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22,  22, 
+     22,  22,  22,  22,  22,  22,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81, 
+     81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81, 
+     81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81,  81, 
+     81,  81,  81,  81,  81,  81,   0,   0,   0,   0,   0,   0,   0,   0,   0,  81, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21, 
+     21,  21,  21,  21,  21,  21,  21,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,  21,  21,  21,   0, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,  21,  21,  21,   0, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,  21,  21,  21,   0, 
+     21,  21,  21,  21,  21,  21,  21,   0,  21,  21,  21,  21,  21,  21,  21,   0, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+
+
+    // block 41
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 42
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0, 
+
+
+    // block 43
+     92,  92,  92,  92,  92,  29,  92,  29,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  29,  29,  29,  29,  29,  29,  29,  29,  29,  91,  91,  91,  91,  91,  91, 
+     92,  92,  92,  92,  92,  92,  92,  92,  29,  29,  29,  29,  92,  92,  92,  92, 
+      0,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32,  32,   0,   0,  91,  91,  92,  92,  32,  32,  32, 
+     92,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  92,  92,  37,  37,  37, 
+
+
+    // block 44
+      0,   0,   0,   0,   0,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7, 
+      7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7, 
+      7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   0,   0, 
+      0,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+      7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7, 
+      7,   7,   7,   7,   7,   7,   7,   7,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+
+
+    // block 45
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,   0, 
+
+
+    // block 46
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 47
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+
+
+    // block 48
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 49
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 50
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+
+
+    // block 51
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,   0,   0,   0, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90, 
+     90,  90,  90,  90,  90,  90,  90,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48, 
+     48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48, 
+     48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48,  48, 
+
+
+    // block 52
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+
+
+    // block 53
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87, 
+     87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,  87,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+      0,   0,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,   0,   0,   0,   0,   0,   0,   0,   0,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17, 
+     17,  17,  17,  17,  17,  17,  17,  17,   0,   0,   0,   0,   0,   0,   0,   0, 
+      5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5, 
+      5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5, 
+      5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5, 
+      5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5, 
+      5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5, 
+      5,   5,   5,   5,   5,   5,   5,   5,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 54
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  44,  44,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  44,  44,  44,  44,  44, 
+
+
+    // block 55
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73, 
+     73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,  73,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0, 
+     61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61, 
+     61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61, 
+     61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61,  61, 
+     61,  61,  61,  61,  61,  61,  61,  61,   0,   0,   0,   0,   0,   0,   0,   0, 
+     69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69, 
+     69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69, 
+     69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69, 
+     69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69,  69, 
+     69,  69,  69,  69,  69,   0,   0,   0,   0,   0,   0,   0,   0,   0,  69,  69, 
+     69,  69,  69,  69,  69,  69,  69,  69,  69,  69,   0,   0,   0,   0,   0,   0, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18, 
+     18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,   0,   0,   0,   0, 
+
+
+    // block 56
+     36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36, 
+     36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36, 
+     36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36,  36, 
+     65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65, 
+     65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  65, 
+     65,  65,  65,  65,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  65, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,   0,   0,   0, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,   0,  35, 
+     35,  35,  35,  35,  35,  35,  35,  35,  35,  35,   0,   0,   0,   0,  35,  35, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 57
+     13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13, 
+     13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13, 
+     13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13, 
+     13,  13,  13,  13,  13,  13,  13,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,   0,   0, 
+     13,  13,  13,  13,  13,  13,  13,  13,  13,  13,   0,   0,  13,  13,  13,  13, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54, 
+     54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,  54,   0,   0,   0,   0, 
+     79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79, 
+     79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79, 
+     79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79, 
+     79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79, 
+     79,  79,  79,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  79,  79,  79,  79,  79, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 58
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53, 
+     53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53, 
+     53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,   0,   0, 
+     53,  53,  53,  53,  53,  53,  53,  53,  53,  53,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 59
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,   0,   0,   0,   0,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,   0,   0,   0,   0, 
+
+
+    // block 60
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 61
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,   0, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,   0, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 62
+     44,  44,  44,  44,  44,  44,  44,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   2,   2,   2,   2,   2,   0,   0,   0,   0,   0,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+     31,  31,  31,  31,  31,  31,  31,   0,  31,  31,  31,  31,  31,   0,  31,   0, 
+     31,  31,   0,  31,  31,   0,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 63
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,  92, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,   0, 
+
+
+    // block 64
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0, 
+     91,  91,  91,  91,  91,  91,  91,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,   0,  92,  92,  92,  92,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92, 
+
+
+    // block 65
+      0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  92,  92, 
+     92,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44, 
+     44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     92,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37, 
+     37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  37,  92,  92, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28, 
+     28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,   0, 
+      0,   0,  28,  28,  28,  28,  28,  28,   0,   0,  28,  28,  28,  28,  28,  28, 
+      0,   0,  28,  28,  28,  28,  28,  28,   0,   0,  28,  28,  28,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,  92,  92,  92,  92,  92,   0,   0, 
+
+
+    // block 66
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,   0,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,   0,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,   0,  47,  47,   0,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,   0,   0, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47,  47,  47,  47,  47,  47,   0,   0,   0,   0,   0, 
+
+
+    // block 67
+     92,  92,  92,   0,   0,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,   0,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  91,   0,   0, 
+
+
+    // block 68
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49, 
+     49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,  49,   0,   0,   0, 
+     12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12, 
+     12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12, 
+     12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,  12, 
+     12,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 69
+     34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34, 
+     34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,   0, 
+     34,  34,  34,  34,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24, 
+     24,  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86, 
+     86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,  86,   0,  86, 
+     88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88, 
+     88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88,  88, 
+     88,  88,  88,  88,   0,   0,   0,   0,  88,  88,  88,  88,  88,  88,  88,  88, 
+     88,  88,  88,  88,  88,  88,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 70
+     19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19, 
+     19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19, 
+     19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19, 
+     19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19, 
+     19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19, 
+     70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70, 
+     70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70, 
+     70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70,  70, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,  60,   0,   0, 
+     60,  60,  60,  60,  60,  60,  60,  60,  60,  60,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 71
+     16,  16,  16,  16,  16,  16,   0,   0,  16,   0,  16,  16,  16,  16,  16,  16, 
+     16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16, 
+     16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16, 
+     16,  16,  16,  16,  16,  16,   0,  16,  16,   0,   0,   0,  16,   0,   0,  16, 
+      1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1, 
+      1,   1,   1,   1,   1,   1,   0,   1,   1,   1,   1,   1,   1,   1,   1,   1, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 72
+     63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63, 
+     63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,  63,   0,   0,   0,  63, 
+     50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50, 
+     50,  50,  50,  50,  50,  50,  50,  50,  50,  50,   0,   0,   0,   0,   0,  50, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 73
+     38,  38,  38,  38,   0,  38,  38,   0,   0,   0,   0,   0,  38,  38,  38,  38, 
+     38,  38,  38,  38,   0,  38,  38,  38,   0,  38,  38,  38,  38,  38,  38,  38, 
+     38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38,  38, 
+     38,  38,  38,  38,   0,   0,   0,   0,  38,  38,  38,   0,   0,   0,   0,  38, 
+     38,  38,  38,  38,  38,  38,  38,  38,   0,   0,   0,   0,   0,   0,   0,   0, 
+     38,  38,  38,  38,  38,  38,  38,  38,  38,   0,   0,   0,   0,   0,   0,   0, 
+     68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68, 
+     68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 74
+      3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3, 
+      3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3, 
+      3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3, 
+      3,   3,   3,   3,   3,   3,   0,   0,   0,   3,   3,   3,   3,   3,   3,   3, 
+     64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64, 
+     64,  64,  64,  64,  64,  64,   0,   0,  64,  64,  64,  64,  64,  64,  64,  64, 
+     62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62,  62, 
+     62,  62,  62,   0,   0,   0,   0,   0,  62,  62,  62,  62,  62,  62,  62,  62, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 75
+     58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58, 
+     58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58, 
+     58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58, 
+     58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58,  58, 
+     58,  58,  58,  58,  58,  58,  58,  58,  58,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 76
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41, 
+     41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41, 
+     41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41, 
+     41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41,  41, 
+     41,  41,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 77
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+
+
+    // block 78
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 79
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89,  89, 
+     89,  89,  89,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     89,  89,  89,  89,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 80
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+
+
+    // block 81
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20, 
+     20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,  20,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 82
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 83
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,   0,   0,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  91,  91,  91,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  91,  91,  91,  91,  91, 
+     91,  91,  91,  92,  92,  91,  91,  91,  91,  91,  91,  91,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  91,  91,  91,  91,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 84
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,  25, 
+     25,  25,  25,  25,  25,  25,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 85
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 86
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92,  92, 
+      0,   0,  92,   0,   0,  92,  92,   0,   0,  92,  92,  92,  92,   0,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92,   0,  92,  92,  92, 
+     92,  92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 87
+     92,  92,  92,  92,  92,  92,   0,  92,  92,  92,  92,   0,   0,  92,  92,  92, 
+     92,  92,  92,  92,  92,   0,  92,  92,  92,  92,  92,  92,  92,   0,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,  92,  92,  92,  92,   0, 
+     92,  92,  92,  92,  92,   0,  92,   0,   0,   0,  92,  92,  92,  92,  92,  92, 
+     92,   0,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 88
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,   0,   0,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 89
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+
+
+    // block 90
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 91
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,   0, 
+      0,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,  92, 
+      0,   0,  92,   0,   0,   0,  92,   0,   0,   0,  92,  92,  92,  92,  92,   0, 
+      0,   0,   0,   0,   0,   0,   0,  92,   0,   0,   0,   0,   0,   0,   0,  92, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,  92,   0,  92,  92,   0,   0,  92, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  92,  92,  92,  92,   0,   0, 
+     92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 92
+     32,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 93
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 94
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 95
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29, 
+     29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,  29,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 96
+      0,  92,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+     92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92,  92, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
+
+
+    // block 97
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+     91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91, 
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0
+    };
+
+    inline ::boost::uint8_t script_lookup(::boost::uint32_t ch)
+    {
+        ::boost::uint32_t block_offset = script_stage1[ch / 256] * 256;
+        return script_stage2[block_offset + ch % 256];
+    }
+
+}}}} // namespace boost::spirit::unicode::detail
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/uppercase_table.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/uppercase_table.hpp
new file mode 100644
index 0000000..5ecae7c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/uppercase_table.hpp
@@ -0,0 +1,639 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    AUTOGENERATED. DO NOT EDIT!!!
+==============================================================================*/
+#include <boost/cstdint.hpp>
+
+namespace boost { namespace spirit { namespace ucd { namespace detail
+{
+    static const ::boost::uint8_t uppercase_stage1[] = {
+
+      0,   1,   2,   3,   4,   5,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   7,   8,   9, 
+      6,  10,   6,   6,  11,   6,   6,   6,   6,   6,   6,   6,  12,  13,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,  14,  15,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,  16, 
+      6,   6,   6,   6,  17,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6, 
+      6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6
+    };
+
+    static const ::boost::uint32_t uppercase_stage2[] = {
+
+    // block 0
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,     65,     66,     67,     68,     69,     70,     71,     72,     73,     74,     75,     76,     77,     78,     79, 
+        80,     81,     82,     83,     84,     85,     86,     87,     88,     89,     90,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,    924,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+       192,    193,    194,    195,    196,    197,    198,    199,    200,    201,    202,    203,    204,    205,    206,    207, 
+       208,    209,    210,    211,    212,    213,    214,      0,    216,    217,    218,    219,    220,    221,    222,    376, 
+
+
+    // block 1
+         0,    256,      0,    258,      0,    260,      0,    262,      0,    264,      0,    266,      0,    268,      0,    270, 
+         0,    272,      0,    274,      0,    276,      0,    278,      0,    280,      0,    282,      0,    284,      0,    286, 
+         0,    288,      0,    290,      0,    292,      0,    294,      0,    296,      0,    298,      0,    300,      0,    302, 
+         0,     73,      0,    306,      0,    308,      0,    310,      0,      0,    313,      0,    315,      0,    317,      0, 
+       319,      0,    321,      0,    323,      0,    325,      0,    327,      0,      0,    330,      0,    332,      0,    334, 
+         0,    336,      0,    338,      0,    340,      0,    342,      0,    344,      0,    346,      0,    348,      0,    350, 
+         0,    352,      0,    354,      0,    356,      0,    358,      0,    360,      0,    362,      0,    364,      0,    366, 
+         0,    368,      0,    370,      0,    372,      0,    374,      0,      0,    377,      0,    379,      0,    381,     83, 
+       579,      0,      0,    386,      0,    388,      0,      0,    391,      0,      0,      0,    395,      0,      0,      0, 
+         0,      0,    401,      0,      0,    502,      0,      0,      0,    408,    573,      0,      0,      0,    544,      0, 
+         0,    416,      0,    418,      0,    420,      0,      0,    423,      0,      0,      0,      0,    428,      0,      0, 
+       431,      0,      0,      0,    435,      0,    437,      0,      0,    440,      0,      0,      0,    444,      0,    503, 
+         0,      0,      0,      0,      0,    452,    452,      0,    455,    455,      0,    458,    458,      0,    461,      0, 
+       463,      0,    465,      0,    467,      0,    469,      0,    471,      0,    473,      0,    475,    398,      0,    478, 
+         0,    480,      0,    482,      0,    484,      0,    486,      0,    488,      0,    490,      0,    492,      0,    494, 
+         0,      0,    497,    497,      0,    500,      0,      0,      0,    504,      0,    506,      0,    508,      0,    510, 
+
+
+    // block 2
+         0,    512,      0,    514,      0,    516,      0,    518,      0,    520,      0,    522,      0,    524,      0,    526, 
+         0,    528,      0,    530,      0,    532,      0,    534,      0,    536,      0,    538,      0,    540,      0,    542, 
+         0,      0,      0,    546,      0,    548,      0,    550,      0,    552,      0,    554,      0,    556,      0,    558, 
+         0,    560,      0,    562,      0,      0,      0,      0,      0,      0,      0,      0,    571,      0,      0,      0, 
+         0,      0,    577,      0,      0,      0,      0,    582,      0,    584,      0,    586,      0,    588,      0,    590, 
+     11375,  11373,      0,    385,    390,      0,    393,    394,      0,    399,      0,    400,      0,      0,      0,      0, 
+       403,      0,      0,    404,      0,      0,      0,      0,    407,    406,      0,  11362,      0,      0,      0,    412, 
+         0,  11374,    413,      0,      0,    415,      0,      0,      0,      0,      0,      0,      0,  11364,      0,      0, 
+       422,      0,      0,    425,      0,      0,      0,      0,    430,    580,    433,    434,    581,      0,      0,      0, 
+         0,      0,    439,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 3
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,    921,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,    880,      0,    882,      0,      0,      0,    886,      0,      0,      0,   1021,   1022,   1023,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,    902,    904,    905,    906, 
+         0,    913,    914,    915,    916,    917,    918,    919,    920,    921,    922,    923,    924,    925,    926,    927, 
+       928,    929,    931,    931,    932,    933,    934,    935,    936,    937,    938,    939,    908,    910,    911,      0, 
+       914,    920,      0,      0,      0,    934,    928,    975,      0,    984,      0,    986,      0,    988,      0,    990, 
+         0,    992,      0,    994,      0,    996,      0,    998,      0,   1000,      0,   1002,      0,   1004,      0,   1006, 
+       922,    929,   1017,      0,      0,    917,      0,      0,   1015,      0,      0,   1018,      0,      0,      0,      0, 
+
+
+    // block 4
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      1040,   1041,   1042,   1043,   1044,   1045,   1046,   1047,   1048,   1049,   1050,   1051,   1052,   1053,   1054,   1055, 
+      1056,   1057,   1058,   1059,   1060,   1061,   1062,   1063,   1064,   1065,   1066,   1067,   1068,   1069,   1070,   1071, 
+      1024,   1025,   1026,   1027,   1028,   1029,   1030,   1031,   1032,   1033,   1034,   1035,   1036,   1037,   1038,   1039, 
+         0,   1120,      0,   1122,      0,   1124,      0,   1126,      0,   1128,      0,   1130,      0,   1132,      0,   1134, 
+         0,   1136,      0,   1138,      0,   1140,      0,   1142,      0,   1144,      0,   1146,      0,   1148,      0,   1150, 
+         0,   1152,      0,      0,      0,      0,      0,      0,      0,      0,      0,   1162,      0,   1164,      0,   1166, 
+         0,   1168,      0,   1170,      0,   1172,      0,   1174,      0,   1176,      0,   1178,      0,   1180,      0,   1182, 
+         0,   1184,      0,   1186,      0,   1188,      0,   1190,      0,   1192,      0,   1194,      0,   1196,      0,   1198, 
+         0,   1200,      0,   1202,      0,   1204,      0,   1206,      0,   1208,      0,   1210,      0,   1212,      0,   1214, 
+         0,      0,   1217,      0,   1219,      0,   1221,      0,   1223,      0,   1225,      0,   1227,      0,   1229,   1216, 
+         0,   1232,      0,   1234,      0,   1236,      0,   1238,      0,   1240,      0,   1242,      0,   1244,      0,   1246, 
+         0,   1248,      0,   1250,      0,   1252,      0,   1254,      0,   1256,      0,   1258,      0,   1260,      0,   1262, 
+         0,   1264,      0,   1266,      0,   1268,      0,   1270,      0,   1272,      0,   1274,      0,   1276,      0,   1278, 
+
+
+    // block 5
+         0,   1280,      0,   1282,      0,   1284,      0,   1286,      0,   1288,      0,   1290,      0,   1292,      0,   1294, 
+         0,   1296,      0,   1298,      0,   1300,      0,   1302,      0,   1304,      0,   1306,      0,   1308,      0,   1310, 
+         0,   1312,      0,   1314,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,   1329,   1330,   1331,   1332,   1333,   1334,   1335,   1336,   1337,   1338,   1339,   1340,   1341,   1342,   1343, 
+      1344,   1345,   1346,   1347,   1348,   1349,   1350,   1351,   1352,   1353,   1354,   1355,   1356,   1357,   1358,   1359, 
+      1360,   1361,   1362,   1363,   1364,   1365,   1366,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 6
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 7
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,  42877,      0,      0,      0,  11363,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 8
+         0,   7680,      0,   7682,      0,   7684,      0,   7686,      0,   7688,      0,   7690,      0,   7692,      0,   7694, 
+         0,   7696,      0,   7698,      0,   7700,      0,   7702,      0,   7704,      0,   7706,      0,   7708,      0,   7710, 
+         0,   7712,      0,   7714,      0,   7716,      0,   7718,      0,   7720,      0,   7722,      0,   7724,      0,   7726, 
+         0,   7728,      0,   7730,      0,   7732,      0,   7734,      0,   7736,      0,   7738,      0,   7740,      0,   7742, 
+         0,   7744,      0,   7746,      0,   7748,      0,   7750,      0,   7752,      0,   7754,      0,   7756,      0,   7758, 
+         0,   7760,      0,   7762,      0,   7764,      0,   7766,      0,   7768,      0,   7770,      0,   7772,      0,   7774, 
+         0,   7776,      0,   7778,      0,   7780,      0,   7782,      0,   7784,      0,   7786,      0,   7788,      0,   7790, 
+         0,   7792,      0,   7794,      0,   7796,      0,   7798,      0,   7800,      0,   7802,      0,   7804,      0,   7806, 
+         0,   7808,      0,   7810,      0,   7812,      0,   7814,      0,   7816,      0,   7818,      0,   7820,      0,   7822, 
+         0,   7824,      0,   7826,      0,   7828,      0,      0,      0,      0,      0,   7776,      0,      0,      0,      0, 
+         0,   7840,      0,   7842,      0,   7844,      0,   7846,      0,   7848,      0,   7850,      0,   7852,      0,   7854, 
+         0,   7856,      0,   7858,      0,   7860,      0,   7862,      0,   7864,      0,   7866,      0,   7868,      0,   7870, 
+         0,   7872,      0,   7874,      0,   7876,      0,   7878,      0,   7880,      0,   7882,      0,   7884,      0,   7886, 
+         0,   7888,      0,   7890,      0,   7892,      0,   7894,      0,   7896,      0,   7898,      0,   7900,      0,   7902, 
+         0,   7904,      0,   7906,      0,   7908,      0,   7910,      0,   7912,      0,   7914,      0,   7916,      0,   7918, 
+         0,   7920,      0,   7922,      0,   7924,      0,   7926,      0,   7928,      0,   7930,      0,   7932,      0,   7934, 
+
+
+    // block 9
+      7944,   7945,   7946,   7947,   7948,   7949,   7950,   7951,      0,      0,      0,      0,      0,      0,      0,      0, 
+      7960,   7961,   7962,   7963,   7964,   7965,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      7976,   7977,   7978,   7979,   7980,   7981,   7982,   7983,      0,      0,      0,      0,      0,      0,      0,      0, 
+      7992,   7993,   7994,   7995,   7996,   7997,   7998,   7999,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8008,   8009,   8010,   8011,   8012,   8013,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,   8025,      0,   8027,      0,   8029,      0,   8031,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8040,   8041,   8042,   8043,   8044,   8045,   8046,   8047,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8122,   8123,   8136,   8137,   8138,   8139,   8154,   8155,   8184,   8185,   8170,   8171,   8186,   8187,      0,      0, 
+      8072,   8073,   8074,   8075,   8076,   8077,   8078,   8079,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8088,   8089,   8090,   8091,   8092,   8093,   8094,   8095,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8104,   8105,   8106,   8107,   8108,   8109,   8110,   8111,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8120,   8121,      0,   8124,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,    921,      0, 
+         0,      0,      0,   8140,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8152,   8153,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8168,   8169,      0,      0,      0,   8172,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,   8188,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 10
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,   8498,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      8544,   8545,   8546,   8547,   8548,   8549,   8550,   8551,   8552,   8553,   8554,   8555,   8556,   8557,   8558,   8559, 
+         0,      0,      0,      0,   8579,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 11
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+      9398,   9399,   9400,   9401,   9402,   9403,   9404,   9405,   9406,   9407,   9408,   9409,   9410,   9411,   9412,   9413, 
+      9414,   9415,   9416,   9417,   9418,   9419,   9420,   9421,   9422,   9423,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 12
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+     11264,  11265,  11266,  11267,  11268,  11269,  11270,  11271,  11272,  11273,  11274,  11275,  11276,  11277,  11278,  11279, 
+     11280,  11281,  11282,  11283,  11284,  11285,  11286,  11287,  11288,  11289,  11290,  11291,  11292,  11293,  11294,  11295, 
+     11296,  11297,  11298,  11299,  11300,  11301,  11302,  11303,  11304,  11305,  11306,  11307,  11308,  11309,  11310,      0, 
+         0,  11360,      0,      0,      0,    570,    574,      0,  11367,      0,  11369,      0,  11371,      0,      0,      0, 
+         0,      0,      0,  11378,      0,      0,  11381,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,  11392,      0,  11394,      0,  11396,      0,  11398,      0,  11400,      0,  11402,      0,  11404,      0,  11406, 
+         0,  11408,      0,  11410,      0,  11412,      0,  11414,      0,  11416,      0,  11418,      0,  11420,      0,  11422, 
+         0,  11424,      0,  11426,      0,  11428,      0,  11430,      0,  11432,      0,  11434,      0,  11436,      0,  11438, 
+         0,  11440,      0,  11442,      0,  11444,      0,  11446,      0,  11448,      0,  11450,      0,  11452,      0,  11454, 
+         0,  11456,      0,  11458,      0,  11460,      0,  11462,      0,  11464,      0,  11466,      0,  11468,      0,  11470, 
+         0,  11472,      0,  11474,      0,  11476,      0,  11478,      0,  11480,      0,  11482,      0,  11484,      0,  11486, 
+         0,  11488,      0,  11490,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 13
+      4256,   4257,   4258,   4259,   4260,   4261,   4262,   4263,   4264,   4265,   4266,   4267,   4268,   4269,   4270,   4271, 
+      4272,   4273,   4274,   4275,   4276,   4277,   4278,   4279,   4280,   4281,   4282,   4283,   4284,   4285,   4286,   4287, 
+      4288,   4289,   4290,   4291,   4292,   4293,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 14
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,  42560,      0,  42562,      0,  42564,      0,  42566,      0,  42568,      0,  42570,      0,  42572,      0,  42574, 
+         0,  42576,      0,  42578,      0,  42580,      0,  42582,      0,  42584,      0,  42586,      0,  42588,      0,  42590, 
+         0,      0,      0,  42594,      0,  42596,      0,  42598,      0,  42600,      0,  42602,      0,  42604,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,  42624,      0,  42626,      0,  42628,      0,  42630,      0,  42632,      0,  42634,      0,  42636,      0,  42638, 
+         0,  42640,      0,  42642,      0,  42644,      0,  42646,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 15
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,  42786,      0,  42788,      0,  42790,      0,  42792,      0,  42794,      0,  42796,      0,  42798, 
+         0,      0,      0,  42802,      0,  42804,      0,  42806,      0,  42808,      0,  42810,      0,  42812,      0,  42814, 
+         0,  42816,      0,  42818,      0,  42820,      0,  42822,      0,  42824,      0,  42826,      0,  42828,      0,  42830, 
+         0,  42832,      0,  42834,      0,  42836,      0,  42838,      0,  42840,      0,  42842,      0,  42844,      0,  42846, 
+         0,  42848,      0,  42850,      0,  42852,      0,  42854,      0,  42856,      0,  42858,      0,  42860,      0,  42862, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,  42873,      0,  42875,      0,      0,  42878, 
+         0,  42880,      0,  42882,      0,  42884,      0,  42886,      0,      0,      0,      0,  42891,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 16
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,  65313,  65314,  65315,  65316,  65317,  65318,  65319,  65320,  65321,  65322,  65323,  65324,  65325,  65326,  65327, 
+     65328,  65329,  65330,  65331,  65332,  65333,  65334,  65335,  65336,  65337,  65338,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+
+
+    // block 17
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,  66560,  66561,  66562,  66563,  66564,  66565,  66566,  66567, 
+     66568,  66569,  66570,  66571,  66572,  66573,  66574,  66575,  66576,  66577,  66578,  66579,  66580,  66581,  66582,  66583, 
+     66584,  66585,  66586,  66587,  66588,  66589,  66590,  66591,  66592,  66593,  66594,  66595,  66596,  66597,  66598,  66599, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0, 
+         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
+    };
+
+    inline ::boost::uint32_t uppercase_lookup(::boost::uint32_t ch)
+    {
+        ::boost::uint32_t block_offset = uppercase_stage1[ch / 256] * 256;
+        return uppercase_stage2[block_offset + ch % 256];
+    }
+
+}}}} // namespace boost::spirit::unicode::detail
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/common_terminals.hpp b/3rdParty/Boost/src/boost/spirit/home/support/common_terminals.hpp
new file mode 100644
index 0000000..2c7772d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/common_terminals.hpp
@@ -0,0 +1,437 @@
+/*=============================================================================
+  Copyright (c) 2001-2011 Joel de Guzman
+  http://spirit.sourceforge.net/
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_COMMON_PLACEHOLDERS_OCTOBER_16_2008_0102PM
+#define BOOST_SPIRIT_COMMON_PLACEHOLDERS_OCTOBER_16_2008_0102PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/terminal.hpp>
+#include <boost/spirit/home/support/char_encoding/standard.hpp>
+#include <boost/spirit/home/support/char_encoding/standard_wide.hpp>
+#include <boost/spirit/home/support/char_encoding/ascii.hpp>
+#include <boost/spirit/home/support/char_encoding/iso8859_1.hpp>
+#include <boost/spirit/home/support/char_class.hpp>
+#include <boost/mpl/vector.hpp>
+
+#if defined(BOOST_SPIRIT_UNICODE)
+# include <boost/spirit/home/support/char_encoding/unicode.hpp>
+#endif
+
+namespace boost { namespace spirit
+{
+    typedef mpl::vector<
+            spirit::char_encoding::ascii
+          , spirit::char_encoding::iso8859_1
+          , spirit::char_encoding::standard
+          , spirit::char_encoding::standard_wide
+#if defined(BOOST_SPIRIT_UNICODE)
+          , spirit::char_encoding::unicode
+#endif
+        >
+    char_encodings;
+
+    template <typename T>
+    struct is_char_encoding : mpl::false_ {};
+
+    template <>
+    struct is_char_encoding<spirit::char_encoding::ascii> : mpl::true_ {};
+
+    template <>
+    struct is_char_encoding<spirit::char_encoding::iso8859_1> : mpl::true_ {};
+
+    template <>
+    struct is_char_encoding<spirit::char_encoding::standard> : mpl::true_ {};
+
+    template <>
+    struct is_char_encoding<spirit::char_encoding::standard_wide> : mpl::true_ {};
+
+#if defined(BOOST_SPIRIT_UNICODE)
+    template <>
+    struct is_char_encoding<spirit::char_encoding::unicode> : mpl::true_ {};
+#endif
+
+    template <typename Encoding>
+    struct encoding
+        : proto::terminal<tag::char_code<tag::encoding, Encoding> >::type
+    {};
+
+    // Our basic terminals
+    BOOST_SPIRIT_DEFINE_TERMINALS_NAME(
+        ( verbatim, verbatim_type )
+        ( no_delimit, no_delimit_type )
+        ( lexeme, lexeme_type )
+        ( no_skip, no_skip_type )
+        ( omit, omit_type )
+        ( raw, raw_type )
+        ( as_string, as_string_type )
+        ( as_wstring, as_wstring_type )
+        ( inf, inf_type )
+        ( eol, eol_type )
+        ( eoi, eoi_type )
+        ( buffer, buffer_type )
+        ( true_, true_type )
+        ( false_, false_type )
+        ( matches, matches_type )
+        ( hold, hold_type )
+        ( strict, strict_type )
+        ( relaxed, relaxed_type )
+        ( duplicate, duplicate_type )
+    )
+
+    // Our extended terminals
+    BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX(
+        ( lit, lit_type )
+        ( bin, bin_type )
+        ( oct, oct_type )
+        ( hex, hex_type )
+        ( bool_, bool_type )
+        ( ushort_, ushort_type )
+        ( ulong_, ulong_type )
+        ( uint_, uint_type )
+        ( short_, short_type )
+        ( long_, long_type )
+        ( int_, int_type )
+        ( ulong_long, ulong_long_type )
+        ( long_long, long_long_type )
+        ( float_, float_type )
+        ( double_, double_type )
+        ( long_double, long_double_type )
+        ( repeat, repeat_type )
+        ( eps, eps_type )
+        ( pad, pad_type )
+        ( byte_, byte_type )
+        ( word, word_type )
+        ( big_word, big_word_type )
+        ( little_word, little_word_type )
+        ( dword, dword_type )
+        ( big_dword, big_dword_type )
+        ( little_dword, little_dword_type )
+        ( qword, qword_type )
+        ( big_qword, big_qword_type )
+        ( little_qword, little_qword_type )
+        ( bin_float, bin_float_type )
+        ( big_bin_float, big_bin_float_type )
+        ( little_bin_float, little_bin_float_type )
+        ( bin_double, bin_double_type )
+        ( big_bin_double, big_bin_double_type )
+        ( little_bin_double, little_bin_double_type )
+        ( skip, skip_type )
+        ( delimit, delimit_type )
+        ( stream, stream_type )
+        ( wstream, wstream_type )
+        ( left_align, left_align_type )
+        ( right_align, right_align_type )
+        ( center, center_type )
+        ( maxwidth, maxwidth_type )
+        ( set_state, set_state_type )
+        ( in_state, in_state_type )
+        ( token, token_type )
+        ( tokenid, tokenid_type )
+        ( raw_token, raw_token_type )
+        ( tokenid_mask, tokenid_mask_type )
+        ( attr, attr_type )
+        ( columns, columns_type )
+        ( auto_, auto_type )
+    )
+
+    // special tags (used mainly for stateful tag types)
+    namespace tag
+    {
+        struct attr_cast { BOOST_SPIRIT_IS_TAG() };
+        struct as { BOOST_SPIRIT_IS_TAG() };
+    }
+}}
+
+///////////////////////////////////////////////////////////////////////////////
+// Here we place the character-set sensitive placeholders. We have one set
+// each for ascii, iso8859_1, standard and standard_wide and unicode. These
+// placeholders are placed in its char-set namespace. For example, there exist
+// a placeholder spirit::ascii::alnum for ascii versions of alnum.
+
+#define BOOST_SPIRIT_TAG_CHAR_SPEC(charset)                                     \
+    typedef tag::char_code<tag::char_, charset> char_;                          \
+    typedef tag::char_code<tag::string, charset> string;                        \
+    /***/
+
+#ifdef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define BOOST_SPIRIT_CHAR_SPEC(charset)                                         \
+    typedef spirit::terminal<tag::charset::char_> char_type;                    \
+    typedef spirit::terminal<tag::charset::string> string_type;                 \
+    /***/
+
+#else
+
+#define BOOST_SPIRIT_CHAR_SPEC(charset)                                         \
+    typedef spirit::terminal<tag::charset::char_> char_type;                    \
+    char_type const char_ = char_type();                                        \
+                                                                                \
+    inline void silence_unused_warnings_##char_() { (void) char_; }             \
+                                                                                \
+    typedef spirit::terminal<tag::charset::string> string_type;                 \
+    string_type const string = string_type();                                   \
+                                                                                \
+    inline void silence_unused_warnings_##string() { (void) string; }           \
+    /***/
+
+#endif
+
+#ifdef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define BOOST_SPIRIT_CHAR_CODE(name, charset)                                   \
+    typedef proto::terminal<tag::char_code<tag::name, charset> >::type          \
+        name##_type;                                                            \
+    /***/
+
+#else
+
+#define BOOST_SPIRIT_CHAR_CODE(name, charset)                                   \
+    typedef proto::terminal<tag::char_code<tag::name, charset> >::type          \
+        name##_type;                                                            \
+    name##_type const name = name##_type();                                     \
+                                                                                \
+    inline void silence_unused_warnings_##name() { (void) name; }               \
+    /***/
+
+
+#endif
+
+#define BOOST_SPIRIT_DEFINE_CHAR_CODES(charset)                                 \
+    namespace boost { namespace spirit { namespace tag { namespace charset      \
+    {                                                                           \
+        BOOST_SPIRIT_TAG_CHAR_SPEC(spirit::char_encoding::charset)              \
+    }}}}                                                                        \
+    namespace boost { namespace spirit { namespace charset                      \
+    {                                                                           \
+        BOOST_SPIRIT_CHAR_SPEC(charset)                                         \
+                                                                                \
+        BOOST_SPIRIT_CHAR_CODE(alnum, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(alpha, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(blank, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(cntrl, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(digit, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(graph, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(print, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(punct, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(space, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(xdigit, spirit::char_encoding::charset)          \
+                                                                                \
+        BOOST_SPIRIT_CHAR_CODE(no_case, spirit::char_encoding::charset)         \
+        BOOST_SPIRIT_CHAR_CODE(lower, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(upper, spirit::char_encoding::charset)           \
+        BOOST_SPIRIT_CHAR_CODE(lowernum, spirit::char_encoding::charset)        \
+        BOOST_SPIRIT_CHAR_CODE(uppernum, spirit::char_encoding::charset)        \
+    }}}                                                                         \
+    /***/
+
+BOOST_SPIRIT_DEFINE_CHAR_CODES(ascii)
+BOOST_SPIRIT_DEFINE_CHAR_CODES(iso8859_1)
+BOOST_SPIRIT_DEFINE_CHAR_CODES(standard)
+BOOST_SPIRIT_DEFINE_CHAR_CODES(standard_wide)
+
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Char>
+    struct char_encoding_from_char;
+
+    template <>
+    struct char_encoding_from_char<char>
+      : mpl::identity<spirit::char_encoding::standard>
+    {};
+
+    template <>
+    struct char_encoding_from_char<wchar_t>
+      : mpl::identity<spirit::char_encoding::standard_wide>
+    {};
+
+    template <typename T>
+    struct char_encoding_from_char<T const>
+      : char_encoding_from_char<T>
+    {};
+}}}
+
+#if defined(BOOST_SPIRIT_UNICODE)
+BOOST_SPIRIT_DEFINE_CHAR_CODES(unicode)
+
+    namespace boost { namespace spirit { namespace tag { namespace unicode
+    {
+        BOOST_SPIRIT_TAG_CHAR_SPEC(spirit::char_encoding::unicode)
+    }}}}
+
+    namespace boost { namespace spirit { namespace unicode
+    {
+#define BOOST_SPIRIT_UNICODE_CHAR_CODE(name)                                    \
+    BOOST_SPIRIT_CHAR_CODE(name, spirit::char_encoding::unicode)                \
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Unicode Major Categories
+    ///////////////////////////////////////////////////////////////////////////
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(letter)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(mark)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(number)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(separator)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(other)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(symbol)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Unicode General Categories
+    ///////////////////////////////////////////////////////////////////////////
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(uppercase_letter)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lowercase_letter)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(titlecase_letter)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(modifier_letter)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(other_letter)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(nonspacing_mark)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(enclosing_mark)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(spacing_mark)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(decimal_number)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(letter_number)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(other_number)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(space_separator)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(line_separator)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(paragraph_separator)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(control)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(format)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(private_use)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(surrogate)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(unassigned)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(dash_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(open_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(close_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(connector_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(other_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(initial_punctuation)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(final_punctuation)
+
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(math_symbol)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(currency_symbol)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(modifier_symbol)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(other_symbol)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Unicode Derived Categories
+    ///////////////////////////////////////////////////////////////////////////
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(alphabetic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(uppercase)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lowercase)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(white_space)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(hex_digit)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(noncharacter_code_point)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(default_ignorable_code_point)
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Unicode Scripts
+    ///////////////////////////////////////////////////////////////////////////
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(arabic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(imperial_aramaic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(armenian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(avestan)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(balinese)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(bamum)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(bengali)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(bopomofo)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(braille)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(buginese)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(buhid)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(canadian_aboriginal)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(carian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(cham)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(cherokee)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(coptic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(cypriot)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(cyrillic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(devanagari)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(deseret)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(egyptian_hieroglyphs)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(ethiopic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(georgian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(glagolitic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(gothic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(greek)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(gujarati)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(gurmukhi)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(hangul)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(han)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(hanunoo)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(hebrew)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(hiragana)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(katakana_or_hiragana)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(old_italic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(javanese)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(kayah_li)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(katakana)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(kharoshthi)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(khmer)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(kannada)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(kaithi)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tai_tham)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lao)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(latin)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lepcha)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(limbu)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(linear_b)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lisu)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lycian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(lydian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(malayalam)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(mongolian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(meetei_mayek)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(myanmar)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(nko)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(ogham)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(ol_chiki)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(old_turkic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(oriya)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(osmanya)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(phags_pa)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(inscriptional_pahlavi)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(phoenician)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(inscriptional_parthian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(rejang)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(runic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(samaritan)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(old_south_arabian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(saurashtra)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(shavian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(sinhala)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(sundanese)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(syloti_nagri)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(syriac)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tagbanwa)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tai_le)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(new_tai_lue)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tamil)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tai_viet)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(telugu)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tifinagh)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tagalog)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(thaana)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(thai)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(tibetan)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(ugaritic)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(vai)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(old_persian)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(cuneiform)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(yi)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(inherited)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(common)
+        BOOST_SPIRIT_UNICODE_CHAR_CODE(unknown)
+
+#undef BOOST_SPIRIT_UNICODE_CHAR_CODE
+    }}}
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/container.hpp b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp
new file mode 100644
index 0000000..7f491aa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp
@@ -0,0 +1,575 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONTAINER_FEBRUARY_06_2007_1001AM)
+#define BOOST_SPIRIT_CONTAINER_FEBRUARY_06_2007_1001AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/optional.hpp>
+#include <boost/variant.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  This file contains some container utils for stl containers. The
+    //  utilities provided also accept spirit's unused_type; all no-ops.
+    //  Compiler optimization will easily strip these away.
+    ///////////////////////////////////////////////////////////////////////////
+
+    namespace detail
+    {
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
+    }
+
+    template <typename T, typename Enable/* = void*/>
+    struct is_container
+      : mpl::bool_<
+            detail::has_value_type<T>::value &&
+            detail::has_iterator<T>::value &&
+            detail::has_size_type<T>::value &&
+            detail::has_reference<T>::value>
+    {};
+
+    template <typename T>
+    struct is_container<T&>
+      : is_container<T>
+    {};
+
+    template <typename T>
+    struct is_container<boost::optional<T> >
+      : is_container<T>
+    {};
+
+#define BOOST_SPIRIT_IS_CONTAINER(z, N, data)                                 \
+        is_container<BOOST_PP_CAT(T, N)>::value ||                            \
+    /***/
+
+    // make sure unused variant parameters do not affect the outcome
+    template <>
+    struct is_container<boost::detail::variant::void_>
+      : mpl::false_
+    {};
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct is_container<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+       : mpl::bool_<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_SPIRIT_IS_CONTAINER, _) false>
+    {};
+
+#undef BOOST_SPIRIT_IS_CONTAINER
+
+    template <typename T, typename Enable/* = void*/>
+    struct is_iterator_range
+      : mpl::false_
+    {};
+
+    template <typename T>
+    struct is_iterator_range<iterator_range<T> >
+      : mpl::true_
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename T>
+        struct remove_value_const
+        {
+            typedef T type;
+        };
+
+        template <typename T>
+        struct remove_value_const<T const>
+          : remove_value_const<T>
+        {};
+
+        template <typename F, typename S>
+        struct remove_value_const<std::pair<F, S> >
+        {
+            typedef typename remove_value_const<F>::type first_type;
+            typedef typename remove_value_const<S>::type second_type;
+            typedef std::pair<first_type, second_type> type;
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////
+    //[customization_container_value_default
+    template <typename Container, typename Enable/* = void*/>
+    struct container_value
+      : detail::remove_value_const<typename Container::value_type>
+    {};
+    //]
+
+    template <typename T>
+    struct container_value<T&>
+      : container_value<T>
+    {};
+
+    // this will be instantiated if the optional holds a container
+    template <typename T>
+    struct container_value<boost::optional<T> >
+      : container_value<T>
+    {};
+
+    // this will be instantiated if the variant holds a container
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct container_value<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    {
+        typedef typename
+            variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types
+        types;
+        typedef typename
+            mpl::find_if<types, is_container<mpl::_1> >::type
+        iter;
+
+        typedef typename container_value<
+            typename mpl::if_<
+                is_same<iter, typename mpl::end<types>::type>
+              , unused_type, typename mpl::deref<iter>::type
+            >::type
+        >::type type;
+    };
+
+    //[customization_container_value_unused
+    template <>
+    struct container_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+    //]
+
+    template <>
+    struct container_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct container_iterator
+    {
+        typedef typename Container::iterator type;
+    };
+
+    template <typename Container>
+    struct container_iterator<Container&>
+      : container_iterator<Container>
+    {};
+
+    template <typename Container>
+    struct container_iterator<Container const>
+    {
+        typedef typename Container::const_iterator type;
+    };
+
+    template <typename T>
+    struct container_iterator<optional<T> >
+      : container_iterator<T>
+    {};
+
+    template <typename T>
+    struct container_iterator<optional<T> const>
+      : container_iterator<T const>
+    {};
+
+    template <typename Iterator>
+    struct container_iterator<iterator_range<Iterator> >
+    {
+        typedef typename range_const_iterator<
+              iterator_range<Iterator> >::type type;
+    };
+
+    template <>
+    struct container_iterator<unused_type>
+    {
+        typedef unused_type const* type;
+    };
+
+    template <>
+    struct container_iterator<unused_type const>
+    {
+        typedef unused_type const* type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable/* = void*/>
+    struct optional_attribute
+    {
+        typedef T const& type;
+
+        static type call(T const& val)
+        {
+            return val;
+        }
+
+        static bool is_valid(T const&)
+        {
+            return true;
+        }
+    };
+
+    template <typename T>
+    struct optional_attribute<boost::optional<T> >
+    {
+        typedef T const& type;
+
+        static type call(boost::optional<T> const& val)
+        {
+            return boost::get<T>(val);
+        }
+
+        static bool is_valid(boost::optional<T> const& val)
+        {
+            return val;
+        }
+    };
+
+    template <typename T>
+    typename optional_attribute<T>::type
+    optional_value(T const& val)
+    {
+        return optional_attribute<T>::call(val);
+    }
+
+    inline unused_type optional_value(unused_type)
+    {
+        return unused;
+    }
+
+    template <typename T>
+    bool has_optional_value(T const& val)
+    {
+        return optional_attribute<T>::is_valid(val);
+    }
+
+    inline bool has_optional_value(unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val);
+
+    //[customization_push_back_default
+    template <typename Container, typename T, typename Enable/* = void*/>
+    struct push_back_container
+    {
+        static bool call(Container& c, T const& val)
+        {
+            c.insert(c.end(), val);
+            return true;
+        }
+    };
+    //]
+
+    template <typename Container, typename T>
+    struct push_back_container<optional<Container>, T>
+    {
+        static bool call(boost::optional<Container>& c, T const& val)
+        {
+            if (!c)
+                c = Container();
+            return push_back(boost::get<Container>(c), val);
+        }
+    };
+
+    namespace detail
+    {
+        template <typename T>
+        struct push_back_visitor : public static_visitor<>
+        {
+            typedef bool result_type;
+
+            push_back_visitor(T const& t) : t_(t) {}
+
+            template <typename Container>
+            bool push_back_impl(Container& c, mpl::true_) const
+            {
+                return push_back(c, t_);
+            }
+
+            template <typename T_>
+            bool push_back_impl(T_&, mpl::false_) const
+            {
+                // this variant doesn't hold a container
+                BOOST_ASSERT(false && "This variant doesn't hold a container");
+                return false;
+            }
+
+            template <typename T_>
+            bool operator()(T_& c) const
+            {
+                return push_back_impl(c, typename is_container<T_>::type());
+            }
+
+            T const& t_;
+        };
+    }
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T_), typename T>
+    struct push_back_container<variant<BOOST_VARIANT_ENUM_PARAMS(T_)>, T>
+    {
+        static bool call(variant<BOOST_VARIANT_ENUM_PARAMS(T_)>& c, T const& val)
+        {
+            return apply_visitor(detail::push_back_visitor<T>(val), c);
+        }
+    };
+
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val)
+    {
+        return push_back_container<Container, T>::call(c, val);
+    }
+
+    //[customization_push_back_unused
+    template <typename Container>
+    bool push_back(Container&, unused_type)
+    {
+        return true;
+    }
+    //]
+
+    template <typename T>
+    bool push_back(unused_type, T const&)
+    {
+        return true;
+    }
+
+    inline bool push_back(unused_type, unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct is_empty_container
+    {
+        static bool call(Container const& c)
+        {
+            return c.empty();
+        }
+    };
+
+    template <typename Container>
+    bool is_empty(Container const& c)
+    {
+        return is_empty_container<Container>::call(c);
+    }
+
+    inline bool is_empty(unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Ensure the attribute is actually a container type
+    template <typename Container, typename Enable/* = void*/>
+    struct make_container_attribute
+    {
+        static void call(Container&)
+        {
+            // for static types this function does nothing
+        }
+    };
+
+    template <typename T>
+    void make_container(T& t)
+    {
+        make_container_attribute<T>::call(t);
+    }
+
+    inline void make_container(unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct begin_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.begin();
+        }
+    };
+
+    template <typename Container>
+    typename spirit::result_of::begin<Container>::type
+    begin(Container& c)
+    {
+        return begin_container<Container>::call(c);
+    }
+
+    inline unused_type const*
+    begin(unused_type)
+    {
+        return &unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct end_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.end();
+        }
+    };
+
+    template <typename Container>
+    inline typename spirit::result_of::end<Container>::type
+    end(Container& c)
+    {
+        return end_container<Container>::call(c);
+    }
+
+    inline unused_type const*
+    end(unused_type)
+    {
+        return &unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct deref_iterator
+    {
+        typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+        static type call(Iterator& it)
+        {
+            return *it;
+        }
+    };
+
+    template <typename Iterator>
+    typename deref_iterator<Iterator>::type
+    deref(Iterator& it)
+    {
+        return deref_iterator<Iterator>::call(it);
+    }
+
+    inline unused_type
+    deref(unused_type const*)
+    {
+        return unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct next_iterator
+    {
+        static void call(Iterator& it)
+        {
+            ++it;
+        }
+    };
+
+    template <typename Iterator>
+    void next(Iterator& it)
+    {
+        next_iterator<Iterator>::call(it);
+    }
+
+    inline void next(unused_type const*)
+    {
+        // do nothing
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct compare_iterators
+    {
+        static bool call(Iterator const& it1, Iterator const& it2)
+        {
+            return it1 == it2;
+        }
+    };
+
+    template <typename Iterator>
+    bool compare(Iterator& it1, Iterator& it2)
+    {
+        return compare_iterators<Iterator>::call(it1, it2);
+    }
+
+    inline bool compare(unused_type const*, unused_type const*)
+    {
+        return false;
+    }
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace result_of
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct optional_value
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct optional_value<boost::optional<T> >
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct optional_value<boost::optional<T> const>
+    {
+        typedef T const type;
+    };
+
+    template <>
+    struct optional_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+
+    template <>
+    struct optional_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container>
+    struct begin
+      : traits::container_iterator<Container>
+    {};
+
+    template <typename Container>
+    struct end
+      : traits::container_iterator<Container>
+    {};
+
+    template <typename Iterator>
+    struct deref
+      : traits::deref_iterator<Iterator>
+    {};
+
+    template <>
+    struct deref<unused_type const*>
+    {
+        typedef unused_type type;
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/context.hpp b/3rdParty/Boost/src/boost/spirit/home/support/context.hpp
new file mode 100644
index 0000000..b728b4f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/context.hpp
@@ -0,0 +1,299 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c)      2011 Thomas Heller
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_CONTEXT_OCTOBER_31_2008_0654PM)
+#define BOOST_SPIRIT_CONTEXT_OCTOBER_31_2008_0654PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/home/support/nonterminal/expand_arg.hpp>
+#include <boost/spirit/home/support/assert_msg.hpp>
+#include <boost/spirit/home/support/argument.hpp>
+#include <boost/spirit/home/support/limits.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/as_list.hpp>
+#include <boost/fusion/include/transform.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/at.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data)                                   \
+    typedef phoenix::actor<attribute<n> >                                      \
+        BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type);                              \
+    phoenix::actor<attribute<n> > const                                        \
+        BOOST_PP_CAT(_r, n) = BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type)();
+    /***/
+#define SPIRIT_USING_ATTRIBUTE(z, n, data)                                     \
+    using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type);                    \
+    using spirit::BOOST_PP_CAT(_r, n);                                         \
+    /***/
+
+#else
+
+#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data)                                   \
+    typedef phoenix::actor<attribute<n> >                                      \
+        BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type);                              \
+    /***/
+#define SPIRIT_USING_ATTRIBUTE(z, n, data)                                     \
+    using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type);                    \
+    /***/
+
+#endif
+
+namespace boost { namespace spirit
+{
+    template <int>
+    struct attribute;
+
+    template <int>
+    struct local_variable;
+}}
+
+BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
+    template <int N>
+  , boost::spirit::attribute<N>
+  , mpl::false_                 // is not nullary
+  , v2_eval(
+        proto::make<
+            boost::spirit::attribute<N>()
+        >
+      , proto::call<
+            functional::env(proto::_state)
+        >
+    )
+)
+
+BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
+    template <int N>
+  , boost::spirit::local_variable<N>
+  , mpl::false_                 // is not nullary
+  , v2_eval(
+        proto::make<
+            boost::spirit::local_variable<N>()
+        >
+      , proto::call<
+            functional::env(proto::_state)
+        >
+    )
+)
+
+namespace boost { namespace spirit
+{
+    template <typename Attributes, typename Locals>
+    struct context
+    {
+        typedef Attributes attributes_type;
+        typedef Locals locals_type;
+
+        context(typename Attributes::car_type attribute)
+          : attributes(attribute, fusion::nil()), locals() {}
+
+        template <typename Args, typename Context>
+        context(
+            typename Attributes::car_type attribute
+          , Args const& args
+          , Context& caller_context
+        ) : attributes(
+                attribute
+              , fusion::as_list(
+                    fusion::transform(
+                        args
+                      , detail::expand_arg<Context>(caller_context)
+                    )
+                )
+            )
+          , locals() {}
+
+        context(Attributes const& attributes)
+          : attributes(attributes), locals() {}
+
+        Attributes attributes;  // The attributes
+        Locals locals;          // Local variables
+    };
+
+    template <typename Context>
+    struct attributes_of
+    {
+        typedef typename Context::attributes_type type;
+    };
+
+    template <typename Context>
+    struct attributes_of<Context const>
+    {
+        typedef typename Context::attributes_type const type;
+    };
+
+    template <typename Context>
+    struct attributes_of<Context &>
+      : attributes_of<Context>
+    {};
+
+    template <typename Context>
+    struct locals_of
+    {
+        typedef typename Context::locals_type type;
+    };
+
+    template <typename Context>
+    struct locals_of<Context const>
+    {
+        typedef typename Context::locals_type const type;
+    };
+
+    template <typename Context>
+    struct locals_of<Context &>
+    {
+        typedef typename Context::locals_type type;
+    };
+
+    template <int N>
+    struct attribute
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                attributes_of<typename
+                    mpl::at_c<typename Env::args_type, 1>::type
+                >::type
+            attributes_type;
+
+            typedef typename
+                fusion::result_of::size<attributes_type>::type
+            attributes_size;
+
+            // report invalid argument not found (N is out of bounds)
+            BOOST_SPIRIT_ASSERT_MSG(
+                (N < attributes_size::value),
+                index_is_out_of_bounds, ());
+
+            typedef typename
+                fusion::result_of::at_c<attributes_type, N>::type
+            type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return fusion::at_c<N>((fusion::at_c<1>(env.args())).attributes);
+        }
+    };
+
+    template <int N>
+    struct local_variable
+    {
+        typedef mpl::true_ no_nullary;
+
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                locals_of<typename
+                    mpl::at_c<typename Env::args_type, 1>::type
+                >::type
+            locals_type;
+
+            typedef typename
+                fusion::result_of::size<locals_type>::type
+            locals_size;
+
+            // report invalid argument not found (N is out of bounds)
+            BOOST_SPIRIT_ASSERT_MSG(
+                (N < locals_size::value),
+                index_is_out_of_bounds, ());
+
+            typedef typename
+                fusion::result_of::at_c<locals_type, N>::type
+            type;
+        };
+
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return get_arg<N>((fusion::at_c<1>(env.args())).locals);
+        }
+    };
+    
+    typedef phoenix::actor<attribute<0> > _val_type;
+    typedef phoenix::actor<attribute<0> > _r0_type;
+    typedef phoenix::actor<attribute<1> > _r1_type;
+    typedef phoenix::actor<attribute<2> > _r2_type;
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    // _val refers to the 'return' value of a rule (same as _r0)
+    // _r1, _r2, ... refer to the rule arguments
+    _val_type const _val = _val_type();
+    _r0_type const _r0 = _r0_type();
+    _r1_type const _r1 = _r1_type();
+    _r2_type const _r2 = _r2_type();
+#endif
+
+    //  Bring in the rest of the attributes (_r4 .. _rN+1), using PP
+    BOOST_PP_REPEAT_FROM_TO(
+        3, SPIRIT_ATTRIBUTES_LIMIT, SPIRIT_DECLARE_ATTRIBUTE, _)
+
+    typedef phoenix::actor<local_variable<0> > _a_type;
+    typedef phoenix::actor<local_variable<1> > _b_type;
+    typedef phoenix::actor<local_variable<2> > _c_type;
+    typedef phoenix::actor<local_variable<3> > _d_type;
+    typedef phoenix::actor<local_variable<4> > _e_type;
+    typedef phoenix::actor<local_variable<5> > _f_type;
+    typedef phoenix::actor<local_variable<6> > _g_type;
+    typedef phoenix::actor<local_variable<7> > _h_type;
+    typedef phoenix::actor<local_variable<8> > _i_type;
+    typedef phoenix::actor<local_variable<9> > _j_type;
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+    // _a, _b, ... refer to the local variables of a rule
+    _a_type const _a = _a_type();
+    _b_type const _b = _b_type();
+    _c_type const _c = _c_type();
+    _d_type const _d = _d_type();
+    _e_type const _e = _e_type();
+    _f_type const _f = _f_type();
+    _g_type const _g = _g_type();
+    _h_type const _h = _h_type();
+    _i_type const _i = _i_type();
+    _j_type const _j = _j_type();
+#endif
+
+    // You can bring these in with the using directive
+    // without worrying about bringing in too much.
+    namespace labels
+    {
+        BOOST_PP_REPEAT(SPIRIT_ARGUMENTS_LIMIT, SPIRIT_USING_ARGUMENT, _)
+        BOOST_PP_REPEAT(SPIRIT_ATTRIBUTES_LIMIT, SPIRIT_USING_ATTRIBUTE, _)
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+        using spirit::_val;
+        using spirit::_a;
+        using spirit::_b;
+        using spirit::_c;
+        using spirit::_d;
+        using spirit::_e;
+        using spirit::_f;
+        using spirit::_g;
+        using spirit::_h;
+        using spirit::_i;
+        using spirit::_j;
+#endif
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp
new file mode 100644
index 0000000..e2fe18d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp
@@ -0,0 +1,104 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(BOOST_SPIRIT_AS_VARIANT_NOVEMBER_16_2007_0420PM)
+#define BOOST_SPIRIT_AS_VARIANT_NOVEMBER_16_2007_0420PM
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/next.hpp>
+#include <boost/fusion/include/value_of.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace spirit { namespace detail
+{
+    template <int size>
+    struct as_variant_impl;
+
+    template <>
+    struct as_variant_impl<0>
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef variant<> type;
+        };
+    };
+
+#define BOOST_FUSION_NEXT_ITERATOR(z, n, data)                                  \
+    typedef typename fusion::result_of::next<BOOST_PP_CAT(I, n)>::type          \
+        BOOST_PP_CAT(I, BOOST_PP_INC(n));
+
+#define BOOST_FUSION_NEXT_CALL_ITERATOR(z, n, data)                             \
+    typename gen::BOOST_PP_CAT(I, BOOST_PP_INC(n))                              \
+        BOOST_PP_CAT(i, BOOST_PP_INC(n)) = fusion::next(BOOST_PP_CAT(i, n));
+
+#define BOOST_FUSION_VALUE_OF_ITERATOR(z, n, data)                              \
+    typedef typename fusion::result_of::value_of<BOOST_PP_CAT(I, n)>::type      \
+        BOOST_PP_CAT(T, n);
+
+#define BOOST_PP_FILENAME_1 <boost/spirit/home/support/detail/as_variant.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, BOOST_VARIANT_LIMIT_TYPES)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_NEXT_ITERATOR
+#undef BOOST_FUSION_NEXT_CALL_ITERATOR
+#undef BOOST_FUSION_VALUE_OF_ITERATOR
+
+    template <typename Sequence>
+    struct as_variant
+    {
+        // build a variant generator being able to generate a variant holding
+        // all of the types as given in the typelist
+        typedef typename
+            detail::as_variant_impl<fusion::result_of::size<Sequence>::value>
+        gen;
+
+        // use this generator to create the actual variant
+        typedef typename gen::template apply<
+                typename fusion::result_of::begin<Sequence>::type
+            >::type
+        type;
+    };
+}}}
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    template <>
+    struct as_variant_impl<N>
+    {
+        template <typename I0>
+        struct apply
+        {
+            BOOST_PP_REPEAT(N, BOOST_FUSION_NEXT_ITERATOR, _)
+            BOOST_PP_REPEAT(N, BOOST_FUSION_VALUE_OF_ITERATOR, _)
+            typedef variant<BOOST_PP_ENUM_PARAMS(N, T)> type;
+        };
+    };
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp
new file mode 100644
index 0000000..4332fa2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp
@@ -0,0 +1,459 @@
+/*=============================================================================
+    Copyright (c) 2007-2011 Hartmut Kaiser
+    Copyright (c) Christopher Diggins 2005
+    Copyright (c) Pablo Aguilar 2005
+    Copyright (c) Kevlin Henney 2001
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    The class boost::spirit::hold_any is built based on the any class
+    published here: http://www.codeproject.com/cpp/dynamic_typing.asp. It adds
+    support for std streaming operator<<() and operator>>().
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_HOLD_ANY_MAY_02_2007_0857AM)
+#define BOOST_SPIRIT_HOLD_ANY_MAY_02_2007_0857AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/sp_typeinfo.hpp>
+
+#include <stdexcept>
+#include <typeinfo>
+#include <algorithm>
+#include <iosfwd>
+
+///////////////////////////////////////////////////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+# pragma warning(push)
+# pragma warning(disable: 4100)   // 'x': unreferenced formal parameter
+# pragma warning(disable: 4127)   // conditional expression is constant
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit
+{
+    struct bad_any_cast
+      : std::bad_cast
+    {
+        bad_any_cast(boost::detail::sp_typeinfo const& src, boost::detail::sp_typeinfo const& dest)
+          : from(src.name()), to(dest.name())
+        {}
+
+        virtual const char* what() const throw() { return "bad any cast"; }
+
+        const char* from;
+        const char* to;
+    };
+
+    namespace detail
+    {
+        // function pointer table
+        template <typename Char>
+        struct fxn_ptr_table
+        {
+            boost::detail::sp_typeinfo const& (*get_type)();
+            void (*static_delete)(void**);
+            void (*destruct)(void**);
+            void (*clone)(void* const*, void**);
+            void (*move)(void* const*, void**);
+            std::basic_istream<Char>& (*stream_in)(std::basic_istream<Char>&, void**);
+            std::basic_ostream<Char>& (*stream_out)(std::basic_ostream<Char>&, void* const*);
+        };
+
+        // static functions for small value-types
+        template <typename Small>
+        struct fxns;
+
+        template <>
+        struct fxns<mpl::true_>
+        {
+            template<typename T, typename Char>
+            struct type
+            {
+                static boost::detail::sp_typeinfo const& get_type()
+                {
+                    return BOOST_SP_TYPEID(T);
+                }
+                static void static_delete(void** x)
+                {
+                    reinterpret_cast<T*>(x)->~T();
+                }
+                static void destruct(void** x)
+                {
+                    reinterpret_cast<T*>(x)->~T();
+                }
+                static void clone(void* const* src, void** dest)
+                {
+                    new (dest) T(*reinterpret_cast<T const*>(src));
+                }
+                static void move(void* const* src, void** dest)
+                {
+                    reinterpret_cast<T*>(dest)->~T();
+                    *reinterpret_cast<T*>(dest) =
+                        *reinterpret_cast<T const*>(src);
+                }
+                static std::basic_istream<Char>& 
+                stream_in (std::basic_istream<Char>& i, void** obj)
+                {
+                    i >> *reinterpret_cast<T*>(obj);
+                    return i;
+                }
+                static std::basic_ostream<Char>& 
+                stream_out(std::basic_ostream<Char>& o, void* const* obj)
+                {
+                    o << *reinterpret_cast<T const*>(obj);
+                    return o;
+                }
+            };
+        };
+
+        // static functions for big value-types (bigger than a void*)
+        template <>
+        struct fxns<mpl::false_>
+        {
+            template<typename T, typename Char>
+            struct type
+            {
+                static boost::detail::sp_typeinfo const& get_type()
+                {
+                    return BOOST_SP_TYPEID(T);
+                }
+                static void static_delete(void** x)
+                {
+                    // destruct and free memory
+                    delete (*reinterpret_cast<T**>(x));
+                }
+                static void destruct(void** x)
+                {
+                    // destruct only, we'll reuse memory
+                    (*reinterpret_cast<T**>(x))->~T();
+                }
+                static void clone(void* const* src, void** dest)
+                {
+                    *dest = new T(**reinterpret_cast<T* const*>(src));
+                }
+                static void move(void* const* src, void** dest)
+                {
+                    (*reinterpret_cast<T**>(dest))->~T();
+                    **reinterpret_cast<T**>(dest) =
+                        **reinterpret_cast<T* const*>(src);
+                }
+                static std::basic_istream<Char>& 
+                stream_in(std::basic_istream<Char>& i, void** obj)
+                {
+                    i >> **reinterpret_cast<T**>(obj);
+                    return i;
+                }
+                static std::basic_ostream<Char>& 
+                stream_out(std::basic_ostream<Char>& o, void* const* obj)
+                {
+                    o << **reinterpret_cast<T* const*>(obj);
+                    return o;
+                }
+            };
+        };
+
+        template <typename T>
+        struct get_table
+        {
+            typedef mpl::bool_<(sizeof(T) <= sizeof(void*))> is_small;
+
+            template <typename Char>
+            static fxn_ptr_table<Char>* get()
+            {
+                static fxn_ptr_table<Char> static_table =
+                {
+                    fxns<is_small>::template type<T, Char>::get_type,
+                    fxns<is_small>::template type<T, Char>::static_delete,
+                    fxns<is_small>::template type<T, Char>::destruct,
+                    fxns<is_small>::template type<T, Char>::clone,
+                    fxns<is_small>::template type<T, Char>::move,
+                    fxns<is_small>::template type<T, Char>::stream_in,
+                    fxns<is_small>::template type<T, Char>::stream_out
+                };
+                return &static_table;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        struct empty {};
+
+        template <typename Char>
+        inline std::basic_istream<Char>&
+        operator>> (std::basic_istream<Char>& i, empty&)
+        {
+            // If this assertion fires you tried to insert from a std istream
+            // into an empty hold_any instance. This simply can't work, because
+            // there is no way to figure out what type to extract from the
+            // stream.
+            // The only way to make this work is to assign an arbitrary
+            // value of the required type to the hold_any instance you want to
+            // stream to. This assignment has to be executed before the actual
+            // call to the operator>>().
+            BOOST_ASSERT(false && 
+                "Tried to insert from a std istream into an empty "
+                "hold_any instance");
+            return i;
+        }
+
+        template <typename Char>
+        inline std::basic_ostream<Char>&
+        operator<< (std::basic_ostream<Char>& o, empty const&)
+        {
+            return o;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Char>
+    class basic_hold_any
+    {
+    public:
+        // constructors
+        template <typename T>
+        explicit basic_hold_any(T const& x)
+          : table(spirit::detail::get_table<T>::template get<Char>()), object(0)
+        {
+            if (spirit::detail::get_table<T>::is_small::value)
+                new (&object) T(x);
+            else
+                object = new T(x);
+        }
+
+        basic_hold_any()
+          : table(spirit::detail::get_table<spirit::detail::empty>::template get<Char>()),
+            object(0)
+        {
+        }
+
+        basic_hold_any(basic_hold_any const& x)
+          : table(spirit::detail::get_table<spirit::detail::empty>::template get<Char>()),
+            object(0)
+        {
+            assign(x);
+        }
+
+        ~basic_hold_any()
+        {
+            table->static_delete(&object);
+        }
+
+        // assignment
+        basic_hold_any& assign(basic_hold_any const& x)
+        {
+            if (&x != this) {
+                // are we copying between the same type?
+                if (table == x.table) {
+                    // if so, we can avoid reallocation
+                    table->move(&x.object, &object);
+                }
+                else {
+                    reset();
+                    x.table->clone(&x.object, &object);
+                    table = x.table;
+                }
+            }
+            return *this;
+        }
+
+        template <typename T>
+        basic_hold_any& assign(T const& x)
+        {
+            // are we copying between the same type?
+            spirit::detail::fxn_ptr_table<Char>* x_table =
+                spirit::detail::get_table<T>::template get<Char>();
+            if (table == x_table) {
+            // if so, we can avoid deallocating and re-use memory
+                table->destruct(&object);    // first destruct the old content
+                if (spirit::detail::get_table<T>::is_small::value) {
+                    // create copy on-top of object pointer itself
+                    new (&object) T(x);
+                }
+                else {
+                    // create copy on-top of old version
+                    new (object) T(x);
+                }
+            }
+            else {
+                if (spirit::detail::get_table<T>::is_small::value) {
+                    // create copy on-top of object pointer itself
+                    table->destruct(&object); // first destruct the old content
+                    new (&object) T(x);
+                }
+                else {
+                    reset();                  // first delete the old content
+                    object = new T(x);
+                }
+                table = x_table;      // update table pointer
+            }
+            return *this;
+        }
+
+        // assignment operator
+        template <typename T>
+        basic_hold_any& operator=(T const& x)
+        {
+            return assign(x);
+        }
+
+        // utility functions
+        basic_hold_any& swap(basic_hold_any& x)
+        {
+            std::swap(table, x.table);
+            std::swap(object, x.object);
+            return *this;
+        }
+
+        boost::detail::sp_typeinfo const& type() const
+        {
+            return table->get_type();
+        }
+
+        template <typename T>
+        T const& cast() const
+        {
+            if (type() != BOOST_SP_TYPEID(T))
+              throw bad_any_cast(type(), BOOST_SP_TYPEID(T));
+
+            return spirit::detail::get_table<T>::is_small::value ?
+                *reinterpret_cast<T const*>(&object) :
+                *reinterpret_cast<T const*>(object);
+        }
+
+// implicit casting is disabled by default for compatibility with boost::any
+#ifdef BOOST_SPIRIT_ANY_IMPLICIT_CASTING
+        // automatic casting operator
+        template <typename T>
+        operator T const& () const { return cast<T>(); }
+#endif // implicit casting
+
+        bool empty() const
+        {
+            return table == spirit::detail::get_table<spirit::detail::empty>::template get<Char>();
+        }
+
+        void reset()
+        {
+            if (!empty())
+            {
+                table->static_delete(&object);
+                table = spirit::detail::get_table<spirit::detail::empty>::template get<Char>();
+                object = 0;
+            }
+        }
+
+    // these functions have been added in the assumption that the embedded
+    // type has a corresponding operator defined, which is completely safe
+    // because spirit::hold_any is used only in contexts where these operators
+    // do exist
+        template <typename Char_>
+        friend inline std::basic_istream<Char_>& 
+        operator>> (std::basic_istream<Char_>& i, basic_hold_any<Char_>& obj)
+        {
+            return obj.table->stream_in(i, &obj.object);
+        }
+
+        template <typename Char_>
+        friend inline std::basic_ostream<Char_>& 
+        operator<< (std::basic_ostream<Char_>& o, basic_hold_any<Char_> const& obj)
+        {
+            return obj.table->stream_out(o, &obj.object);
+        }
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    private: // types
+        template <typename T, typename Char_>
+        friend T* any_cast(basic_hold_any<Char_> *);
+#else
+    public: // types (public so any_cast can be non-friend)
+#endif
+        // fields
+        spirit::detail::fxn_ptr_table<Char>* table;
+        void* object;
+    };
+
+    // boost::any-like casting
+    template <typename T, typename Char>
+    inline T* any_cast (basic_hold_any<Char>* operand)
+    {
+        if (operand && operand->type() == BOOST_SP_TYPEID(T)) {
+            return spirit::detail::get_table<T>::is_small::value ?
+                reinterpret_cast<T*>(&operand->object) :
+                reinterpret_cast<T*>(operand->object);
+        }
+        return 0;
+    }
+
+    template <typename T, typename Char>
+    inline T const* any_cast(basic_hold_any<Char> const* operand)
+    {
+        return any_cast<T>(const_cast<basic_hold_any<Char>*>(operand));
+    }
+
+    template <typename T, typename Char>
+    T any_cast(basic_hold_any<Char>& operand)
+    {
+        typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type nonref;
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        // If 'nonref' is still reference type, it means the user has not
+        // specialized 'remove_reference'.
+
+        // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
+        // to generate specialization of remove_reference for your class
+        // See type traits library documentation for details
+        BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
+#endif
+
+        nonref* result = any_cast<nonref>(&operand);
+        if(!result)
+            boost::throw_exception(bad_any_cast(operand.type(), BOOST_SP_TYPEID(T)));
+        return *result;
+    }
+
+    template <typename T, typename Char>
+    T const& any_cast(basic_hold_any<Char> const& operand)
+    {
+        typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type nonref;
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        // The comment in the above version of 'any_cast' explains when this
+        // assert is fired and what to do.
+        BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
+#endif
+
+        return any_cast<nonref const&>(const_cast<basic_hold_any<Char> &>(operand));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // backwards compatibility
+    typedef basic_hold_any<char> hold_any;
+    typedef basic_hold_any<wchar_t> whold_any;
+
+    namespace traits
+    {
+        template <typename T>
+        struct is_hold_any : mpl::false_ {};
+
+        template <typename Char>
+        struct is_hold_any<basic_hold_any<Char> > : mpl::true_ {};
+    }
+
+}}    // namespace boost::spirit
+
+///////////////////////////////////////////////////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+# pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp
new file mode 100644
index 0000000..73269e2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_SUPPORT_DETAIL_IS_SPIRIT_TAG_MAR_28_2011_0341PM)
+#define BOOST_SPIRIT_SUPPORT_DETAIL_IS_SPIRIT_TAG_MAR_28_2011_0341PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+#define BOOST_SPIRIT_IS_TAG()
+#else
+#define BOOST_SPIRIT_IS_TAG() typedef void is_spirit_tag;
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/char_traits.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/char_traits.hpp
new file mode 100644
index 0000000..6b112ad
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/char_traits.hpp
@@ -0,0 +1,54 @@
+// char_traits.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_CHAR_TRAITS_H
+#define BOOST_LEXER_CHAR_TRAITS_H
+
+// Make sure wchar_t is defined
+#include <string>
+
+namespace boost
+{
+namespace lexer
+{
+template<typename CharT>
+struct char_traits
+{
+    typedef CharT char_type;
+    typedef CharT index_type;
+
+    static index_type call (CharT ch)
+    {
+       return ch;
+    }
+};
+
+template<>
+struct char_traits<char>
+{
+    typedef char char_type;
+    typedef unsigned char index_type;
+        
+    static index_type call (char ch)
+    {
+        return static_cast<index_type>(ch);
+    }
+};
+
+template<>
+struct char_traits<wchar_t>
+{
+    typedef wchar_t char_type;
+    typedef wchar_t index_type;
+
+    static index_type call (wchar_t ch)
+    {
+        return ch;
+    }
+};
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/consts.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/consts.hpp
new file mode 100644
index 0000000..a8a8cce
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/consts.hpp
@@ -0,0 +1,39 @@
+// consts.h
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_CONSTS_H
+#define BOOST_LEXER_CONSTS_H
+
+#include <boost/config.hpp>
+#include <boost/integer_traits.hpp>
+#include "size_t.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+    enum regex_flags {none = 0, icase = 1, dot_not_newline = 2};
+    // 0 = end state, 1 = id, 2 = unique_id, 3 = lex state, 4 = bol, 5 = eol,
+    // 6 = dead_state_index
+    enum {end_state_index, id_index, unique_id_index, state_index, bol_index,
+        eol_index, dead_state_index, dfa_offset};
+
+    const std::size_t max_macro_len = 30;
+    const std::size_t num_chars = 256;
+    // If sizeof(wchar_t) == sizeof(size_t) then don't overflow to 0
+    // by adding one to comparison.
+    const std::size_t num_wchar_ts =
+        (boost::integer_traits<wchar_t>::const_max < 0x110000) ?
+        boost::integer_traits<wchar_t>::const_max +
+        static_cast<std::size_t> (1) : 0x110000;
+    const std::size_t null_token = static_cast<std::size_t> (~0);
+    const std::size_t bol_token = static_cast<std::size_t> (~1);
+    const std::size_t eol_token = static_cast<std::size_t> (~2);
+    const std::size_t end_state = 1;
+    const std::size_t npos = static_cast<std::size_t> (~0);
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_list.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_list.hpp
new file mode 100644
index 0000000..5995849
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_list.hpp
@@ -0,0 +1,71 @@
+// ptr_list.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_PTR_LIST_HPP
+#define BOOST_LEXER_PTR_LIST_HPP
+
+#include <list>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename Type>
+class ptr_list
+{
+public:
+    typedef std::list<Type *> list;
+
+    ptr_list ()
+    {
+    }
+
+    ~ptr_list ()
+    {
+        clear ();
+    }
+
+    list *operator -> ()
+    {
+        return &_list;
+    }
+
+    const list *operator -> () const
+    {
+        return &_list;
+    }
+
+    list &operator * ()
+    {
+        return _list;
+    }
+
+    const list &operator * () const
+    {
+        return _list;
+    }
+
+    void clear ()
+    {
+        while (!_list.empty ())
+        {
+            delete _list.front ();
+            _list.pop_front ();
+        }
+    }
+
+private:
+    list _list;
+
+    ptr_list (const ptr_list &); // No copy construction.
+    ptr_list &operator = (const ptr_list &); // No assignment.
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_vector.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_vector.hpp
new file mode 100644
index 0000000..98411e6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/containers/ptr_vector.hpp
@@ -0,0 +1,108 @@
+// ptr_vector.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_PTR_VECTOR_HPP
+#define BOOST_LEXER_PTR_VECTOR_HPP
+
+#include "../size_t.hpp"
+#include <vector>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename Type>
+class ptr_vector
+{
+public:
+    typedef std::vector<Type *> vector;
+
+    ptr_vector ()
+    {
+    }
+
+    ~ptr_vector ()
+    {
+        clear ();
+    }
+
+    vector *operator -> ()
+    {
+        return &_vector;
+    }
+
+    const vector *operator -> () const
+    {
+        return &_vector;
+    }
+
+    vector &operator * ()
+    {
+        return _vector;
+    }
+
+    const vector &operator * () const
+    {
+        return _vector;
+    }
+
+    Type * &operator [] (const std::size_t index_)
+    {
+        return _vector[index_];
+    }
+
+    Type * const &operator [] (const std::size_t index_) const
+    {
+        return _vector[index_];
+    }
+
+    bool operator == (const ptr_vector &rhs_) const
+    {
+        bool equal_ = _vector.size () == rhs_._vector.size ();
+
+        if (equal_)
+        {
+            typename vector::const_iterator lhs_iter_ = _vector.begin ();
+            typename vector::const_iterator end_ = _vector.end ();
+            typename vector::const_iterator rhs_iter_ = rhs_._vector.begin ();
+
+            for (; equal_ && lhs_iter_ != end_; ++lhs_iter_, ++rhs_iter_)
+            {
+                equal_ = **lhs_iter_ == **rhs_iter_;
+            }
+        }
+
+        return  equal_;
+    }
+
+    void clear ()
+    {
+        if (!_vector.empty ())
+        {
+            Type **iter_ = &_vector.front ();
+            Type **end_ = iter_ + _vector.size ();
+
+            for (; iter_ != end_; ++iter_)
+            {
+                delete *iter_;
+            }
+        }
+
+        _vector.clear ();
+    }
+
+private:
+    vector _vector;
+
+    ptr_vector (const ptr_vector &); // No copy construction.
+    ptr_vector &operator = (const ptr_vector &); // No assignment.
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/conversion/char_state_machine.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/conversion/char_state_machine.hpp
new file mode 100644
index 0000000..38c70b5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/conversion/char_state_machine.hpp
@@ -0,0 +1,77 @@
+// char_state_machine.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_CHAR_STATE_MACHINE_HPP
+#define BOOST_LEXER_CHAR_STATE_MACHINE_HPP
+
+#include "../consts.hpp"
+#include <map>
+#include "../size_t.hpp"
+#include "../string_token.hpp"
+#include <vector>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+struct basic_char_state_machine
+{
+    struct state
+    {
+        typedef basic_string_token<CharT> string_token;
+        typedef std::map<std::size_t, string_token> size_t_string_token_map;
+        typedef std::pair<std::size_t, string_token> size_t_string_token_pair;
+
+        bool _end_state;
+        std::size_t _id;
+        std::size_t _unique_id;
+        std::size_t _state;
+        std::size_t _bol_index;
+        std::size_t _eol_index;
+        size_t_string_token_map _transitions;
+
+        state () :
+            _end_state (false),
+            _id (0),
+            _unique_id (npos),
+            _state (0),
+            _bol_index (npos),
+            _eol_index (npos)
+        {
+        }
+    };
+
+    typedef std::vector<state> state_vector;
+    typedef std::vector<state_vector> state_vector_vector;
+
+    state_vector_vector _sm_vector;
+
+    bool empty () const
+    {
+        return _sm_vector.empty ();
+    }
+
+    void clear ()
+    {
+        _sm_vector.clear ();
+    }
+
+    void swap (basic_char_state_machine &csm_)
+    {
+        _sm_vector.swap (csm_._sm_vector);
+    }
+};
+
+typedef basic_char_state_machine<char> char_state_machine;
+typedef basic_char_state_machine<wchar_t> wchar_state_machine;
+
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp
new file mode 100644
index 0000000..23cda87
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp
@@ -0,0 +1,285 @@
+// debug.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_DEBUG_HPP
+#define BOOST_LEXER_DEBUG_HPP
+
+#include <map>
+#include <ostream>
+#include "rules.hpp"
+#include "size_t.hpp"
+#include "state_machine.hpp"
+#include "string_token.hpp"
+#include <vector>
+
+namespace boost
+{
+namespace lexer
+{
+template<typename CharT>
+class basic_debug
+{
+public:
+    typedef std::basic_ostream<CharT> ostream;
+    typedef std::basic_string<CharT> string;
+    typedef std::vector<std::size_t> size_t_vector;
+
+    static void escape_control_chars (const string &in_, string &out_)
+    {
+        const CharT *ptr_ = in_.c_str ();
+        std::size_t size_ = in_.size ();
+
+#if defined _MSC_VER && _MSC_VER <= 1200
+        out_.erase ();
+#else
+        out_.clear ();
+#endif
+
+        while (size_)
+        {
+            basic_string_token<CharT>::escape_char (*ptr_, out_);
+            ++ptr_;
+            --size_;
+        }
+    }
+
+    static void dump (const basic_state_machine<CharT> &state_machine_,
+        basic_rules<CharT> &rules_, ostream &stream_)
+    {
+        typename basic_state_machine<CharT>::iterator iter_ =
+            state_machine_.begin ();
+        typename basic_state_machine<CharT>::iterator end_ =
+            state_machine_.end ();
+
+        for (std::size_t dfa_ = 0, dfas_ = state_machine_.size ();
+            dfa_ < dfas_; ++dfa_)
+        {
+            lexer_state (stream_);
+            stream_ << rules_.state (dfa_) << std::endl << std::endl;
+
+            dump_ex (iter_, stream_);
+        }
+    }
+
+    static void dump (const basic_state_machine<CharT> &state_machine_,
+        ostream &stream_)
+    {
+        typename basic_state_machine<CharT>::iterator iter_ =
+            state_machine_.begin ();
+        typename basic_state_machine<CharT>::iterator end_ =
+            state_machine_.end ();
+
+        for (std::size_t dfa_ = 0, dfas_ = state_machine_.size ();
+            dfa_ < dfas_; ++dfa_)
+        {
+            lexer_state (stream_);
+            stream_ << dfa_ << std::endl << std::endl;
+
+            dump_ex (iter_, stream_);
+        }
+    }
+
+protected:
+    typedef std::basic_stringstream<CharT> stringstream;
+
+    static void dump_ex (typename basic_state_machine<CharT>::iterator &iter_,
+        ostream &stream_)
+    {
+        const std::size_t states_ = iter_->states;
+
+        for (std::size_t i_ = 0; i_ < states_; ++i_)
+        {
+            state (stream_);
+            stream_ << i_ << std::endl;
+
+            if (iter_->end_state)
+            {
+                end_state (stream_);
+                stream_ << iter_->id;
+                unique_id (stream_);
+                stream_ << iter_->unique_id;
+                dfa (stream_);
+                stream_ << iter_->goto_dfa;
+                stream_ << std::endl;
+            }
+
+            if (iter_->bol_index != npos)
+            {
+                bol (stream_);
+                stream_ << iter_->bol_index << std::endl;
+            }
+
+            if (iter_->eol_index != npos)
+            {
+                eol (stream_);
+                stream_ << iter_->eol_index << std::endl;
+            }
+
+            const std::size_t transitions_ = iter_->transitions;
+
+            if (transitions_ == 0)
+            {
+                ++iter_;
+            }
+
+            for (std::size_t t_ = 0; t_ < transitions_; ++t_)
+            {
+                std::size_t goto_state_ = iter_->goto_state;
+
+                if (iter_->token.any ())
+                {
+                    any (stream_);
+                }
+                else
+                {
+                    open_bracket (stream_);
+
+                    if (iter_->token._negated)
+                    {
+                        negated (stream_);
+                    }
+
+                    string charset_;
+                    CharT c_ = 0;
+
+                    escape_control_chars (iter_->token._charset,
+                        charset_);
+                    c_ = *charset_.c_str ();
+
+                    if (!iter_->token._negated &&
+                        (c_ == '^' || c_ == ']'))
+                    {
+                        stream_ << '\\';
+                    }
+
+                    stream_ << charset_;
+                    close_bracket (stream_);
+                }
+
+                stream_ << goto_state_ << std::endl;
+                ++iter_;
+            }
+
+            stream_ << std::endl;
+        }
+    }
+
+    static void lexer_state (std::ostream &stream_)
+    {
+        stream_ << "Lexer state: ";
+    }
+
+    static void lexer_state (std::wostream &stream_)
+    {
+        stream_ << L"Lexer state: ";
+    }
+
+    static void state (std::ostream &stream_)
+    {
+        stream_ << "State: ";
+    }
+
+    static void state (std::wostream &stream_)
+    {
+        stream_ << L"State: ";
+    }
+
+    static void bol (std::ostream &stream_)
+    {
+        stream_ << "  BOL -> ";
+    }
+
+    static void bol (std::wostream &stream_)
+    {
+        stream_ << L"  BOL -> ";
+    }
+
+    static void eol (std::ostream &stream_)
+    {
+        stream_ << "  EOL -> ";
+    }
+
+    static void eol (std::wostream &stream_)
+    {
+        stream_ << L"  EOL -> ";
+    }
+
+    static void end_state (std::ostream &stream_)
+    {
+        stream_ << "  END STATE, Id = ";
+    }
+
+    static void end_state (std::wostream &stream_)
+    {
+        stream_ << L"  END STATE, Id = ";
+    }
+
+    static void unique_id (std::ostream &stream_)
+    {
+        stream_ << ", Unique Id = ";
+    }
+
+    static void unique_id (std::wostream &stream_)
+    {
+        stream_ << L", Unique Id = ";
+    }
+
+    static void any (std::ostream &stream_)
+    {
+        stream_ << "  . -> ";
+    }
+
+    static void any (std::wostream &stream_)
+    {
+        stream_ << L"  . -> ";
+    }
+
+    static void open_bracket (std::ostream &stream_)
+    {
+        stream_ << "  [";
+    }
+
+    static void open_bracket (std::wostream &stream_)
+    {
+        stream_ << L"  [";
+    }
+
+    static void negated (std::ostream &stream_)
+    {
+        stream_ << "^";
+    }
+
+    static void negated (std::wostream &stream_)
+    {
+        stream_ << L"^";
+    }
+
+    static void close_bracket (std::ostream &stream_)
+    {
+        stream_ << "] -> ";
+    }
+
+    static void close_bracket (std::wostream &stream_)
+    {
+        stream_ << L"] -> ";
+    }
+
+    static void dfa (std::ostream &stream_)
+    {
+        stream_ << ", dfa = ";
+    }
+
+    static void dfa (std::wostream &stream_)
+    {
+        stream_ << L", dfa = ";
+    }
+};
+
+typedef basic_debug<char> debug;
+typedef basic_debug<wchar_t> wdebug;
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp
new file mode 100644
index 0000000..49bea2f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp
@@ -0,0 +1,858 @@
+// generator.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_GENERATOR_HPP
+#define BOOST_LEXER_GENERATOR_HPP
+
+#include "char_traits.hpp"
+// memcmp()
+#include <cstring>
+#include "partition/charset.hpp"
+#include "partition/equivset.hpp"
+#include <memory>
+#include "parser/tree/node.hpp"
+#include "parser/parser.hpp"
+#include "containers/ptr_list.hpp"
+#include "rules.hpp"
+#include "state_machine.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+template<typename CharT, typename Traits = char_traits<CharT> >
+class basic_generator
+{
+public:
+    typedef typename detail::internals::size_t_vector size_t_vector;
+    typedef basic_rules<CharT> rules;
+
+    static void build (const rules &rules_,
+        basic_state_machine<CharT> &state_machine_)
+    {
+        std::size_t index_ = 0;
+        std::size_t size_ = rules_.statemap ().size ();
+        node_ptr_vector node_ptr_vector_;
+        detail::internals &internals_ = const_cast<detail::internals &>
+            (state_machine_.data ());
+        bool seen_BOL_assertion_ = false;
+        bool seen_EOL_assertion_ = false;
+
+        state_machine_.clear ();
+
+        for (; index_ < size_; ++index_)
+        {
+            internals_._lookup->push_back (static_cast<size_t_vector *>(0));
+            internals_._lookup->back () = new size_t_vector;
+            internals_._dfa_alphabet.push_back (0);
+            internals_._dfa->push_back (static_cast<size_t_vector *>(0));
+            internals_._dfa->back () = new size_t_vector;
+        }
+
+        for (index_ = 0, size_ = internals_._lookup->size ();
+            index_ < size_; ++index_)
+        {
+            internals_._lookup[index_]->resize (sizeof (CharT) == 1 ?
+                num_chars : num_wchar_ts, dead_state_index);
+
+            if (!rules_.regexes ()[index_].empty ())
+            {
+                // vector mapping token indexes to partitioned token index sets
+                index_set_vector set_mapping_;
+                // syntax tree
+                detail::node *root_ = build_tree (rules_, index_,
+                    node_ptr_vector_, internals_, set_mapping_);
+
+                build_dfa (root_, set_mapping_,
+                    internals_._dfa_alphabet[index_],
+                    *internals_._dfa[index_]);
+
+                if (internals_._seen_BOL_assertion)
+                {
+                    seen_BOL_assertion_ = true;
+                }
+
+                if (internals_._seen_EOL_assertion)
+                {
+                    seen_EOL_assertion_ = true;
+                }
+
+                internals_._seen_BOL_assertion = false;
+                internals_._seen_EOL_assertion = false;
+            }
+        }
+
+        internals_._seen_BOL_assertion = seen_BOL_assertion_;
+        internals_._seen_EOL_assertion = seen_EOL_assertion_;
+    }
+
+    static void minimise (basic_state_machine<CharT> &state_machine_)
+    {
+        detail::internals &internals_ = const_cast<detail::internals &>
+            (state_machine_.data ());
+        const std::size_t machines_ = internals_._dfa->size ();
+
+        for (std::size_t i_ = 0; i_ < machines_; ++i_)
+        {
+            const std::size_t dfa_alphabet_ = internals_._dfa_alphabet[i_];
+            size_t_vector *dfa_ = internals_._dfa[i_];
+
+            if (dfa_alphabet_ != 0)
+            {
+                std::size_t size_ = 0;
+
+                do
+                {
+                    size_ = dfa_->size ();
+                    minimise_dfa (dfa_alphabet_, *dfa_, size_);
+                } while (dfa_->size () != size_);
+            }
+        }
+    }
+
+protected:
+    typedef detail::basic_charset<CharT> charset;
+    typedef detail::ptr_list<charset> charset_list;
+    typedef std::auto_ptr<charset> charset_ptr;
+    typedef detail::equivset equivset;
+    typedef detail::ptr_list<equivset> equivset_list;
+    typedef std::auto_ptr<equivset> equivset_ptr;
+    typedef typename charset::index_set index_set;
+    typedef std::vector<index_set> index_set_vector;
+    typedef detail::basic_parser<CharT> parser;
+    typedef typename parser::node_ptr_vector node_ptr_vector;
+    typedef std::set<const detail::node *> node_set;
+    typedef detail::ptr_vector<node_set> node_set_vector;
+    typedef std::vector<const detail::node *> node_vector;
+    typedef detail::ptr_vector<node_vector> node_vector_vector;
+    typedef typename parser::string string;
+    typedef std::pair<string, string> string_pair;
+    typedef typename parser::tokeniser::string_token string_token;
+    typedef std::deque<string_pair> macro_deque;
+    typedef std::pair<string, const detail::node *> macro_pair;
+    typedef typename parser::macro_map::iterator macro_iter;
+    typedef std::pair<macro_iter, bool> macro_iter_pair;
+    typedef typename parser::tokeniser::token_map token_map;
+
+    static detail::node *build_tree (const rules &rules_,
+        const std::size_t state_, node_ptr_vector &node_ptr_vector_,
+        detail::internals &internals_, index_set_vector &set_mapping_)
+    {
+        size_t_vector *lookup_ = internals_._lookup[state_];
+        const typename rules::string_deque_deque &regexes_ =
+            rules_.regexes ();
+        const typename rules::id_vector_deque &ids_ = rules_.ids ();
+        const typename rules::id_vector_deque &unique_ids_ =
+            rules_.unique_ids ();
+        const typename rules::id_vector_deque &states_ = rules_.states ();
+        typename rules::string_deque::const_iterator regex_iter_ =
+            regexes_[state_].begin ();
+        typename rules::string_deque::const_iterator regex_iter_end_ =
+            regexes_[state_].end ();
+        typename rules::id_vector::const_iterator ids_iter_ =
+            ids_[state_].begin ();
+        typename rules::id_vector::const_iterator unique_ids_iter_ =
+            unique_ids_[state_].begin ();
+        typename rules::id_vector::const_iterator states_iter_ =
+            states_[state_].begin ();
+        const typename rules::string &regex_ = *regex_iter_;
+        // map of regex charset tokens (strings) to index
+        token_map token_map_;
+        const typename rules::string_pair_deque &macrodeque_ =
+            rules_.macrodeque ();
+        typename parser::macro_map macromap_;
+        typename detail::node::node_vector tree_vector_;
+
+        build_macros (token_map_, macrodeque_, macromap_,
+            rules_.flags (), rules_.locale (), node_ptr_vector_,
+            internals_._seen_BOL_assertion, internals_._seen_EOL_assertion);
+
+        detail::node *root_ = parser::parse (regex_.c_str (),
+            regex_.c_str () + regex_.size (), *ids_iter_, *unique_ids_iter_,
+            *states_iter_, rules_.flags (), rules_.locale (), node_ptr_vector_,
+            macromap_, token_map_, internals_._seen_BOL_assertion,
+            internals_._seen_EOL_assertion);
+
+        ++regex_iter_;
+        ++ids_iter_;
+        ++unique_ids_iter_;
+        ++states_iter_;
+        tree_vector_.push_back (root_);
+
+        // build syntax trees
+        while (regex_iter_ != regex_iter_end_)
+        {
+            // re-declare var, otherwise we perform an assignment..!
+            const typename rules::string &regex_ = *regex_iter_;
+
+            root_ = parser::parse (regex_.c_str (),
+                regex_.c_str () + regex_.size (), *ids_iter_,
+                *unique_ids_iter_, *states_iter_, rules_.flags (),
+                rules_.locale (), node_ptr_vector_, macromap_, token_map_,
+                internals_._seen_BOL_assertion,
+                internals_._seen_EOL_assertion);
+            tree_vector_.push_back (root_);
+            ++regex_iter_;
+            ++ids_iter_;
+            ++unique_ids_iter_;
+            ++states_iter_;
+        }
+
+        if (internals_._seen_BOL_assertion)
+        {
+            // Fixup BOLs
+            typename detail::node::node_vector::iterator iter_ =
+                tree_vector_.begin ();
+            typename detail::node::node_vector::iterator end_ =
+                tree_vector_.end ();
+
+            for (; iter_ != end_; ++iter_)
+            {
+                fixup_bol (*iter_, node_ptr_vector_);
+            }
+        }
+
+        // join trees
+        {
+            typename detail::node::node_vector::iterator iter_ =
+                tree_vector_.begin ();
+            typename detail::node::node_vector::iterator end_ =
+                tree_vector_.end ();
+
+            if (iter_ != end_)
+            {
+                root_ = *iter_;
+                ++iter_;
+            }
+
+            for (; iter_ != end_; ++iter_)
+            {
+                node_ptr_vector_->push_back (static_cast<detail::selection_node *>(0));
+                node_ptr_vector_->back () = new detail::selection_node
+                    (root_, *iter_);
+                root_ = node_ptr_vector_->back ();
+            }
+        }
+
+        // partitioned token list
+        charset_list token_list_;
+
+        set_mapping_.resize (token_map_.size ());
+        partition_tokens (token_map_, token_list_);
+
+        typename charset_list::list::const_iterator iter_ =
+            token_list_->begin ();
+        typename charset_list::list::const_iterator end_ =
+            token_list_->end ();
+        std::size_t index_ = 0;
+
+        for (; iter_ != end_; ++iter_, ++index_)
+        {
+            const charset *cs_ = *iter_;
+            typename charset::index_set::const_iterator set_iter_ =
+                cs_->_index_set.begin ();
+            typename charset::index_set::const_iterator set_end_ =
+                cs_->_index_set.end ();
+
+            fill_lookup (cs_->_token, lookup_, index_);
+
+            for (; set_iter_ != set_end_; ++set_iter_)
+            {
+                set_mapping_[*set_iter_].insert (index_);
+            }
+        }
+
+        internals_._dfa_alphabet[state_] = token_list_->size () + dfa_offset;
+        return root_;
+    }
+
+    static void build_macros (token_map &token_map_,
+        const macro_deque &macrodeque_,
+        typename parser::macro_map &macromap_, const regex_flags flags_,
+        const std::locale &locale_, node_ptr_vector &node_ptr_vector_,
+        bool &seen_BOL_assertion_, bool &seen_EOL_assertion_)
+    {
+        for (typename macro_deque::const_iterator iter_ =
+            macrodeque_.begin (), end_ = macrodeque_.end ();
+            iter_ != end_; ++iter_)
+        {
+            const typename rules::string &name_ = iter_->first;
+            const typename rules::string &regex_ = iter_->second;
+            detail::node *node_ = parser::parse (regex_.c_str (),
+                regex_.c_str () + regex_.size (), 0, 0, 0, flags_,
+                locale_, node_ptr_vector_, macromap_, token_map_,
+                seen_BOL_assertion_, seen_EOL_assertion_);
+            macro_iter_pair map_iter_ = macromap_.
+                insert (macro_pair (name_, static_cast<const detail::node *>
+                (0)));
+
+            map_iter_.first->second = node_;
+        }
+    }
+
+    static void build_dfa (detail::node *root_,
+        const index_set_vector &set_mapping_, const std::size_t dfa_alphabet_,
+        size_t_vector &dfa_)
+    {
+        typename detail::node::node_vector *followpos_ =
+            &root_->firstpos ();
+        node_set_vector seen_sets_;
+        node_vector_vector seen_vectors_;
+        size_t_vector hash_vector_;
+
+        // 'jam' state
+        dfa_.resize (dfa_alphabet_, 0);
+        closure (followpos_, seen_sets_, seen_vectors_,
+            hash_vector_, dfa_alphabet_, dfa_);
+
+        std::size_t *ptr_ = 0;
+
+        for (std::size_t index_ = 0; index_ < seen_vectors_->size (); ++index_)
+        {
+            equivset_list equiv_list_;
+
+            build_equiv_list (seen_vectors_[index_], set_mapping_, equiv_list_);
+
+            for (typename equivset_list::list::const_iterator iter_ =
+                equiv_list_->begin (), end_ = equiv_list_->end ();
+                iter_ != end_; ++iter_)
+            {
+                equivset *equivset_ = *iter_;
+                const std::size_t transition_ = closure
+                    (&equivset_->_followpos, seen_sets_, seen_vectors_,
+                    hash_vector_, dfa_alphabet_, dfa_);
+
+                if (transition_ != npos)
+                {
+                    ptr_ = &dfa_.front () + ((index_ + 1) * dfa_alphabet_);
+
+                    // Prune abstemious transitions from end states.
+                    if (*ptr_ && !equivset_->_greedy) continue;
+
+                    for (typename detail::equivset::index_vector::const_iterator
+                        equiv_iter_ = equivset_->_index_vector.begin (),
+                        equiv_end_ = equivset_->_index_vector.end ();
+                        equiv_iter_ != equiv_end_; ++equiv_iter_)
+                    {
+                        const std::size_t index_ = *equiv_iter_;
+
+                        if (index_ == bol_token)
+                        {
+                            if (ptr_[eol_index] == 0)
+                            {
+                                ptr_[bol_index] = transition_;
+                            }
+                        }
+                        else if (index_ == eol_token)
+                        {
+                            if (ptr_[bol_index] == 0)
+                            {
+                                ptr_[eol_index] = transition_;
+                            }
+                        }
+                        else
+                        {
+                            ptr_[index_ + dfa_offset] = transition_;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    static std::size_t closure (typename detail::node::node_vector *followpos_,
+        node_set_vector &seen_sets_, node_vector_vector &seen_vectors_,
+        size_t_vector &hash_vector_, const std::size_t size_,
+        size_t_vector &dfa_)
+    {
+        bool end_state_ = false;
+        std::size_t id_ = 0;
+        std::size_t unique_id_ = npos;
+        std::size_t state_ = 0;
+        std::size_t hash_ = 0;
+
+        if (followpos_->empty ()) return npos;
+
+        std::size_t index_ = 0;
+        std::auto_ptr<node_set> set_ptr_ (new node_set);
+        std::auto_ptr<node_vector> vector_ptr_ (new node_vector);
+
+        for (typename detail::node::node_vector::const_iterator iter_ =
+            followpos_->begin (), end_ = followpos_->end ();
+            iter_ != end_; ++iter_)
+        {
+            closure_ex (*iter_, end_state_, id_, unique_id_, state_,
+                set_ptr_.get (), vector_ptr_.get (), hash_);
+        }
+
+        bool found_ = false;
+        typename size_t_vector::const_iterator hash_iter_ =
+            hash_vector_.begin ();
+        typename size_t_vector::const_iterator hash_end_ =
+            hash_vector_.end ();
+        typename node_set_vector::vector::const_iterator set_iter_ =
+            seen_sets_->begin ();
+
+        for (; hash_iter_ != hash_end_; ++hash_iter_, ++set_iter_)
+        {
+            found_ = *hash_iter_ == hash_ && *(*set_iter_) == *set_ptr_;
+            ++index_;
+
+            if (found_) break;
+        }
+
+        if (!found_)
+        {
+            seen_sets_->push_back (static_cast<node_set *>(0));
+            seen_sets_->back () = set_ptr_.release ();
+            seen_vectors_->push_back (static_cast<node_vector *>(0));
+            seen_vectors_->back () = vector_ptr_.release ();
+            hash_vector_.push_back (hash_);
+            // State 0 is the jam state...
+            index_ = seen_sets_->size ();
+
+            const std::size_t old_size_ = dfa_.size ();
+
+            dfa_.resize (old_size_ + size_, 0);
+
+            if (end_state_)
+            {
+                dfa_[old_size_] |= end_state;
+                dfa_[old_size_ + id_index] = id_;
+                dfa_[old_size_ + unique_id_index] = unique_id_;
+                dfa_[old_size_ + state_index] = state_;
+            }
+        }
+
+        return index_;
+    }
+
+    static void closure_ex (detail::node *node_, bool &end_state_,
+        std::size_t &id_, std::size_t &unique_id_, std::size_t &state_,
+        node_set *set_ptr_, node_vector *vector_ptr_, std::size_t &hash_)
+    {
+        const bool temp_end_state_ = node_->end_state ();
+
+        if (temp_end_state_)
+        {
+            if (!end_state_)
+            {
+                end_state_ = true;
+                id_ = node_->id ();
+                unique_id_ = node_->unique_id ();
+                state_ = node_->lexer_state ();
+            }
+        }
+
+        if (set_ptr_->insert (node_).second)
+        {
+            vector_ptr_->push_back (node_);
+            hash_ += reinterpret_cast<std::size_t> (node_);
+        }
+    }
+
+    static void partition_tokens (const token_map &map_,
+        charset_list &lhs_)
+    {
+        charset_list rhs_;
+
+        fill_rhs_list (map_, rhs_);
+
+        if (!rhs_->empty ())
+        {
+            typename charset_list::list::iterator iter_;
+            typename charset_list::list::iterator end_;
+            charset_ptr overlap_ (new charset);
+
+            lhs_->push_back (static_cast<charset *>(0));
+            lhs_->back () = rhs_->front ();
+            rhs_->pop_front ();
+
+            while (!rhs_->empty ())
+            {
+                charset_ptr r_ (rhs_->front ());
+
+                rhs_->pop_front ();
+                iter_ = lhs_->begin ();
+                end_ = lhs_->end ();
+
+                while (!r_->empty () && iter_ != end_)
+                {
+                    typename charset_list::list::iterator l_iter_ = iter_;
+
+                    (*l_iter_)->intersect (*r_.get (), *overlap_.get ());
+
+                    if (overlap_->empty ())
+                    {
+                        ++iter_;
+                    }
+                    else if ((*l_iter_)->empty ())
+                    {
+                        delete *l_iter_;
+                        *l_iter_ = overlap_.release ();
+
+                        // VC++ 6 Hack:
+                        charset_ptr temp_overlap_ (new charset);
+
+                        overlap_ = temp_overlap_;
+                        ++iter_;
+                    }
+                    else if (r_->empty ())
+                    {
+                        delete r_.release ();
+                        r_ = overlap_;
+
+                        // VC++ 6 Hack:
+                        charset_ptr temp_overlap_ (new charset);
+
+                        overlap_ = temp_overlap_;
+                        break;
+                    }
+                    else
+                    {
+                        iter_ = lhs_->insert (++iter_,
+                            static_cast<charset *>(0));
+                        *iter_ = overlap_.release ();
+
+                        // VC++ 6 Hack:
+                        charset_ptr temp_overlap_ (new charset);
+
+                        overlap_ = temp_overlap_;
+                        ++iter_;
+                        end_ = lhs_->end ();
+                    }
+                }
+
+                if (!r_->empty ())
+                {
+                    lhs_->push_back (static_cast<charset *>(0));
+                    lhs_->back () = r_.release ();
+                }
+            }
+        }
+    }
+
+    static void fill_rhs_list (const token_map &map_,
+        charset_list &list_)
+    {
+        typename parser::tokeniser::token_map::const_iterator iter_ =
+            map_.begin ();
+        typename parser::tokeniser::token_map::const_iterator end_ =
+            map_.end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            list_->push_back (static_cast<charset *>(0));
+            list_->back () = new charset (iter_->first, iter_->second);
+        }
+    }
+
+    static void fill_lookup (const string_token &token_,
+        size_t_vector *lookup_, const std::size_t index_)
+    {
+        const CharT *curr_ = token_._charset.c_str ();
+        const CharT *chars_end_ = curr_ + token_._charset.size ();
+        std::size_t *ptr_ = &lookup_->front ();
+        const std::size_t max_ = sizeof (CharT) == 1 ?
+            num_chars : num_wchar_ts;
+
+        if (token_._negated)
+        {
+            CharT curr_char_ = sizeof (CharT) == 1 ? -128 : 0;
+            std::size_t i_ = 0;
+
+            while (curr_ < chars_end_)
+            {
+                while (*curr_ > curr_char_)
+                {
+                    ptr_[static_cast<typename Traits::index_type>
+                        (curr_char_)] = index_ + dfa_offset;
+                    ++curr_char_;
+                    ++i_;
+                }
+
+                ++curr_char_;
+                ++curr_;
+                ++i_;
+            }
+
+            for (; i_ < max_; ++i_)
+            {
+                ptr_[static_cast<typename Traits::index_type>(curr_char_)] =
+                    index_ + dfa_offset;
+                ++curr_char_;
+            }
+        }
+        else
+        {
+            while (curr_ < chars_end_)
+            {
+                ptr_[static_cast<typename Traits::index_type>(*curr_)] =
+                    index_ + dfa_offset;
+                ++curr_;
+            }
+        }
+    }
+
+    static void build_equiv_list (const node_vector *vector_,
+        const index_set_vector &set_mapping_, equivset_list &lhs_)
+    {
+        equivset_list rhs_;
+
+        fill_rhs_list (vector_, set_mapping_, rhs_);
+
+        if (!rhs_->empty ())
+        {
+            typename equivset_list::list::iterator iter_;
+            typename equivset_list::list::iterator end_;
+            equivset_ptr overlap_ (new equivset);
+
+            lhs_->push_back (static_cast<equivset *>(0));
+            lhs_->back () = rhs_->front ();
+            rhs_->pop_front ();
+
+            while (!rhs_->empty ())
+            {
+                equivset_ptr r_ (rhs_->front ());
+
+                rhs_->pop_front ();
+                iter_ = lhs_->begin ();
+                end_ = lhs_->end ();
+
+                while (!r_->empty () && iter_ != end_)
+                {
+                    typename equivset_list::list::iterator l_iter_ = iter_;
+
+                    (*l_iter_)->intersect (*r_.get (), *overlap_.get ());
+
+                    if (overlap_->empty ())
+                    {
+                        ++iter_;
+                    }
+                    else if ((*l_iter_)->empty ())
+                    {
+                        delete *l_iter_;
+                        *l_iter_ = overlap_.release ();
+
+                        // VC++ 6 Hack:
+                        equivset_ptr temp_overlap_ (new equivset);
+
+                        overlap_ = temp_overlap_;
+                        ++iter_;
+                    }
+                    else if (r_->empty ())
+                    {
+                        delete r_.release ();
+                        r_ = overlap_;
+
+                        // VC++ 6 Hack:
+                        equivset_ptr temp_overlap_ (new equivset);
+
+                        overlap_ = temp_overlap_;
+                        break;
+                    }
+                    else
+                    {
+                        iter_ = lhs_->insert (++iter_,
+                            static_cast<equivset *>(0));
+                        *iter_ = overlap_.release ();
+
+                        // VC++ 6 Hack:
+                        equivset_ptr temp_overlap_ (new equivset);
+
+                        overlap_ = temp_overlap_;
+                        ++iter_;
+                        end_ = lhs_->end ();
+                    }
+                }
+
+                if (!r_->empty ())
+                {
+                    lhs_->push_back (static_cast<equivset *>(0));
+                    lhs_->back () = r_.release ();
+                }
+            }
+        }
+    }
+
+    static void fill_rhs_list (const node_vector *vector_,
+        const index_set_vector &set_mapping_, equivset_list &list_)
+    {
+        typename node_vector::const_iterator iter_ =
+            vector_->begin ();
+        typename node_vector::const_iterator end_ =
+            vector_->end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            const detail::node *node_ = *iter_;
+
+            if (!node_->end_state ())
+            {
+                const std::size_t token_ = node_->token ();
+
+                if (token_ != null_token)
+                {
+                    list_->push_back (static_cast<equivset *>(0));
+
+                    if (token_ == bol_token || token_ == eol_token)
+                    {
+                        std::set<std::size_t> index_set_;
+
+                        index_set_.insert (token_);
+                        list_->back () = new equivset (index_set_,
+                            node_->greedy (), token_, node_->followpos ());
+                    }
+                    else
+                    {
+                        list_->back () = new equivset (set_mapping_[token_],
+                            node_->greedy (), token_, node_->followpos ());
+                    }
+                }
+            }
+        }
+    }
+
+    static void fixup_bol (detail::node * &root_,
+        node_ptr_vector &node_ptr_vector_)
+    {
+        typename detail::node::node_vector *first_ = &root_->firstpos ();
+        bool found_ = false;
+        typename detail::node::node_vector::const_iterator iter_ =
+            first_->begin ();
+        typename detail::node::node_vector::const_iterator end_ =
+            first_->end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            const detail::node *node_ = *iter_;
+
+            found_ = !node_->end_state () && node_->token () == bol_token;
+
+            if (found_) break;
+        }
+
+        if (!found_)
+        {
+            node_ptr_vector_->push_back (static_cast<detail::leaf_node *>(0));
+            node_ptr_vector_->back () = new detail::leaf_node
+                (bol_token, true);
+
+            detail::node *lhs_ = node_ptr_vector_->back ();
+
+            node_ptr_vector_->push_back (static_cast<detail::leaf_node *>(0));
+            node_ptr_vector_->back () = new detail::leaf_node
+                (null_token, true);
+
+            detail::node *rhs_ = node_ptr_vector_->back ();
+
+            node_ptr_vector_->push_back
+                (static_cast<detail::selection_node *>(0));
+            node_ptr_vector_->back () =
+                new detail::selection_node (lhs_, rhs_);
+            lhs_ = node_ptr_vector_->back ();
+
+            node_ptr_vector_->push_back
+                (static_cast<detail::sequence_node *>(0));
+            node_ptr_vector_->back () =
+                new detail::sequence_node (lhs_, root_);
+            root_ = node_ptr_vector_->back ();
+        }
+    }
+
+    static void minimise_dfa (const std::size_t dfa_alphabet_,
+        size_t_vector &dfa_, std::size_t size_)
+    {
+        const std::size_t *first_ = &dfa_.front ();
+        const std::size_t *second_ = 0;
+        const std::size_t *end_ = first_ + size_;
+        std::size_t index_ = 1;
+        std::size_t new_index_ = 1;
+        std::size_t curr_index_ = 0;
+        index_set index_set_;
+        size_t_vector lookup_;
+        std::size_t *lookup_ptr_ = 0;
+
+        lookup_.resize (size_ / dfa_alphabet_, null_token);
+        lookup_ptr_ = &lookup_.front ();
+        *lookup_ptr_ = 0;
+        // Only one 'jam' state, so skip it.
+        first_ += dfa_alphabet_;
+
+        for (; first_ < end_; first_ += dfa_alphabet_, ++index_)
+        {
+            for (second_ = first_ + dfa_alphabet_, curr_index_ = index_ + 1;
+                second_ < end_; second_ += dfa_alphabet_, ++curr_index_)
+            {
+                if (index_set_.find (curr_index_) != index_set_.end ())
+                {
+                    continue;
+                }
+
+                // Some systems have memcmp in namespace std.
+                using namespace std;
+
+                if (memcmp (first_, second_, sizeof (std::size_t) *
+                    dfa_alphabet_) == 0)
+                {
+                    index_set_.insert (curr_index_);
+                    lookup_ptr_[curr_index_] = new_index_;
+                }
+            }
+
+            if (lookup_ptr_[index_] == null_token)
+            {
+                lookup_ptr_[index_] = new_index_;
+                ++new_index_;
+            }
+        }
+
+        if (!index_set_.empty ())
+        {
+            const std::size_t *front_ = &dfa_.front ();
+            size_t_vector new_dfa_ (front_, front_ + dfa_alphabet_);
+            typename index_set::iterator set_end_ =
+                index_set_.end ();
+            const std::size_t *ptr_ = front_ + dfa_alphabet_;
+            std::size_t *new_ptr_ = 0;
+
+            new_dfa_.resize (size_ - index_set_.size () * dfa_alphabet_, 0);
+            new_ptr_ = &new_dfa_.front () + dfa_alphabet_;
+            size_ /= dfa_alphabet_;
+
+            for (index_ = 1; index_ < size_; ++index_)
+            {
+                if (index_set_.find (index_) != set_end_)
+                {
+                    ptr_ += dfa_alphabet_;
+                    continue;
+                }
+
+                new_ptr_[end_state_index] = ptr_[end_state_index];
+                new_ptr_[id_index] = ptr_[id_index];
+                new_ptr_[unique_id_index] = ptr_[unique_id_index];
+                new_ptr_[state_index] = ptr_[state_index];
+                new_ptr_[bol_index] = lookup_ptr_[ptr_[bol_index]];
+                new_ptr_[eol_index] = lookup_ptr_[ptr_[eol_index]];
+                new_ptr_ += dfa_offset;
+                ptr_ += dfa_offset;
+
+                for (std::size_t i_ = dfa_offset; i_ < dfa_alphabet_; ++i_)
+                {
+                    *new_ptr_++ = lookup_ptr_[*ptr_++];
+                }
+            }
+
+            dfa_.swap (new_dfa_);
+        }
+    }
+};
+
+typedef basic_generator<char> generator;
+typedef basic_generator<wchar_t> wgenerator;
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/internals.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/internals.hpp
new file mode 100644
index 0000000..5f3a026
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/internals.hpp
@@ -0,0 +1,60 @@
+// internals.hpp
+// Copyright (c) 2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_INTERNALS_HPP
+#define BOOST_LEXER_INTERNALS_HPP
+
+#include "containers/ptr_vector.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+struct internals
+{
+    typedef std::vector<std::size_t> size_t_vector;
+    typedef ptr_vector<size_t_vector> size_t_vector_vector;
+
+    size_t_vector_vector _lookup;
+    size_t_vector _dfa_alphabet;
+    size_t_vector_vector _dfa;
+    bool _seen_BOL_assertion;
+    bool _seen_EOL_assertion;
+
+    internals () :
+        _seen_BOL_assertion (false),
+        _seen_EOL_assertion (false)
+    {
+    }
+
+    void clear ()
+    {
+        _lookup.clear ();
+        _dfa_alphabet.clear ();
+        _dfa.clear ();
+        _seen_BOL_assertion = false;
+        _seen_EOL_assertion = false;
+    }
+
+    void swap (internals &internals_)
+    {
+        _lookup->swap (*internals_._lookup);
+        _dfa_alphabet.swap (internals_._dfa_alphabet);
+        _dfa->swap (*internals_._dfa);
+        std::swap (_seen_BOL_assertion, internals_._seen_BOL_assertion);
+        std::swap (_seen_EOL_assertion, internals_._seen_EOL_assertion);
+    }
+
+private:
+    internals (const internals &); // No copy construction.
+    internals &operator = (const internals &); // No assignment.
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/parser.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/parser.hpp
new file mode 100644
index 0000000..9000e5e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/parser.hpp
@@ -0,0 +1,511 @@
+// parser.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_PARSER_HPP
+#define BOOST_LEXER_PARSER_HPP
+
+#include <boost/assert.hpp>
+#include "tree/end_node.hpp"
+#include "tree/iteration_node.hpp"
+#include "tree/leaf_node.hpp"
+#include "../runtime_error.hpp"
+#include "tree/selection_node.hpp"
+#include "tree/sequence_node.hpp"
+#include "../size_t.hpp"
+#include "tokeniser/re_tokeniser.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+class basic_parser
+{
+public:
+    typedef basic_re_tokeniser<CharT> tokeniser;
+    typedef typename tokeniser::string string;
+    typedef std::map<string, const node *> macro_map;
+    typedef node::node_ptr_vector node_ptr_vector;
+    typedef typename tokeniser::num_token token;
+
+/*
+    General principles of regex parsing:
+    - Every regex is a sequence of sub-regexes.
+    - Regexes consist of operands and operators
+    - All operators decompose to sequence, selection ('|') and iteration ('*')
+    - Regex tokens are stored on the stack.
+    - When a complete sequence of regex tokens is on the stack it is processed.
+
+Grammar:
+
+<REGEX>      -> <OREXP>
+<OREXP>      -> <SEQUENCE> | <OREXP>'|'<SEQUENCE>
+<SEQUENCE>   -> <SUB>
+<SUB>        -> <EXPRESSION> | <SUB><EXPRESSION>
+<EXPRESSION> -> <REPEAT>
+<REPEAT>     -> charset | macro | '('<REGEX>')' | <REPEAT><DUPLICATE>
+<DUPLICATE>  -> '?' | '*' | '+' | '{n[,[m]]}'
+*/
+    static node *parse (const CharT *start_, const CharT * const end_,
+        const std::size_t id_, const std::size_t unique_id_,
+        const std::size_t dfa_state_, const regex_flags flags_,
+        const std::locale &locale_, node_ptr_vector &node_ptr_vector_,
+        const macro_map &macromap_, typename tokeniser::token_map &map_,
+        bool &seen_BOL_assertion_, bool &seen_EOL_assertion_)
+    {
+        node *root_ = 0;
+        state state_ (start_, end_, flags_, locale_);
+        token lhs_token_;
+        token rhs_token_;
+        token_stack token_stack_;
+        tree_node_stack tree_node_stack_;
+        char action_ = 0;
+
+        token_stack_.push (rhs_token_);
+        tokeniser::next (state_, map_, rhs_token_);
+
+        do
+        {
+            lhs_token_ = token_stack_.top ();
+            action_ = lhs_token_.precedence (rhs_token_._type);
+
+            switch (action_)
+            {
+            case '<':
+            case '=':
+                token_stack_.push (rhs_token_);
+                tokeniser::next (state_, map_, rhs_token_);
+                break;
+            case '>':
+                reduce (token_stack_, macromap_, node_ptr_vector_,
+                    tree_node_stack_);
+                break;
+            default:
+                std::ostringstream ss_;
+
+                ss_ << "A syntax error occured: '" <<
+                    lhs_token_.precedence_string () <<
+                    "' against '" << rhs_token_.precedence_string () <<
+                    "' at index " << state_.index () << ".";
+                throw runtime_error (ss_.str ().c_str ());
+                break;
+            }
+        } while (!token_stack_.empty ());
+
+        if (tree_node_stack_.empty ())
+        {
+            throw runtime_error ("Empty rules are not allowed.");
+        }
+
+        BOOST_ASSERT(tree_node_stack_.size () == 1);
+
+        node *lhs_node_ = tree_node_stack_.top ();
+
+        tree_node_stack_.pop ();
+
+        if (id_ == 0)
+        {
+            // Macros have no end state...
+            root_ = lhs_node_;
+        }
+        else
+        {
+            node_ptr_vector_->push_back (static_cast<end_node *>(0));
+
+            node *rhs_node_ = new end_node (id_, unique_id_, dfa_state_);
+
+            node_ptr_vector_->back () = rhs_node_;
+            node_ptr_vector_->push_back (static_cast<sequence_node *>(0));
+            node_ptr_vector_->back () = new sequence_node
+                (lhs_node_, rhs_node_);
+            root_ = node_ptr_vector_->back ();
+        }
+
+        // Done this way as bug in VC++ 6 prevents |= operator working
+        // properly!
+        if (state_._seen_BOL_assertion) seen_BOL_assertion_ = true;
+
+        if (state_._seen_EOL_assertion) seen_EOL_assertion_ = true;
+
+        return root_;
+    }
+
+private:
+    typedef typename tokeniser::state state;
+    typedef std::stack<token> token_stack;
+    typedef node::node_stack tree_node_stack;
+
+    static void reduce (token_stack &token_stack_,
+        const macro_map &macromap_, node_ptr_vector &node_vector_ptr_,
+        tree_node_stack &tree_node_stack_)
+    {
+        typename tokeniser::num_token lhs_;
+        typename tokeniser::num_token rhs_;
+        token_stack handle_;
+        char action_ = 0;
+
+        do
+        {
+            rhs_ = token_stack_.top ();
+            token_stack_.pop ();
+            handle_.push (rhs_);
+
+            if (!token_stack_.empty ())
+            {
+                lhs_ = token_stack_.top ();
+                action_ = lhs_.precedence (rhs_._type);
+            }
+        } while (!token_stack_.empty () && action_ == '=');
+
+        BOOST_ASSERT(token_stack_.empty () || action_ == '<');
+
+        switch (rhs_._type)
+        {
+        case token::BEGIN:
+            // finished processing so exit
+            break;
+        case token::REGEX:
+            // finished parsing, nothing to do
+            break;
+        case token::OREXP:
+            orexp (handle_, token_stack_, node_vector_ptr_, tree_node_stack_);
+            break;
+        case token::SEQUENCE:
+            token_stack_.push (token::OREXP);
+            break;
+        case token::SUB:
+            sub (handle_, token_stack_, node_vector_ptr_, tree_node_stack_);
+            break;
+        case token::EXPRESSION:
+            token_stack_.push (token::SUB);
+            break;
+        case token::REPEAT:
+            repeat (handle_, token_stack_);
+            break;
+        case token::CHARSET:
+            charset (handle_, token_stack_, node_vector_ptr_,
+                tree_node_stack_);
+            break;
+        case token::MACRO:
+            macro (handle_, token_stack_, macromap_, node_vector_ptr_,
+                tree_node_stack_);
+            break;
+        case token::OPENPAREN:
+            openparen (handle_, token_stack_);
+            break;
+        case token::OPT:
+        case token::AOPT:
+            optional (rhs_._type == token::OPT, node_vector_ptr_,
+                tree_node_stack_);
+            token_stack_.push (token::DUP);
+            break;
+        case token::ZEROORMORE:
+        case token::AZEROORMORE:
+            zero_or_more (rhs_._type == token::ZEROORMORE, node_vector_ptr_,
+                tree_node_stack_);
+            token_stack_.push (token::DUP);
+            break;
+        case token::ONEORMORE:
+        case token::AONEORMORE:
+            one_or_more (rhs_._type == token::ONEORMORE, node_vector_ptr_,
+                tree_node_stack_);
+            token_stack_.push (token::DUP);
+            break;
+        case token::REPEATN:
+        case token::AREPEATN:
+            repeatn (rhs_._type == token::REPEATN, handle_.top (),
+                node_vector_ptr_, tree_node_stack_);
+            token_stack_.push (token::DUP);
+            break;
+        default:
+            throw runtime_error
+                ("Internal error regex_parser::reduce");
+            break;
+        }
+    }
+
+    static void orexp (token_stack &handle_, token_stack &token_stack_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        BOOST_ASSERT(handle_.top ()._type == token::OREXP &&
+            (handle_.size () == 1 || handle_.size () == 3));
+
+        if (handle_.size () == 1)
+        {
+            token_stack_.push (token::REGEX);
+        }
+        else
+        {
+            handle_.pop ();
+            BOOST_ASSERT(handle_.top ()._type == token::OR);
+            handle_.pop ();
+            BOOST_ASSERT(handle_.top ()._type == token::SEQUENCE);
+            perform_or (node_ptr_vector_, tree_node_stack_);
+            token_stack_.push (token::OREXP);
+        }
+    }
+
+    static void sub (token_stack &handle_, token_stack &token_stack_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        BOOST_ASSERT(handle_.top ()._type == token::SUB &&
+            (handle_.size () == 1 || handle_.size () == 2));
+
+        if (handle_.size () == 1)
+        {
+            token_stack_.push (token::SEQUENCE);
+        }
+        else
+        {
+            handle_.pop ();
+            BOOST_ASSERT(handle_.top ()._type == token::EXPRESSION);
+            // perform join
+            sequence (node_ptr_vector_, tree_node_stack_);
+            token_stack_.push (token::SUB);
+        }
+    }
+
+    static void repeat (token_stack &handle_, token_stack &token_stack_)
+    {
+        BOOST_ASSERT(handle_.top ()._type == token::REPEAT &&
+            handle_.size () >= 1 && handle_.size () <= 3);
+
+        if (handle_.size () == 1)
+        {
+            token_stack_.push (token::EXPRESSION);
+        }
+        else
+        {
+            handle_.pop ();
+            BOOST_ASSERT(handle_.top ()._type == token::DUP);
+            token_stack_.push (token::REPEAT);
+        }
+    }
+
+    static void charset (token_stack &handle_, token_stack &token_stack_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        BOOST_ASSERT(handle_.top ()._type == token::CHARSET &&
+            handle_.size () == 1);
+        // store charset
+        node_ptr_vector_->push_back (static_cast<leaf_node *>(0));
+
+        const size_t id_ = handle_.top ()._id;
+
+        node_ptr_vector_->back () = new leaf_node (id_, true);
+        tree_node_stack_.push (node_ptr_vector_->back ());
+        token_stack_.push (token::REPEAT);
+    }
+
+    static void macro (token_stack &handle_, token_stack &token_stack_,
+        const macro_map &macromap_, node_ptr_vector &node_ptr_vector_,
+        tree_node_stack &tree_node_stack_)
+    {
+        token &top_ = handle_.top ();
+
+        BOOST_ASSERT(top_._type == token::MACRO && handle_.size () == 1);
+
+        typename macro_map::const_iterator iter_ =
+            macromap_.find (top_._macro);
+
+        if (iter_ == macromap_.end ())
+        {
+            const CharT *name_ = top_._macro;
+            std::basic_stringstream<CharT> ss_;
+            std::ostringstream os_;
+
+            os_ << "Unknown MACRO name '";
+
+            while (*name_)
+            {
+                os_ << ss_.narrow (*name_++, ' ');
+            }
+
+            os_ << "'.";
+            throw runtime_error (os_.str ());
+        }
+
+        tree_node_stack_.push (iter_->second->copy (node_ptr_vector_));
+        token_stack_.push (token::REPEAT);
+    }
+
+    static void openparen (token_stack &handle_, token_stack &token_stack_)
+    {
+        BOOST_ASSERT(handle_.top ()._type == token::OPENPAREN &&
+            handle_.size () == 3);
+        handle_.pop ();
+        BOOST_ASSERT(handle_.top ()._type == token::REGEX);
+        handle_.pop ();
+        BOOST_ASSERT(handle_.top ()._type == token::CLOSEPAREN);
+        token_stack_.push (token::REPEAT);
+    }
+
+    static void perform_or (node_ptr_vector &node_ptr_vector_,
+        tree_node_stack &tree_node_stack_)
+    {
+        // perform or
+        node *rhs_ = tree_node_stack_.top ();
+
+        tree_node_stack_.pop ();
+
+        node *lhs_ = tree_node_stack_.top ();
+
+        node_ptr_vector_->push_back (static_cast<selection_node *>(0));
+        node_ptr_vector_->back () = new selection_node (lhs_, rhs_);
+        tree_node_stack_.top () = node_ptr_vector_->back ();
+    }
+
+    static void sequence (node_ptr_vector &node_ptr_vector_,
+        tree_node_stack &tree_node_stack_)
+    {
+        node *rhs_ = tree_node_stack_.top ();
+
+        tree_node_stack_.pop ();
+
+        node *lhs_ = tree_node_stack_.top ();
+
+        node_ptr_vector_->push_back (static_cast<sequence_node *>(0));
+        node_ptr_vector_->back () = new sequence_node (lhs_, rhs_);
+        tree_node_stack_.top () = node_ptr_vector_->back ();
+    }
+
+    static void optional (const bool greedy_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        // perform ?
+        node *lhs_ = tree_node_stack_.top ();
+        // You don't know if lhs_ is a leaf_node, so get firstpos.
+        node::node_vector &firstpos_ = lhs_->firstpos ();
+
+        for (node::node_vector::iterator iter_ = firstpos_.begin (),
+            end_ = firstpos_.end (); iter_ != end_; ++iter_)
+        {
+            // These are leaf_nodes!
+            (*iter_)->greedy (greedy_);
+        }
+
+        node_ptr_vector_->push_back (static_cast<leaf_node *>(0));
+
+        node *rhs_ = new leaf_node (null_token, greedy_);
+
+        node_ptr_vector_->back () = rhs_;
+        node_ptr_vector_->push_back (static_cast<selection_node *>(0));
+        node_ptr_vector_->back () = new selection_node (lhs_, rhs_);
+        tree_node_stack_.top () = node_ptr_vector_->back ();
+    }
+
+    static void zero_or_more (const bool greedy_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        // perform *
+        node *ptr_ = tree_node_stack_.top ();
+
+        node_ptr_vector_->push_back (static_cast<iteration_node *>(0));
+        node_ptr_vector_->back () = new iteration_node (ptr_, greedy_);
+        tree_node_stack_.top () = node_ptr_vector_->back ();
+    }
+
+    static void one_or_more (const bool greedy_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        // perform +
+        node *lhs_ = tree_node_stack_.top ();
+        node *copy_ = lhs_->copy (node_ptr_vector_);
+
+        node_ptr_vector_->push_back (static_cast<iteration_node *>(0));
+
+        node *rhs_ = new iteration_node (copy_, greedy_);
+
+        node_ptr_vector_->back () = rhs_;
+        node_ptr_vector_->push_back (static_cast<sequence_node *>(0));
+        node_ptr_vector_->back () = new sequence_node (lhs_, rhs_);
+        tree_node_stack_.top () = node_ptr_vector_->back ();
+    }
+
+    // This is one of the most mind bending routines in this code...
+    static void repeatn (const bool greedy_, const token &token_,
+        node_ptr_vector &node_ptr_vector_, tree_node_stack &tree_node_stack_)
+    {
+        // perform {n[,[m]]}
+        // Semantic checks have already been performed.
+        // {0,}  = *
+        // {0,1} = ?
+        // {1,}  = +
+        // therefore we do not check for these cases.
+        if (!(token_._min == 1 && !token_._comma))
+        {
+            const std::size_t top_ = token_._min > 0 ?
+                token_._min : token_._max;
+
+            if (token_._min == 0)
+            {
+                optional (greedy_, node_ptr_vector_, tree_node_stack_);
+            }
+
+            node *prev_ = tree_node_stack_.top ()->copy (node_ptr_vector_);
+            node *curr_ = 0;
+
+            for (std::size_t i_ = 2; i_ < top_; ++i_)
+            {
+                curr_ = prev_->copy (node_ptr_vector_);
+                tree_node_stack_.push (static_cast<node *>(0));
+                tree_node_stack_.top () = prev_;
+                sequence (node_ptr_vector_, tree_node_stack_);
+                prev_ = curr_;
+            }
+
+            if (token_._comma && token_._min > 0)
+            {
+                if (token_._min > 1)
+                {
+                    curr_ = prev_->copy (node_ptr_vector_);
+                    tree_node_stack_.push (static_cast<node *>(0));
+                    tree_node_stack_.top () = prev_;
+                    sequence (node_ptr_vector_, tree_node_stack_);
+                    prev_ = curr_;
+                }
+
+                if (token_._comma && token_._max)
+                {
+                    tree_node_stack_.push (static_cast<node *>(0));
+                    tree_node_stack_.top () = prev_;
+                    optional (greedy_, node_ptr_vector_, tree_node_stack_);
+                    prev_ = tree_node_stack_.top ();
+                    tree_node_stack_.pop ();
+
+                    const std::size_t count_ = token_._max - token_._min;
+
+                    for (std::size_t i_ = 1; i_ < count_; ++i_)
+                    {
+                        curr_ = prev_->copy (node_ptr_vector_);
+                        tree_node_stack_.push (static_cast<node *>(0));
+                        tree_node_stack_.top () = prev_;
+                        sequence (node_ptr_vector_, tree_node_stack_);
+                        prev_ = curr_;
+                    }
+                }
+                else
+                {
+                    tree_node_stack_.push (static_cast<node *>(0));
+                    tree_node_stack_.top () = prev_;
+                    zero_or_more (greedy_, node_ptr_vector_, tree_node_stack_);
+                    prev_ = tree_node_stack_.top ();
+                    tree_node_stack_.pop ();
+                }
+            }
+
+            tree_node_stack_.push (static_cast<node *>(0));
+            tree_node_stack_.top () = prev_;
+            sequence (node_ptr_vector_, tree_node_stack_);
+        }
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/num_token.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/num_token.hpp
new file mode 100644
index 0000000..dc1c6bd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/num_token.hpp
@@ -0,0 +1,146 @@
+// num_token.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_NUM_TOKEN_HPP
+#define BOOST_LEXER_NUM_TOKEN_HPP
+
+#include <boost/config.hpp>
+#include "../../consts.hpp" // null_token
+#include "../../size_t.hpp"
+#include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+struct basic_num_token
+{
+    enum type {BEGIN, REGEX, OREXP, SEQUENCE, SUB, EXPRESSION, REPEAT,
+        DUP, OR, CHARSET, MACRO, OPENPAREN, CLOSEPAREN, OPT, AOPT,
+        ZEROORMORE, AZEROORMORE, ONEORMORE, AONEORMORE, REPEATN, AREPEATN,
+        END};
+
+    type _type;
+    std::size_t _id;
+    std::size_t _min;
+    bool _comma;
+    std::size_t _max;
+    CharT _macro[max_macro_len + 1];
+    static const char _precedence_table[END + 1][END + 1];
+    static const char *_precedence_strings[END + 1];
+
+    basic_num_token (const type type_ = BEGIN,
+        const std::size_t id_ = null_token) :
+        _type (type_),
+        _id (id_),
+        _min (0),
+        _comma (false),
+        _max (0)
+    {
+        *_macro = 0;
+    }
+
+    basic_num_token &operator = (const basic_num_token &rhs_)
+    {
+        _type = rhs_._type;
+        _id = rhs_._id;
+        _min = rhs_._min;
+        _comma = rhs_._comma;
+        _max = rhs_._max;
+
+        if (_type == MACRO)
+        {
+            const CharT *read_ = rhs_._macro;
+            CharT *write_ = _macro;
+
+            while (*read_)
+            {
+                *write_++ = *read_++;
+            }
+
+            *write_ = 0;
+        }
+
+        return *this;
+    }
+
+    void set (const type type_)
+    {
+        _type = type_;
+        _id = null_token;
+    }
+
+    void set (const type type_, const std::size_t id_)
+    {
+        _type = type_;
+        _id = id_;
+    }
+
+    void min_max (const std::size_t min_, const bool comma_,
+        const std::size_t max_)
+    {
+        _min = min_;
+        _comma = comma_;
+        _max = max_;
+    }
+
+    char precedence (const type type_) const
+    {
+        return _precedence_table[_type][type_];
+    }
+
+    const char *precedence_string () const
+    {
+        return _precedence_strings[_type];
+    }
+};
+
+template<typename CharT>
+const char basic_num_token<CharT>::_precedence_table[END + 1][END + 1] = {
+//        BEG, REG, ORE, SEQ, SUB, EXP, RPT, DUP,  | , CHR, MCR,  ( ,  ) ,  ? , ?? ,  * , *? ,  + , +?, {n}?, {n}, END
+/*BEGIN*/{' ', '<', '<', '<', '<', '<', '<', ' ', ' ', '<', '<', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*REGEX*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '=', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*OREXP*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '=', '>', '>', ' ', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* SEQ */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', ' ', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* SUB */{' ', ' ', ' ', ' ', ' ', '=', '<', ' ', '>', '<', '<', '<', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*EXPRE*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* RPT */{' ', ' ', ' ', ' ', ' ', ' ', ' ', '=', '>', '>', '>', '>', '>', '<', '<', '<', '<', '<', '<', '<', '<', '>'},
+/*DUPLI*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*  |  */{' ', ' ', ' ', '=', '<', '<', '<', ' ', ' ', '<', '<', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+/*CHARA*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>'},
+/*MACRO*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>'},
+/*  (  */{' ', '=', '<', '<', '<', '<', '<', ' ', ' ', '<', '<', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+/*  )  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>', '>'},
+/*  ?  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* ??  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*  *  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* *?  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*  +  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* +?  */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*{n,m}*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', '<', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/*{nm}?*/{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>', '>', '>', '>', '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '>'},
+/* END */{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '}
+};
+
+template<typename CharT>
+const char *basic_num_token<CharT>::_precedence_strings[END + 1] =
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(910))
+{{"BEGIN"}, {"REGEX"}, {"OREXP"}, {"SEQUENCE"}, {"SUB"}, {"EXPRESSION"},
+    {"REPEAT"}, {"DUPLICATE"}, {"|"}, {"CHARSET"}, {"MACRO"},
+    {"("}, {")"}, {"?"}, {"??"}, {"*"}, {"*?"}, {"+"}, {"+?"}, {"{n[,[m]]}"},
+    {"{n[,[m]]}?"}, {"END"}};
+#else
+{"BEGIN", "REGEX", "OREXP", "SEQUENCE", "SUB", "EXPRESSION", "REPEAT",
+    "DUPLICATE", "|", "CHARSET", "MACRO", "(", ")", "?", "??", "*", "*?",
+    "+", "+?", "{n[,[m]]}", "{n[,[m]]}?", "END"};
+#endif
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser.hpp
new file mode 100644
index 0000000..7bdeb80
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser.hpp
@@ -0,0 +1,574 @@
+// tokeniser.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_RE_TOKENISER_HPP
+#define BOOST_LEXER_RE_TOKENISER_HPP
+
+// memcpy()
+#include <cstring>
+#include <map>
+#include "num_token.hpp"
+#include "../../runtime_error.hpp"
+#include "../../size_t.hpp"
+#include <sstream>
+#include "../../string_token.hpp"
+#include "re_tokeniser_helper.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+class basic_re_tokeniser
+{
+public:
+    typedef basic_num_token<CharT> num_token;
+    typedef basic_re_tokeniser_state<CharT> state;
+    typedef basic_string_token<CharT> string_token;
+    typedef typename string_token::string string;
+    typedef std::map<string_token, std::size_t> token_map;
+    typedef std::pair<string_token, std::size_t> token_pair;
+
+    static void next (state &state_, token_map &map_, num_token &token_)
+    {
+        CharT ch_ = 0;
+        bool eos_ = state_.next (ch_);
+
+        token_.min_max (0, false, 0);
+
+        while (!eos_ && ch_ == '"')
+        {
+            state_._in_string ^= 1;
+            eos_ = state_.next (ch_);
+        }
+
+        if (eos_)
+        {
+            if (state_._in_string)
+            {
+                throw runtime_error ("Unexpected end of regex "
+                    "(missing '\"').");
+            }
+
+            if (state_._paren_count)
+            {
+                throw runtime_error ("Unexpected end of regex "
+                    "(missing ')').");
+            }
+
+            token_.set (num_token::END, null_token);
+        }
+        else
+        {
+            if (ch_ == '\\')
+            {
+                // Even if we are in a string, respect escape sequences...
+                escape (state_, map_, token_);
+            }
+            else if (state_._in_string)
+            {
+                // All other meta characters lose their special meaning
+                // inside a string.
+                create_charset_token (string (1, ch_), false, map_, token_);
+            }
+            else
+            {
+                // Not an escape sequence and not inside a string, so
+                // check for meta characters.
+                switch (ch_)
+                {
+                case '(':
+                    token_.set (num_token::OPENPAREN, null_token);
+                    ++state_._paren_count;
+                    read_options (state_);
+                    break;
+                case ')':
+                    --state_._paren_count;
+
+                    if (state_._paren_count < 0)
+                    {
+                        std::ostringstream ss_;
+
+                        ss_ << "Number of open parenthesis < 0 at index " <<
+                            state_.index () - 1 << '.';
+                        throw runtime_error (ss_.str ().c_str ());
+                    }
+
+                    token_.set (num_token::CLOSEPAREN, null_token);
+
+                    if (!state_._flags_stack.empty ())
+                    {
+                        state_._flags = state_._flags_stack.top ();
+                        state_._flags_stack.pop ();
+                    }
+                    break;
+                case '?':
+                    if (!state_.eos () && *state_._curr == '?')
+                    {
+                        token_.set (num_token::AOPT, null_token);
+                        state_.increment ();
+                    }
+                    else
+                    {
+                        token_.set (num_token::OPT, null_token);
+                    }
+
+                    break;
+                case '*':
+                    if (!state_.eos () && *state_._curr == '?')
+                    {
+                        token_.set (num_token::AZEROORMORE, null_token);
+                        state_.increment ();
+                    }
+                    else
+                    {
+                        token_.set (num_token::ZEROORMORE, null_token);
+                    }
+
+                    break;
+                case '+':
+                    if (!state_.eos () && *state_._curr == '?')
+                    {
+                        token_.set (num_token::AONEORMORE, null_token);
+                        state_.increment ();
+                    }
+                    else
+                    {
+                        token_.set (num_token::ONEORMORE, null_token);
+                    }
+
+                    break;
+                case '{':
+                    open_curly (state_, token_);
+                    break;
+                case '|':
+                    token_.set (num_token::OR, null_token);
+                    break;
+                case '^':
+                    if (state_._curr - 1 == state_._start)
+                    {
+                        token_.set (num_token::CHARSET, bol_token);
+                        state_._seen_BOL_assertion = true;
+                    }
+                    else
+                    {
+                        create_charset_token (string (1, ch_), false,
+                            map_, token_);
+                    }
+
+                    break;
+                case '$':
+                    if (state_._curr == state_._end)
+                    {
+                        token_.set (num_token::CHARSET, eol_token);
+                        state_._seen_EOL_assertion = true;
+                    }
+                    else
+                    {
+                        create_charset_token (string (1, ch_), false,
+                            map_, token_);
+                    }
+
+                    break;
+                case '.':
+                {
+                    string dot_;
+
+                    if (state_._flags & dot_not_newline)
+                    {
+                        dot_ = '\n';
+                    }
+
+                    create_charset_token (dot_, true, map_, token_);
+                    break;
+                }
+                case '[':
+                {
+                    charset (state_, map_, token_);
+                    break;
+                }
+                case '/':
+                    throw runtime_error("Lookahead ('/') is not supported yet.");
+                    break;
+                default:
+                    if ((state_._flags & icase) &&
+                        (std::isupper (ch_, state_._locale) ||
+                        std::islower (ch_, state_._locale)))
+                    {
+                        CharT upper_ = std::toupper (ch_, state_._locale);
+                        CharT lower_ = std::tolower (ch_, state_._locale);
+
+                        string str_ (1, upper_);
+
+                        str_ += lower_;
+                        create_charset_token (str_, false, map_, token_);
+                    }
+                    else
+                    {
+                        create_charset_token (string (1, ch_), false,
+                            map_, token_);
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
+
+private:
+    typedef basic_re_tokeniser_helper<CharT> tokeniser_helper;
+
+    static void read_options (state &state_)
+    {
+        if (!state_.eos () && *state_._curr == '?')
+        {
+            CharT ch_ = 0;
+            bool eos_ = false;
+            bool negate_ = false;
+
+            state_.increment ();
+            eos_ = state_.next (ch_);
+            state_._flags_stack.push (state_._flags);
+
+            while (!eos_ && ch_ != ':')
+            {
+                switch (ch_)
+                {
+                case '-':
+                    negate_ ^= 1;
+                    break;
+                case 'i':
+                    if (negate_)
+                    {
+                        state_._flags = static_cast<regex_flags>
+                            (state_._flags & ~icase);
+                    }
+                    else
+                    {
+                        state_._flags = static_cast<regex_flags>
+                            (state_._flags | icase);
+                    }
+
+                    negate_ = false;
+                    break;
+                case 's':
+                    if (negate_)
+                    {
+                        state_._flags = static_cast<regex_flags>
+                            (state_._flags | dot_not_newline);
+                    }
+                    else
+                    {
+                        state_._flags = static_cast<regex_flags>
+                            (state_._flags & ~dot_not_newline);
+                    }
+
+                    negate_ = false;
+                    break;
+                default:
+                {
+                    std::ostringstream ss_;
+
+                    ss_ << "Unknown option at index " <<
+                        state_.index () - 1 << '.';
+                    throw runtime_error (ss_.str ().c_str ());
+                }
+                }
+
+                eos_ = state_.next (ch_);
+            }
+
+            // End of string handler will handle early termination
+        }
+        else if (!state_._flags_stack.empty ())
+        {
+            state_._flags_stack.push (state_._flags);
+        }
+    }
+
+    static void escape (state &state_, token_map &map_, num_token &token_)
+    {
+        CharT ch_ = 0;
+        std::size_t str_len_ = 0;
+        const CharT *str_ = tokeniser_helper::escape_sequence (state_,
+            ch_, str_len_);
+
+        if (str_)
+        {
+            state state2_ (str_ + 1, str_ + str_len_, state_._flags,
+                state_._locale);
+
+            charset (state2_, map_, token_);
+        }
+        else
+        {
+            create_charset_token (string (1, ch_), false, map_, token_);
+        }
+    }
+
+    static void charset (state &state_, token_map &map_, num_token &token_)
+    {
+        string chars_;
+        bool negated_ = false;
+
+        tokeniser_helper::charset (state_, chars_, negated_);
+        create_charset_token (chars_, negated_, map_, token_);
+    }
+
+    static void create_charset_token (const string &charset_,
+        const bool negated_, token_map &map_, num_token &token_)
+    {
+        std::size_t id_ = null_token;
+        string_token stok_ (negated_, charset_);
+
+        stok_.remove_duplicates ();
+        stok_.normalise ();
+
+        typename token_map::const_iterator iter_ = map_.find (stok_);
+
+        if (iter_ == map_.end ())
+        {
+            id_ = map_.size ();
+            map_.insert (token_pair (stok_, id_));
+        }
+        else
+        {
+            id_ = iter_->second;
+        }
+
+        token_.set (num_token::CHARSET, id_);
+    }
+
+    static void open_curly (state &state_, num_token &token_)
+    {
+        if (state_.eos ())
+        {
+            throw runtime_error ("Unexpected end of regex "
+                "(missing '}').");
+        }
+        else if (*state_._curr >= '0' && *state_._curr <= '9')
+        {
+            repeat_n (state_, token_);
+
+            if (!state_.eos () && *state_._curr == '?')
+            {
+                token_._type = num_token::AREPEATN;
+                state_.increment ();
+            }
+        }
+        else
+        {
+            macro (state_, token_);
+        }
+    }
+
+    // SYNTAX:
+    //   {n[,[n]]}
+    // SEMANTIC RULES:
+    //   {0} - INVALID (throw exception)
+    //   {0,} = *
+    //   {0,0} - INVALID (throw exception)
+    //   {0,1} = ?
+    //   {1,} = +
+    //   {min,max} where min == max - {min}
+    //   {min,max} where max < min - INVALID (throw exception)
+    static void repeat_n (state &state_, num_token &token_)
+    {
+        CharT ch_ = 0;
+        bool eos_ = state_.next (ch_);
+
+        while (!eos_ && ch_ >= '0' && ch_ <= '9')
+        {
+            token_._min *= 10;
+            token_._min += ch_ - '0';
+            eos_ = state_.next (ch_);
+        }
+
+        if (eos_)
+        {
+            throw runtime_error ("Unexpected end of regex "
+                "(missing '}').");
+        }
+
+        bool min_max_ = false;
+        bool repeatn_ = true;
+
+        token_._comma = ch_ == ',';
+
+        if (token_._comma)
+        {
+            eos_ = state_.next (ch_);
+
+            if (eos_)
+            {
+                throw runtime_error ("Unexpected end of regex "
+                    "(missing '}').");
+            }
+
+            if (ch_ == '}')
+            {
+                // Small optimisation: Check for '*' equivalency.
+                if (token_._min == 0)
+                {
+                    token_.set (num_token::ZEROORMORE, null_token);
+                    repeatn_ = false;
+                }
+                // Small optimisation: Check for '+' equivalency.
+                else if (token_._min == 1)
+                {
+                    token_.set (num_token::ONEORMORE, null_token);
+                    repeatn_ = false;
+                }
+            }
+            else
+            {
+                if (ch_ < '0' || ch_ > '9')
+                {
+                    std::ostringstream ss_;
+
+                    ss_ << "Missing '}' at index " <<
+                        state_.index () - 1 << '.';
+                    throw runtime_error (ss_.str ().c_str ());
+                }
+
+                min_max_ = true;
+
+                do
+                {
+                    token_._max *= 10;
+                    token_._max += ch_ - '0';
+                    eos_ = state_.next (ch_);
+                } while (!eos_ && ch_ >= '0' && ch_ <= '9');
+
+                if (eos_)
+                {
+                    throw runtime_error ("Unexpected end of regex "
+                        "(missing '}').");
+                }
+
+                // Small optimisation: Check for '?' equivalency.
+                if (token_._min == 0 && token_._max == 1)
+                {
+                    token_.set (num_token::OPT, null_token);
+                    repeatn_ = false;
+                }
+                // Small optimisation: if min == max, then min.
+                else if (token_._min == token_._max)
+                {
+                    token_._comma = false;
+                    min_max_ = false;
+                    token_._max = 0;
+                }
+            }
+        }
+
+        if (ch_ != '}')
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Missing '}' at index " << state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        if (repeatn_)
+        {
+            // SEMANTIC VALIDATION follows:
+            // NOTE: {0,} has already become *
+            // therefore we don't check for a comma.
+            if (token_._min == 0 && token_._max == 0)
+            {
+                std::ostringstream ss_;
+
+                ss_ << "Cannot have exactly zero repeats preceding index " <<
+                    state_.index () << '.';
+                throw runtime_error (ss_.str ().c_str ());
+            }
+
+            if (min_max_ && token_._max < token_._min)
+            {
+                std::ostringstream ss_;
+
+                ss_ << "Max less than min preceding index " <<
+                    state_.index () << '.';
+                throw runtime_error (ss_.str ().c_str ());
+            }
+
+            token_.set (num_token::REPEATN, null_token);
+        }
+    }
+
+    static void macro (state &state_, num_token &token_)
+    {
+        CharT ch_ = 0;
+        bool eos_ = false;
+        const CharT *start_ = state_._curr;
+
+        state_.next (ch_);
+
+        if (ch_ != '_' && !(ch_ >= 'A' && ch_ <= 'Z') &&
+            !(ch_ >= 'a' && ch_ <= 'z'))
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Invalid MACRO name at index " <<
+                state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        do
+        {
+            eos_ = state_.next (ch_);
+
+            if (eos_)
+            {
+                throw runtime_error ("Unexpected end of regex "
+                    "(missing '}').");
+            }
+        } while (ch_ == '_' || ch_ == '-' || (ch_ >= 'A' && ch_ <= 'Z') ||
+            (ch_ >= 'a' && ch_ <= 'z') || (ch_ >= '0' && ch_ <= '9'));
+
+        if (ch_ != '}')
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Missing '}' at index " << state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        std::size_t len_ = state_._curr - 1 - start_;
+
+        if (len_ > max_macro_len)
+        {
+            std::basic_stringstream<CharT> ss_;
+            std::ostringstream os_;
+
+            os_ << "MACRO name '";
+
+            while (len_)
+            {
+                os_ << ss_.narrow (*start_++, ' ');
+                --len_;
+            }
+
+            os_ << "' too long.";
+            throw runtime_error (os_.str ());
+        }
+
+        token_.set (num_token::MACRO, null_token);
+
+        // Some systems have memcpy in namespace std.
+        using namespace std;
+
+        memcpy (token_._macro, start_, len_ * sizeof (CharT));
+        token_._macro[len_] = 0;
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_helper.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_helper.hpp
new file mode 100644
index 0000000..6e0791e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_helper.hpp
@@ -0,0 +1,549 @@
+// tokeniser_helper.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_RE_TOKENISER_HELPER_H
+#define BOOST_LEXER_RE_TOKENISER_HELPER_H
+
+#include "../../char_traits.hpp"
+// strlen()
+#include <cstring>
+#include "../../size_t.hpp"
+#include "re_tokeniser_state.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT, typename Traits = char_traits<CharT> >
+class basic_re_tokeniser_helper
+{
+public:
+    typedef basic_re_tokeniser_state<CharT> state;
+    typedef std::basic_string<CharT> string;
+
+    static const CharT *escape_sequence (state &state_, CharT &ch_,
+        std::size_t &str_len_)
+    {
+        bool eos_ = state_.eos ();
+
+        if (eos_)
+        {
+            throw runtime_error ("Unexpected end of regex "
+                "following '\\'.");
+        }
+
+        const CharT *str_ = charset_shortcut (*state_._curr, str_len_);
+
+        if (str_)
+        {
+            state_.increment ();
+        }
+        else
+        {
+            ch_ = chr (state_);
+        }
+
+        return str_;
+    }
+
+    // This function can call itself.
+    static void charset (state &state_, string &chars_, bool &negated_)
+    {
+        CharT ch_ = 0;
+        bool eos_ = state_.next (ch_);
+
+        if (eos_)
+        {
+            // Pointless returning index if at end of string
+            throw runtime_error ("Unexpected end of regex "
+                "following '['.");
+        }
+
+        negated_ = ch_ == '^';
+
+        if (negated_)
+        {
+            eos_ = state_.next (ch_);
+
+            if (eos_)
+            {
+                // Pointless returning index if at end of string
+                throw runtime_error ("Unexpected end of regex "
+                    "following '^'.");
+            }
+        }
+
+        bool chset_ = false;
+        CharT prev_ = 0;
+
+        while (ch_ != ']')
+        {
+            if (ch_ == '\\')
+            {
+                std::size_t str_len_ = 0;
+                const CharT *str_ = escape_sequence (state_, prev_, str_len_);
+
+                chset_ = str_ != 0;
+
+                if (chset_)
+                {
+                    state temp_state_ (str_ + 1, str_ + str_len_,
+                        state_._flags, state_._locale);
+                    string temp_chars_;
+                    bool temp_negated_ = false;
+
+                    charset (temp_state_, temp_chars_, temp_negated_);
+
+                    if (negated_ != temp_negated_)
+                    {
+                        std::ostringstream ss_;
+
+                        ss_ << "Mismatch in charset negation preceding "
+                            "index " << state_.index () << '.';
+                        throw runtime_error (ss_.str ().c_str ());
+                    }
+
+                    chars_ += temp_chars_;
+                }
+            }
+/*
+            else if (ch_ == '[' && !state_.eos () && *state_._curr == ':')
+            {
+                // TODO: POSIX charsets
+            }
+*/
+            else
+            {
+                chset_ = false;
+                prev_ = ch_;
+            }
+
+            eos_ = state_.next (ch_);
+
+            // Covers preceding if, else if and else
+            if (eos_)
+            {
+                // Pointless returning index if at end of string
+                throw runtime_error ("Unexpected end of regex "
+                    "(missing ']').");
+            }
+
+            if (ch_ == '-')
+            {
+                charset_range (chset_, state_, eos_, ch_, prev_, chars_);
+            }
+            else if (!chset_)
+            {
+                if ((state_._flags & icase) &&
+                    (std::isupper (prev_, state_._locale) ||
+                    std::islower (prev_, state_._locale)))
+                {
+                    CharT upper_ = std::toupper (prev_, state_._locale);
+                    CharT lower_ = std::tolower (prev_, state_._locale);
+
+                    chars_ += upper_;
+                    chars_ += lower_;
+                }
+                else
+                {
+                    chars_ += prev_;
+                }
+            }
+        }
+
+        if (!negated_ && chars_.empty ())
+        {
+            throw runtime_error ("Empty charsets not allowed.");
+        }
+    }
+
+    static CharT chr (state &state_)
+    {
+        CharT ch_ = 0;
+
+        // eos_ has already been checked for.
+        switch (*state_._curr)
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+                ch_ = decode_octal (state_);
+                break;
+            case 'a':
+                ch_ = '\a';
+                state_.increment ();
+                break;
+            case 'b':
+                ch_ = '\b';
+                state_.increment ();
+                break;
+            case 'c':
+                ch_ = decode_control_char (state_);
+                break;
+            case 'e':
+                ch_ = 27; // '\e' not recognised by compiler
+                state_.increment ();
+                break;
+            case 'f':
+                ch_ = '\f';
+                state_.increment ();
+                break;
+            case 'n':
+                ch_ = '\n';
+                state_.increment ();
+                break;
+            case 'r':
+                ch_ = '\r';
+                state_.increment ();
+                break;
+            case 't':
+                ch_ = '\t';
+                state_.increment ();
+                break;
+            case 'v':
+                ch_ = '\v';
+                state_.increment ();
+                break;
+            case 'x':
+                ch_ = decode_hex (state_);
+                break;
+            default:
+                ch_ = *state_._curr;
+                state_.increment ();
+                break;
+        }
+
+        return ch_;
+    }
+
+private:
+    static const char *charset_shortcut (const char ch_,
+        std::size_t &str_len_)
+    {
+        const char *str_ = 0;
+
+        switch (ch_)
+        {
+        case 'd':
+            str_ = "[0-9]";
+            break;
+        case 'D':
+            str_ = "[^0-9]";
+            break;
+        case 's':
+            str_ = "[ \t\n\r\f\v]";
+            break;
+        case 'S':
+            str_ = "[^ \t\n\r\f\v]";
+            break;
+        case 'w':
+            str_ = "[_0-9A-Za-z]";
+            break;
+        case 'W':
+            str_ = "[^_0-9A-Za-z]";
+            break;
+        }
+
+        if (str_)
+        {
+            // Some systems have strlen in namespace std.
+            using namespace std;
+
+            str_len_ = strlen (str_);
+        }
+        else
+        {
+            str_len_ = 0;
+        }
+
+        return str_;
+    }
+
+    static const wchar_t *charset_shortcut (const wchar_t ch_,
+        std::size_t &str_len_)
+    {
+        const wchar_t *str_ = 0;
+
+        switch (ch_)
+        {
+        case 'd':
+            str_ = L"[0-9]";
+            break;
+        case 'D':
+            str_ = L"[^0-9]";
+            break;
+        case 's':
+            str_ = L"[ \t\n\r\f\v]";
+            break;
+        case 'S':
+            str_ = L"[^ \t\n\r\f\v]";
+            break;
+        case 'w':
+            str_ = L"[_0-9A-Za-z]";
+            break;
+        case 'W':
+            str_ = L"[^_0-9A-Za-z]";
+            break;
+        }
+
+        if (str_)
+        {
+            // Some systems have wcslen in namespace std.
+            using namespace std;
+
+            str_len_ = wcslen (str_);
+        }
+        else
+        {
+            str_len_ = 0;
+        }
+
+        return str_;
+    }
+
+    static CharT decode_octal (state &state_)
+    {
+        std::size_t accumulator_ = 0;
+        CharT ch_ = *state_._curr;
+        unsigned short count_ = 3;
+        bool eos_ = false;
+
+        for (;;)
+        {
+            accumulator_ *= 8;
+            accumulator_ += ch_ - '0';
+            --count_;
+            state_.increment ();
+            eos_ = state_.eos ();
+
+            if (!count_ || eos_) break;
+
+            ch_ = *state_._curr;
+
+            // Don't consume invalid chars!
+            if (ch_ < '0' || ch_ > '7')
+            {
+                break;
+            }
+        }
+
+        return static_cast<CharT> (accumulator_);
+    }
+
+    static CharT decode_control_char (state &state_)
+    {
+        // Skip over 'c'
+        state_.increment ();
+
+        CharT ch_ = 0;
+        bool eos_ = state_.next (ch_);
+
+        if (eos_)
+        {
+            // Pointless returning index if at end of string
+            throw runtime_error ("Unexpected end of regex following \\c.");
+        }
+        else
+        {
+            if (ch_ >= 'a' && ch_ <= 'z')
+            {
+                ch_ -= 'a' - 1;
+            }
+            else if (ch_ >= 'A' && ch_ <= 'Z')
+            {
+                ch_ -= 'A' - 1;
+            }
+            else if (ch_ == '@')
+            {
+                // Apparently...
+                ch_ = 0;
+            }
+            else
+            {
+                std::ostringstream ss_;
+
+                ss_ << "Invalid control char at index " <<
+                    state_.index () - 1 << '.';
+                throw runtime_error (ss_.str ().c_str ());
+            }
+        }
+
+        return ch_;
+    }
+
+    static CharT decode_hex (state &state_)
+    {
+        // Skip over 'x'
+        state_.increment ();
+
+        CharT ch_ = 0;
+        bool eos_ = state_.next (ch_);
+
+        if (eos_)
+        {
+            // Pointless returning index if at end of string
+            throw runtime_error ("Unexpected end of regex following \\x.");
+        }
+
+        if (!((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'a' && ch_ <= 'f') ||
+            (ch_ >= 'A' && ch_ <= 'F')))
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Illegal char following \\x at index " <<
+                state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        std::size_t hex_ = 0;
+
+        do
+        {
+            hex_ *= 16;
+
+            if (ch_ >= '0' && ch_ <= '9')
+            {
+                hex_ += ch_ - '0';
+            }
+            else if (ch_ >= 'a' && ch_ <= 'f')
+            {
+                hex_ += 10 + (ch_ - 'a');
+            }
+            else
+            {
+                hex_ += 10 + (ch_ - 'A');
+            }
+
+            eos_ = state_.eos ();
+
+            if (!eos_)
+            {
+                ch_ = *state_._curr;
+
+                // Don't consume invalid chars!
+                if (((ch_ >= '0' && ch_ <= '9') ||
+                    (ch_ >= 'a' && ch_ <= 'f') || (ch_ >= 'A' && ch_ <= 'F')))
+                {
+                    state_.increment ();
+                }
+                else
+                {
+                    eos_ = true;
+                }
+            }
+        } while (!eos_);
+
+        return static_cast<CharT> (hex_);
+    }
+
+    static void charset_range (const bool chset_, state &state_, bool &eos_,
+        CharT &ch_, const CharT prev_, string &chars_)
+    {
+        if (chset_)
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Charset cannot form start of range preceding "
+                "index " << state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        eos_ = state_.next (ch_);
+
+        if (eos_)
+        {
+            // Pointless returning index if at end of string
+            throw runtime_error ("Unexpected end of regex "
+                "following '-'.");
+        }
+
+        CharT curr_ = 0;
+
+        if (ch_ == '\\')
+        {
+            std::size_t str_len_ = 0;
+
+            if (escape_sequence (state_, curr_, str_len_))
+            {
+                std::ostringstream ss_;
+
+                ss_ << "Charset cannot form end of range preceding index "
+                    << state_.index () << '.';
+                throw runtime_error (ss_.str ().c_str ());
+            }
+        }
+/*
+        else if (ch_ == '[' && !state_.eos () && *state_._curr == ':')
+        {
+            std::ostringstream ss_;
+
+            ss_ << "POSIX char class cannot form end of range at "
+                "index " << state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+*/
+        else
+        {
+            curr_ = ch_;
+        }
+
+        eos_ = state_.next (ch_);
+
+        // Covers preceding if and else
+        if (eos_)
+        {
+            // Pointless returning index if at end of string
+            throw runtime_error ("Unexpected end of regex "
+                "(missing ']').");
+        }
+
+        std::size_t start_ = static_cast<typename Traits::index_type> (prev_);
+        std::size_t end_ = static_cast<typename Traits::index_type> (curr_);
+
+        // Semanic check
+        if (end_ < start_)
+        {
+            std::ostringstream ss_;
+
+            ss_ << "Invalid range in charset preceding index " <<
+                state_.index () - 1 << '.';
+            throw runtime_error (ss_.str ().c_str ());
+        }
+
+        chars_.reserve (chars_.size () + (end_ + 1 - start_));
+
+        for (; start_ <= end_; ++start_)
+        {
+            CharT ch_ = static_cast<CharT> (start_);
+
+            if ((state_._flags & icase) &&
+                (std::isupper (ch_, state_._locale) ||
+                std::islower (ch_, state_._locale)))
+            {
+                CharT upper_ = std::toupper (ch_, state_._locale);
+                CharT lower_ = std::tolower (ch_, state_._locale);
+
+                chars_ += (upper_);
+                chars_ += (lower_);
+            }
+            else
+            {
+                chars_ += (ch_);
+            }
+        }
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_state.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_state.hpp
new file mode 100644
index 0000000..35995ad
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tokeniser/re_tokeniser_state.hpp
@@ -0,0 +1,98 @@
+// tokeniser_state.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_RE_TOKENISER_STATE_HPP
+#define BOOST_LEXER_RE_TOKENISER_STATE_HPP
+
+#include "../../consts.hpp"
+#include <locale>
+#include "../../size_t.hpp"
+#include <stack>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+struct basic_re_tokeniser_state
+{
+    const CharT * const _start;
+    const CharT * const _end;
+    const CharT *_curr;
+    regex_flags _flags;
+    std::stack<regex_flags> _flags_stack;
+    std::locale _locale;
+    long _paren_count;
+    bool _in_string;
+    bool _seen_BOL_assertion;
+    bool _seen_EOL_assertion;
+
+    basic_re_tokeniser_state (const CharT *start_, const CharT * const end_,
+        const regex_flags flags_, const std::locale locale_) :
+        _start (start_),
+        _end (end_),
+        _curr (start_),
+        _flags (flags_),
+        _locale (locale_),
+        _paren_count (0),
+        _in_string (false),
+        _seen_BOL_assertion (false),
+        _seen_EOL_assertion (false)
+    {
+    }
+
+    // prevent VC++ 7.1 warning:
+    const basic_re_tokeniser_state &operator =
+        (const basic_re_tokeniser_state &rhs_)
+    {
+        _start = rhs_._start;
+        _end = rhs_._end;
+        _curr = rhs_._curr;
+        _flags = rhs_._flags;
+        _locale = rhs_._locale;
+        _paren_count = rhs_._paren_count;
+        _in_string = rhs_._in_string;
+        _seen_BOL_assertion = rhs_._seen_BOL_assertion;
+        _seen_EOL_assertion = rhs_._seen_EOL_assertion;
+        return this;
+    }
+
+    inline bool next (CharT &ch_)
+    {
+        if (_curr >= _end)
+        {
+            ch_ = 0;
+            return true;
+        }
+        else
+        {
+            ch_ = *_curr;
+            increment ();
+            return false;
+        }
+    }
+
+    inline void increment ()
+    {
+        ++_curr;
+    }
+
+    inline std::size_t index ()
+    {
+        return _curr - _start;
+    }
+
+    inline bool eos ()
+    {
+        return _curr >= _end;
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/end_node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/end_node.hpp
new file mode 100644
index 0000000..c613e6a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/end_node.hpp
@@ -0,0 +1,90 @@
+// end_node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_END_NODE_HPP
+#define BOOST_LEXER_END_NODE_HPP
+
+#include "node.hpp"
+#include "../../size_t.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class end_node : public node
+{
+public:
+    end_node (const std::size_t id_, const std::size_t unique_id_,
+        const std::size_t lexer_state_) :
+        node (false),
+        _id (id_),
+        _unique_id (unique_id_),
+        _lexer_state (lexer_state_)
+    {
+        node::_firstpos.push_back (this);
+        node::_lastpos.push_back (this);
+    }
+
+    virtual ~end_node ()
+    {
+    }
+
+    virtual type what_type () const
+    {
+        return END;
+    }
+
+    virtual bool traverse (const_node_stack &/*node_stack_*/,
+        bool_stack &/*perform_op_stack_*/) const
+    {
+        return false;
+    }
+
+    virtual const node_vector &followpos () const
+    {
+        // _followpos is always empty..!
+        return _followpos;
+    }
+
+    virtual bool end_state () const
+    {
+        return true;
+    }
+
+    virtual std::size_t id () const
+    {
+        return _id;
+    }
+
+    virtual std::size_t unique_id () const
+    {
+        return _unique_id;
+    }
+
+    virtual std::size_t lexer_state () const
+    {
+        return _lexer_state;
+    }
+
+private:
+    std::size_t _id;
+    std::size_t _unique_id;
+    std::size_t _lexer_state;
+    node_vector _followpos;
+
+    virtual void copy_node (node_ptr_vector &/*node_ptr_vector_*/,
+        node_stack &/*new_node_stack_*/, bool_stack &/*perform_op_stack_*/,
+        bool &/*down_*/) const
+    {
+        // Nothing to do, as end_nodes are not copied.
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/iteration_node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/iteration_node.hpp
new file mode 100644
index 0000000..6b39462
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/iteration_node.hpp
@@ -0,0 +1,90 @@
+// iteration_node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_ITERATION_NODE_HPP
+#define BOOST_LEXER_ITERATION_NODE_HPP
+
+#include "node.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class iteration_node : public node
+{
+public:
+    iteration_node (node *next_, const bool greedy_) :
+        node (true),
+        _next (next_),
+        _greedy (greedy_)
+    {
+        node_vector::iterator iter_;
+        node_vector::iterator end_;
+
+        _next->append_firstpos (_firstpos);
+        _next->append_lastpos (_lastpos);
+
+        for (iter_ = _lastpos.begin (), end_ = _lastpos.end ();
+            iter_ != end_; ++iter_)
+        {
+            (*iter_)->append_followpos (_firstpos);
+        }
+
+        for (iter_ = _firstpos.begin (), end_ = _firstpos.end ();
+            iter_ != end_; ++iter_)
+        {
+            (*iter_)->greedy (greedy_);
+        }
+    }
+
+    virtual ~iteration_node ()
+    {
+    }
+
+    virtual type what_type () const
+    {
+        return ITERATION;
+    }
+
+    virtual bool traverse (const_node_stack &node_stack_,
+        bool_stack &perform_op_stack_) const
+    {
+        perform_op_stack_.push (true);
+        node_stack_.push (_next);
+        return true;
+    }
+
+private:
+    // Not owner of this pointer...
+    node *_next;
+    bool _greedy;
+
+    virtual void copy_node (node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &perform_op_stack_,
+        bool &down_) const
+    {
+        if (perform_op_stack_.top ())
+        {
+            node *ptr_ = new_node_stack_.top ();
+
+            node_ptr_vector_->push_back (static_cast<iteration_node *>(0));
+            node_ptr_vector_->back () = new iteration_node (ptr_, _greedy);
+            new_node_stack_.top () = node_ptr_vector_->back ();
+        }
+        else
+        {
+            down_ = true;
+        }
+
+        perform_op_stack_.pop ();
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/leaf_node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/leaf_node.hpp
new file mode 100644
index 0000000..39ed98d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/leaf_node.hpp
@@ -0,0 +1,107 @@
+// leaf_node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_LEAF_NODE_HPP
+#define BOOST_LEXER_LEAF_NODE_HPP
+
+#include "../../consts.hpp" // null_token
+#include "node.hpp"
+#include "../../size_t.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class leaf_node : public node
+{
+public:
+    leaf_node (const std::size_t token_, const bool greedy_) :
+        node (token_ == null_token),
+        _token (token_),
+        _set_greedy (!greedy_),
+        _greedy (greedy_)
+    {
+        if (!_nullable)
+        {
+            _firstpos.push_back (this);
+            _lastpos.push_back (this);
+        }
+    }
+
+    virtual ~leaf_node ()
+    {
+    }
+
+    virtual void append_followpos (const node_vector &followpos_)
+    {
+        for (node_vector::const_iterator iter_ = followpos_.begin (),
+            end_ = followpos_.end (); iter_ != end_; ++iter_)
+        {
+            _followpos.push_back (*iter_);
+        }
+    }
+
+    virtual type what_type () const
+    {
+        return LEAF;
+    }
+
+    virtual bool traverse (const_node_stack &/*node_stack_*/,
+        bool_stack &/*perform_op_stack_*/) const
+    {
+        return false;
+    }
+
+    virtual std::size_t token () const
+    {
+        return _token;
+    }
+
+    virtual void greedy (const bool greedy_)
+    {
+        if (!_set_greedy)
+        {
+            _greedy = greedy_;
+            _set_greedy = true;
+        }
+    }
+
+    virtual bool greedy () const
+    {
+        return _greedy;
+    }
+
+    virtual const node_vector &followpos () const
+    {
+        return _followpos;
+    }
+
+    virtual node_vector &followpos ()
+    {
+        return _followpos;
+    }
+
+private:
+    std::size_t _token;
+    bool _set_greedy;
+    bool _greedy;
+    node_vector _followpos;
+
+    virtual void copy_node (node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &/*perform_op_stack_*/,
+        bool &/*down_*/) const
+    {
+        node_ptr_vector_->push_back (static_cast<leaf_node *>(0));
+        node_ptr_vector_->back () = new leaf_node (_token, _greedy);
+        new_node_stack_.push (node_ptr_vector_->back ());
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/node.hpp
new file mode 100644
index 0000000..1e36ccb
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/node.hpp
@@ -0,0 +1,188 @@
+// node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_NODE_HPP
+#define BOOST_LEXER_NODE_HPP
+
+#include <boost/assert.hpp>
+#include "../../containers/ptr_vector.hpp"
+#include "../../runtime_error.hpp"
+#include "../../size_t.hpp"
+#include <stack>
+#include <vector>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class node
+{
+public:
+    enum type {LEAF, SEQUENCE, SELECTION, ITERATION, END};
+
+    typedef std::stack<bool> bool_stack;
+    typedef std::stack<node *> node_stack;
+    // stack and vector not owner of node pointers
+    typedef std::stack<const node *> const_node_stack;
+    typedef std::vector<node *> node_vector;
+    typedef ptr_vector<node> node_ptr_vector;
+
+    node () :
+        _nullable (false)
+    {
+    }
+
+    node (const bool nullable_) :
+        _nullable (nullable_)
+    {
+    }
+
+    virtual ~node ()
+    {
+    }
+
+    bool nullable () const
+    {
+        return _nullable;
+    }
+
+    void append_firstpos (node_vector &firstpos_) const
+    {
+        firstpos_.insert (firstpos_.end (),
+            _firstpos.begin (), _firstpos.end ());
+    }
+
+    void append_lastpos (node_vector &lastpos_) const
+    {
+        lastpos_.insert (lastpos_.end (),
+            _lastpos.begin (), _lastpos.end ());
+    }
+
+    virtual void append_followpos (const node_vector &/*followpos_*/)
+    {
+        throw runtime_error ("Internal error node::append_followpos()");
+    }
+
+    node *copy (node_ptr_vector &node_ptr_vector_) const
+    {
+        node *new_root_ = 0;
+        const_node_stack node_stack_;
+        bool_stack perform_op_stack_;
+        bool down_ = true;
+        node_stack new_node_stack_;
+
+        node_stack_.push (this);
+
+        while (!node_stack_.empty ())
+        {
+            while (down_)
+            {
+                down_ = node_stack_.top ()->traverse (node_stack_,
+                    perform_op_stack_);
+            }
+
+            while (!down_ && !node_stack_.empty ())
+            {
+                const node *top_ = node_stack_.top ();
+
+                top_->copy_node (node_ptr_vector_, new_node_stack_,
+                    perform_op_stack_, down_);
+
+                if (!down_) node_stack_.pop ();
+            }
+        }
+
+        BOOST_ASSERT(new_node_stack_.size () == 1);
+        new_root_ = new_node_stack_.top ();
+        new_node_stack_.pop ();
+        return new_root_;
+    }
+
+    virtual type what_type () const = 0;
+
+    virtual bool traverse (const_node_stack &node_stack_,
+        bool_stack &perform_op_stack_) const = 0;
+
+    node_vector &firstpos ()
+    {
+        return _firstpos;
+    }
+
+    const node_vector &firstpos () const
+    {
+        return _firstpos;
+    }
+
+    // _lastpos modified externally, so not const &
+    node_vector &lastpos ()
+    {
+        return _lastpos;
+    }
+
+    virtual bool end_state () const
+    {
+        return false;
+    }
+
+    virtual std::size_t id () const
+    {
+        throw runtime_error ("Internal error node::id()");
+    }
+
+    virtual std::size_t unique_id () const
+    {
+        throw runtime_error ("Internal error node::unique_id()");
+    }
+
+    virtual std::size_t lexer_state () const
+    {
+        throw runtime_error ("Internal error node::state()");
+    }
+
+    virtual std::size_t token () const
+    {
+        throw runtime_error ("Internal error node::token()");
+    }
+
+    virtual void greedy (const bool /*greedy_*/)
+    {
+        throw runtime_error ("Internal error node::token(bool)");
+    }
+
+    virtual bool greedy () const
+    {
+        throw runtime_error ("Internal error node::token()");
+    }
+
+    virtual const node_vector &followpos () const
+    {
+        throw runtime_error ("Internal error node::followpos()");
+    }
+
+    virtual node_vector &followpos ()
+    {
+        throw runtime_error ("Internal error node::followpos()");
+    }
+
+protected:
+    const bool _nullable;
+    node_vector _firstpos;
+    node_vector _lastpos;
+
+    virtual void copy_node (node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &perform_op_stack_,
+        bool &down_) const = 0;
+
+private:
+    node (node const &); // No copy construction.
+    node &operator = (node const &); // No assignment.
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/selection_node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/selection_node.hpp
new file mode 100644
index 0000000..67e5ea0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/selection_node.hpp
@@ -0,0 +1,94 @@
+// selection_node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_SELECTION_NODE_HPP
+#define BOOST_LEXER_SELECTION_NODE_HPP
+
+#include "node.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class selection_node : public node
+{
+public:
+    selection_node (node *left_, node *right_) :
+        node (left_->nullable () || right_->nullable ()),
+        _left (left_),
+        _right (right_)
+    {
+        _left->append_firstpos (_firstpos);
+        _right->append_firstpos (_firstpos);
+        _left->append_lastpos (_lastpos);
+        _right->append_lastpos (_lastpos);
+    }
+
+    virtual ~selection_node ()
+    {
+    }
+
+    virtual type what_type () const
+    {
+        return SELECTION;
+    }
+
+    virtual bool traverse (const_node_stack &node_stack_,
+        bool_stack &perform_op_stack_) const
+    {
+        perform_op_stack_.push (true);
+
+        switch (_right->what_type ())
+        {
+        case SEQUENCE:
+        case SELECTION:
+        case ITERATION:
+            perform_op_stack_.push (false);
+            break;
+        default:
+            break;
+        }
+
+        node_stack_.push (_right);
+        node_stack_.push (_left);
+        return true;
+    }
+
+private:
+    // Not owner of these pointers...
+    node *_left;
+    node *_right;
+
+    virtual void copy_node (node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &perform_op_stack_,
+        bool &down_) const
+    {
+        if (perform_op_stack_.top ())
+        {
+            node *rhs_ = new_node_stack_.top ();
+
+            new_node_stack_.pop ();
+
+            node *lhs_ = new_node_stack_.top ();
+
+            node_ptr_vector_->push_back (static_cast<selection_node *>(0));
+            node_ptr_vector_->back () = new selection_node (lhs_, rhs_);
+            new_node_stack_.top () = node_ptr_vector_->back ();
+        }
+        else
+        {
+            down_ = true;
+        }
+
+        perform_op_stack_.pop ();
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/sequence_node.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/sequence_node.hpp
new file mode 100644
index 0000000..471fa68
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/parser/tree/sequence_node.hpp
@@ -0,0 +1,112 @@
+// sequence_node.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_SEQUENCE_NODE_HPP
+#define BOOST_LEXER_SEQUENCE_NODE_HPP
+
+#include "node.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+class sequence_node : public node
+{
+public:
+    sequence_node (node *left_, node *right_) :
+        node (left_->nullable () && right_->nullable ()),
+        _left (left_),
+        _right (right_)
+    {
+        _left->append_firstpos (_firstpos);
+
+        if (_left->nullable ())
+        {
+            _right->append_firstpos (_firstpos);
+        }
+
+        if (_right->nullable ())
+        {
+            _left->append_lastpos (_lastpos);
+        }
+
+        _right->append_lastpos (_lastpos);
+
+        node_vector &lastpos_ = _left->lastpos ();
+        const node_vector &firstpos_ = _right->firstpos ();
+
+        for (node_vector::iterator iter_ = lastpos_.begin (),
+            end_ = lastpos_.end (); iter_ != end_; ++iter_)
+        {
+            (*iter_)->append_followpos (firstpos_);
+        }
+    }
+
+    virtual ~sequence_node ()
+    {
+    }
+
+    virtual type what_type () const
+    {
+        return SEQUENCE;
+    }
+
+    virtual bool traverse (const_node_stack &node_stack_,
+        bool_stack &perform_op_stack_) const
+    {
+        perform_op_stack_.push (true);
+
+        switch (_right->what_type ())
+        {
+        case SEQUENCE:
+        case SELECTION:
+        case ITERATION:
+            perform_op_stack_.push (false);
+            break;
+        default:
+            break;
+        }
+
+        node_stack_.push (_right);
+        node_stack_.push (_left);
+        return true;
+    }
+
+private:
+    // Not owner of these pointers...
+    node *_left;
+    node *_right;
+
+    virtual void copy_node (node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &perform_op_stack_,
+        bool &down_) const
+    {
+        if (perform_op_stack_.top ())
+        {
+            node *rhs_ = new_node_stack_.top ();
+
+            new_node_stack_.pop ();
+
+            node *lhs_ = new_node_stack_.top ();
+
+            node_ptr_vector_->push_back (static_cast<sequence_node *>(0));
+            node_ptr_vector_->back () = new sequence_node (lhs_, rhs_);
+            new_node_stack_.top () = node_ptr_vector_->back ();
+        }
+        else
+        {
+            down_ = true;
+        }
+
+        perform_op_stack_.pop ();
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/charset.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/charset.hpp
new file mode 100644
index 0000000..c74dd36
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/charset.hpp
@@ -0,0 +1,81 @@
+// charset.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_CHARSET_HPP
+#define BOOST_LEXER_CHARSET_HPP
+
+#include <set>
+#include "../size_t.hpp"
+#include "../string_token.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+template<typename CharT>
+struct basic_charset
+{
+    typedef basic_string_token<CharT> token;
+    typedef std::set<std::size_t> index_set;
+
+    token _token;
+    index_set _index_set;
+
+    basic_charset ()
+    {
+    }
+
+    basic_charset (const token &token_, const std::size_t index_) :
+        _token (token_)
+    {
+        _index_set.insert (index_);
+    }
+
+    bool empty () const
+    {
+        return _token.empty () && _index_set.empty ();
+    }
+
+    void intersect (basic_charset &rhs_, basic_charset &overlap_)
+    {
+        _token.intersect (rhs_._token, overlap_._token);
+
+        if (!overlap_._token.empty ())
+        {
+            typename index_set::const_iterator iter_ = _index_set.begin ();
+            typename index_set::const_iterator end_ = _index_set.end ();
+
+            for (; iter_ != end_; ++iter_)
+            {
+                overlap_._index_set.insert (*iter_);
+            }
+
+            iter_ = rhs_._index_set.begin ();
+            end_ = rhs_._index_set.end ();
+
+            for (; iter_ != end_; ++iter_)
+            {
+                overlap_._index_set.insert (*iter_);
+            }
+
+            if (_token.empty ())
+            {
+                _index_set.clear ();
+            }
+
+            if (rhs_._token.empty ())
+            {
+                rhs_._index_set.clear ();
+            }
+        }
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/equivset.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/equivset.hpp
new file mode 100644
index 0000000..b39fb15
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/partition/equivset.hpp
@@ -0,0 +1,140 @@
+// equivset.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_EQUIVSET_HPP
+#define BOOST_LEXER_EQUIVSET_HPP
+
+#include <algorithm>
+#include "../parser/tree/node.hpp"
+#include <set>
+#include "../size_t.hpp"
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+struct equivset
+{
+    typedef std::set<std::size_t> index_set;
+    typedef std::vector<std::size_t> index_vector;
+    // Not owner of nodes:
+    typedef std::vector<node *> node_vector;
+
+    index_vector _index_vector;
+    bool _greedy;
+    std::size_t _id;
+    node_vector _followpos;
+
+    equivset () :
+        _greedy (true),
+        _id (0)
+    {
+    }
+
+    equivset (const index_set &index_set_, const bool greedy_,
+        const std::size_t id_, const node_vector &followpos_) :
+        _greedy (greedy_),
+        _id (id_),
+        _followpos (followpos_)
+    {
+        index_set::const_iterator iter_ = index_set_.begin ();
+        index_set::const_iterator end_ = index_set_.end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            _index_vector.push_back (*iter_);
+        }
+    }
+
+    bool empty () const
+    {
+        return _index_vector.empty () && _followpos.empty ();
+    }
+
+    void intersect (equivset &rhs_, equivset &overlap_)
+    {
+        intersect_indexes (rhs_._index_vector, overlap_._index_vector);
+
+        if (!overlap_._index_vector.empty ())
+        {
+            // Note that the LHS takes priority in order to
+            // respect rule ordering priority in the lex spec.
+            overlap_._id = _id;
+            overlap_._greedy = _greedy;
+            overlap_._followpos = _followpos;
+
+            node_vector::const_iterator overlap_begin_ =
+                overlap_._followpos.begin ();
+            node_vector::const_iterator overlap_end_ =
+                overlap_._followpos.end ();
+            node_vector::const_iterator rhs_iter_ =
+                rhs_._followpos.begin ();
+            node_vector::const_iterator rhs_end_ =
+                rhs_._followpos.end ();
+
+            for (; rhs_iter_ != rhs_end_; ++rhs_iter_)
+            {
+                node *node_ = *rhs_iter_;
+
+                if (std::find (overlap_begin_, overlap_end_, node_) ==
+                    overlap_end_)
+                {
+                    overlap_._followpos.push_back (node_);
+                    overlap_begin_ = overlap_._followpos.begin ();
+                    overlap_end_ = overlap_._followpos.end ();
+                }
+            }
+
+            if (_index_vector.empty ())
+            {
+                _followpos.clear ();
+            }
+
+            if (rhs_._index_vector.empty ())
+            {
+                rhs_._followpos.clear ();
+            }
+        }
+    }
+
+private:
+    void intersect_indexes (index_vector &rhs_, index_vector &overlap_)
+    {
+        index_vector::iterator iter_ = _index_vector.begin ();
+        index_vector::iterator end_ = _index_vector.end ();
+        index_vector::iterator rhs_iter_ = rhs_.begin ();
+        index_vector::iterator rhs_end_ = rhs_.end ();
+
+        while (iter_ != end_ && rhs_iter_ != rhs_end_)
+        {
+            const std::size_t index_ = *iter_;
+            const std::size_t rhs_index_ = *rhs_iter_;
+
+            if (index_ < rhs_index_)
+            {
+                ++iter_;
+            }
+            else if (index_ > rhs_index_)
+            {
+                ++rhs_iter_;
+            }
+            else
+            {
+                overlap_.push_back (index_);
+                iter_ = _index_vector.erase (iter_);
+                end_ = _index_vector.end ();
+                rhs_iter_ = rhs_.erase (rhs_iter_);
+                rhs_end_ = rhs_.end ();
+            }
+        }
+    }
+};
+}
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/rules.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/rules.hpp
new file mode 100644
index 0000000..83cc9a4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/rules.hpp
@@ -0,0 +1,806 @@
+// rules.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_RULES_HPP
+#define BOOST_LEXER_RULES_HPP
+
+#include "consts.hpp"
+#include <deque>
+#include <locale>
+#include <map>
+#include "runtime_error.hpp"
+#include <set>
+#include "size_t.hpp"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace boost
+{
+namespace lexer
+{
+namespace detail
+{
+    // return name of initial state
+    template <typename CharT>
+    struct strings;
+
+    template <>
+    struct strings<char>
+    {
+        static const char *initial ()
+        {
+            return "INITIAL";
+        }
+
+        static const char *dot ()
+        {
+            return ".";
+        }
+
+        static const char *all_states ()
+        {
+            return "*";
+        }
+
+        static const char *char_name ()
+        {
+            return "char";
+        }
+
+        static const char *char_prefix ()
+        {
+            return "";
+        }
+    };
+
+    template <>
+    struct strings<wchar_t>
+    {
+        static const wchar_t *initial ()
+        {
+            return L"INITIAL";
+        }
+
+        static const wchar_t *dot ()
+        {
+            return L".";
+        }
+
+        static const wchar_t *all_states ()
+        {
+            return L"*";
+        }
+
+        static const char *char_name ()
+        {
+            return "wchar_t";
+        }
+
+        static const char *char_prefix ()
+        {
+            return "L";
+        }
+    };
+}
+
+template<typename CharT>
+class basic_rules
+{
+public:
+    typedef std::vector<std::size_t> id_vector;
+    typedef std::deque<id_vector> id_vector_deque;
+    typedef std::basic_string<CharT> string;
+    typedef std::deque<string> string_deque;
+    typedef std::deque<string_deque> string_deque_deque;
+    typedef std::set<string> string_set;
+    typedef std::pair<string, string> string_pair;
+    typedef std::deque<string_pair> string_pair_deque;
+    typedef std::map<string, std::size_t> string_size_t_map;
+    typedef std::pair<string, std::size_t> string_size_t_pair;
+
+    basic_rules (const regex_flags flags_ = dot_not_newline,
+        std::size_t (*counter_ptr_) () = 0) :
+        _flags (flags_),
+        _counter (0),
+        _counter_ptr (counter_ptr_)
+    {
+        add_state (initial ());
+    }
+
+    void clear ()
+    {
+        _statemap.clear ();
+        _macrodeque.clear ();
+        _macroset.clear ();
+        _regexes.clear ();
+        _ids.clear ();
+        _unique_ids.clear ();
+        _states.clear ();
+        _flags = dot_not_newline;
+        _locale = std::locale ();
+        add_state (initial ());
+    }
+
+    void clear (const CharT *state_name_)
+    {
+        std::size_t state_ = state (state_name_);
+
+        if (state_ != npos)
+        {
+            _regexes[state_].clear ();
+            _ids[state_].clear ();
+            _unique_ids[state_].clear ();
+            _states[state_].clear ();
+        }
+    }
+
+    void flags (const regex_flags flags_)
+    {
+        _flags = flags_;
+    }
+
+    regex_flags flags () const
+    {
+        return _flags;
+    }
+
+    std::size_t next_unique_id ()
+    {
+        return _counter_ptr ? _counter_ptr () : _counter++;
+    }
+
+    std::locale imbue (std::locale &locale_)
+    {
+        std::locale loc_ = _locale;
+
+        _locale = locale_;
+        return loc_;
+    }
+
+    const std::locale &locale () const
+    {
+        return _locale;
+    }
+
+    std::size_t state (const CharT *name_) const
+    {
+        std::size_t state_ = npos;
+        typename string_size_t_map::const_iterator iter_ =
+            _statemap.find (name_);
+
+        if (iter_ != _statemap.end ())
+        {
+            state_ = iter_->second;
+        }
+
+        return state_;
+    }
+
+    const CharT *state (const std::size_t index_) const
+    {
+        if (index_ == 0)
+        {
+            return initial ();
+        }
+        else
+        {
+            const std::size_t vec_index_ = index_ - 1;
+
+            if (vec_index_ > _lexer_state_names.size () - 1)
+            {
+                return 0;
+            }
+            else
+            {
+                return _lexer_state_names[vec_index_].c_str ();
+            }
+        }
+    }
+
+    std::size_t add_state (const CharT *name_)
+    {
+        validate (name_);
+
+        if (_statemap.insert (string_size_t_pair (name_,
+            _statemap.size ())).second)
+        {
+            _regexes.push_back (string_deque ());
+            _ids.push_back (id_vector ());
+            _unique_ids.push_back (id_vector ());
+            _states.push_back (id_vector ());
+
+            if (string (name_) != initial ())
+            {
+                _lexer_state_names.push_back (name_);
+            }
+        }
+
+        // Initial is not stored, so no need to - 1.
+        return _lexer_state_names.size ();
+    }
+
+    void add_macro (const CharT *name_, const CharT *regex_)
+    {
+        add_macro (name_, string (regex_));
+    }
+
+    void add_macro (const CharT *name_, const CharT *regex_start_,
+        const CharT *regex_end_)
+    {
+        add_macro (name_, string (regex_start_, regex_end_));
+    }
+
+    void add_macro (const CharT *name_, const string &regex_)
+    {
+        validate (name_);
+
+        typename string_set::const_iterator iter_ = _macroset.find (name_);
+
+        if (iter_ == _macroset.end ())
+        {
+            _macrodeque.push_back (string_pair (name_, regex_));
+            _macroset.insert (name_);
+        }
+        else
+        {
+            std::basic_stringstream<CharT> ss_;
+            std::ostringstream os_;
+
+            os_ << "Attempt to redefine MACRO '";
+
+            while (*name_)
+            {
+                os_ << ss_.narrow (*name_++, static_cast<CharT> (' '));
+            }
+
+            os_ << "'.";
+            throw runtime_error (os_.str ());
+        }
+    }
+
+    void add_macros (const basic_rules<CharT> &rules_)
+    {
+        const string_pair_deque &macros_ = rules_.macrodeque ();
+        typename string_pair_deque::const_iterator macro_iter_ =
+            macros_.begin ();
+        typename string_pair_deque::const_iterator macro_end_ =
+            macros_.end ();
+
+        for (; macro_iter_ != macro_end_; ++macro_iter_)
+        {
+            add_macro (macro_iter_->first.c_str (),
+                macro_iter_->second.c_str ());
+        }
+    }
+
+    void merge_macros (const basic_rules<CharT> &rules_)
+    {
+        const string_pair_deque &macros_ = rules_.macrodeque ();
+        typename string_pair_deque::const_iterator macro_iter_ =
+            macros_.begin ();
+        typename string_pair_deque::const_iterator macro_end_ =
+            macros_.end ();
+        typename string_set::const_iterator macro_dest_iter_;
+        typename string_set::const_iterator macro_dest_end_ = _macroset.end ();
+
+        for (; macro_iter_ != macro_end_; ++macro_iter_)
+        {
+            macro_dest_iter_ = _macroset.find (macro_iter_->first);
+
+            if (macro_dest_iter_ == macro_dest_end_)
+            {
+                add_macro (macro_iter_->first.c_str (),
+                    macro_iter_->second.c_str ());
+            }
+        }
+    }
+
+    std::size_t add (const CharT *regex_, const std::size_t id_)
+    {
+        return add (string (regex_), id_);
+    }
+
+    std::size_t add (const CharT *regex_start_, const CharT *regex_end_,
+        const std::size_t id_)
+    {
+        return add (string (regex_start_, regex_end_), id_);
+    }
+
+    std::size_t add (const string &regex_, const std::size_t id_)
+    {
+        const std::size_t counter_ = next_unique_id ();
+
+        check_for_invalid_id (id_);
+        _regexes.front ().push_back (regex_);
+        _ids.front ().push_back (id_);
+        _unique_ids.front ().push_back (counter_);
+        _states.front ().push_back (0);
+        return counter_;
+    }
+
+    std::size_t add (const CharT *curr_state_, const CharT *regex_,
+        const CharT *new_state_)
+    {
+        return add (curr_state_, string (regex_), new_state_);
+    }
+
+    std::size_t add (const CharT *curr_state_, const CharT *regex_start_,
+        const CharT *regex_end_, const CharT *new_state_)
+    {
+        return add (curr_state_, string (regex_start_, regex_end_),
+            new_state_);
+    }
+
+    std::size_t add (const CharT *curr_state_, const string &regex_,
+        const CharT *new_state_)
+    {
+        return add (curr_state_, regex_, 0, new_state_, false);
+    }
+
+    std::size_t add (const CharT *curr_state_, const CharT *regex_,
+        const std::size_t id_, const CharT *new_state_)
+    {
+        return add (curr_state_, string (regex_), id_, new_state_);
+    }
+
+    std::size_t add (const CharT *curr_state_, const CharT *regex_start_,
+        const CharT *regex_end_, const std::size_t id_,
+        const CharT *new_state_)
+    {
+        return add (curr_state_, string (regex_start_, regex_end_), id_,
+            new_state_);
+    }
+
+    std::size_t add (const CharT *curr_state_, const string &regex_,
+        const std::size_t id_, const CharT *new_state_)
+    {
+        return add (curr_state_, regex_, id_, new_state_, true);
+    }
+
+    void add (const CharT *source_, const basic_rules<CharT> &rules_,
+        const CharT *dest_, const CharT *to_ = detail::strings<CharT>::dot ())
+    {
+        const bool star_ = *source_ == '*' && *(source_ + 1) == 0;
+        const bool dest_dot_ = *dest_ == '.' && *(dest_ + 1) == 0;
+        const bool to_dot_ = *to_ == '.' && *(to_ + 1) == 0;
+        std::size_t state_ = 0;
+        const string_deque_deque &all_regexes_ = rules_.regexes ();
+        const id_vector_deque &all_ids_ = rules_.ids ();
+        const id_vector_deque &all_unique_ids_ = rules_.unique_ids ();
+        const id_vector_deque &all_states_ = rules_.states ();
+        typename string_deque::const_iterator regex_iter_;
+        typename string_deque::const_iterator regex_end_;
+        typename id_vector::const_iterator id_iter_;
+        typename id_vector::const_iterator uid_iter_;
+        typename id_vector::const_iterator state_iter_;
+
+        if (star_)
+        {
+            typename string_deque_deque::const_iterator all_regexes_iter_ =
+                all_regexes_.begin ();
+            typename string_deque_deque::const_iterator all_regexes_end_ =
+                all_regexes_.end ();
+            typename id_vector_deque::const_iterator all_ids_iter_ =
+                all_ids_.begin ();
+            typename id_vector_deque::const_iterator all_uids_iter_ =
+                all_unique_ids_.begin ();
+            typename id_vector_deque::const_iterator all_states_iter_ =
+                all_states_.begin ();
+
+            for (; all_regexes_iter_ != all_regexes_end_;
+                ++state_, ++all_regexes_iter_, ++all_ids_iter_,
+                ++all_uids_iter_, ++all_states_iter_)
+            {
+                regex_iter_ = all_regexes_iter_->begin ();
+                regex_end_ = all_regexes_iter_->end ();
+                id_iter_ = all_ids_iter_->begin ();
+                uid_iter_ = all_uids_iter_->begin ();
+                state_iter_ = all_states_iter_->begin ();
+
+                for (; regex_iter_ != regex_end_; ++regex_iter_, ++id_iter_,
+                    ++uid_iter_, ++state_iter_)
+                {
+                    // If ..._dot_ then lookup state name from rules_; otherwise
+                    // pass name through.
+                    add (dest_dot_ ? rules_.state (state_) : dest_, *regex_iter_,
+                        *id_iter_, to_dot_ ? rules_.state (*state_iter_) : to_, true,
+                        *uid_iter_);
+                }
+            }
+        }
+        else
+        {
+            const CharT *start_ = source_;
+            string state_name_;
+
+            while (*source_)
+            {
+                while (*source_ && *source_ != ',')
+                {
+                    ++source_;
+                }
+
+                state_name_.assign (start_, source_);
+
+                if (*source_)
+                {
+                    ++source_;
+                    start_ = source_;
+                }
+
+                state_ = rules_.state (state_name_.c_str ());
+
+                if (state_ == npos)
+                {
+                    std::basic_stringstream<CharT> ss_;
+                    std::ostringstream os_;
+
+                    os_ << "Unknown state name '";
+                    source_ = state_name_.c_str ();
+
+                    while (*source_)
+                    {
+                        os_ << ss_.narrow (*source_++, ' ');
+                    }
+
+                    os_ << "'.";
+                    throw runtime_error (os_.str ());
+                }
+
+                regex_iter_ = all_regexes_[state_].begin ();
+                regex_end_ = all_regexes_[state_].end ();
+                id_iter_ = all_ids_[state_].begin ();
+                uid_iter_ = all_unique_ids_[state_].begin ();
+                state_iter_ = all_states_[state_].begin ();
+
+                for (; regex_iter_ != regex_end_; ++regex_iter_, ++id_iter_,
+                    ++uid_iter_, ++state_iter_)
+                {
+                    // If ..._dot_ then lookup state name from rules_; otherwise
+                    // pass name through.
+                    add (dest_dot_ ? state_name_.c_str () : dest_, *regex_iter_,
+                        *id_iter_, to_dot_ ? rules_.state (*state_iter_) : to_, true,
+                        *uid_iter_);
+                }
+            }
+        }
+    }
+/*
+    void add (const CharT *curr_state_, const basic_rules<CharT> &rules_)
+    {
+        const string_deque_deque &regexes_ = rules_.regexes ();
+        const id_vector_deque &ids_ = rules_.ids ();
+        const id_vector_deque &unique_ids_ = rules_.unique_ids ();
+        typename string_deque_deque::const_iterator state_regex_iter_ =
+            regexes_.begin ();
+        typename string_deque_deque::const_iterator state_regex_end_ =
+            regexes_.end ();
+        typename id_vector_deque::const_iterator state_id_iter_ =
+            ids_.begin ();
+        typename id_vector_deque::const_iterator state_uid_iter_ =
+            unique_ids_.begin ();
+        typename string_deque::const_iterator regex_iter_;
+        typename string_deque::const_iterator regex_end_;
+        typename id_vector::const_iterator id_iter_;
+        typename id_vector::const_iterator uid_iter_;
+
+        for (; state_regex_iter_ != state_regex_end_; ++state_regex_iter_)
+        {
+            regex_iter_ = state_regex_iter_->begin ();
+            regex_end_ = state_regex_iter_->end ();
+            id_iter_ = state_id_iter_->begin ();
+            uid_iter_ = state_uid_iter_->begin ();
+
+            for (; regex_iter_ != regex_end_; ++regex_iter_, ++id_iter_,
+                ++uid_iter_)
+            {
+                add (curr_state_, *regex_iter_, *id_iter_, curr_state_, true,
+                    *uid_iter_);
+            }
+        }
+    }
+*/
+    const string_size_t_map &statemap () const
+    {
+        return _statemap;
+    }
+
+    const string_pair_deque &macrodeque () const
+    {
+        return _macrodeque;
+    }
+
+    const string_deque_deque &regexes () const
+    {
+        return _regexes;
+    }
+
+    const id_vector_deque &ids () const
+    {
+        return _ids;
+    }
+
+    const id_vector_deque &unique_ids () const
+    {
+        return _unique_ids;
+    }
+
+    const id_vector_deque &states () const
+    {
+        return _states;
+    }
+
+    bool empty () const
+    {
+        typename string_deque_deque::const_iterator iter_ = _regexes.begin ();
+        typename string_deque_deque::const_iterator end_ = _regexes.end ();
+        bool empty_ = true;
+
+        for (; iter_ != end_; ++iter_)
+        {
+            if (!iter_->empty ())
+            {
+                empty_ = false;
+                break;
+            }
+        }
+
+        return empty_;
+    }
+
+    static const CharT *initial ()
+    {
+        return detail::strings<CharT>::initial ();
+    }
+
+    static const CharT *all_states ()
+    {
+        return detail::strings<CharT>::all_states ();
+    }
+
+    static const CharT *dot ()
+    {
+        return detail::strings<CharT>::dot ();
+    }
+
+private:
+    string_size_t_map _statemap;
+    string_pair_deque _macrodeque;
+    string_set _macroset;
+    string_deque_deque _regexes;
+    id_vector_deque _ids;
+    id_vector_deque _unique_ids;
+    id_vector_deque _states;
+    regex_flags _flags;
+    std::size_t _counter;
+    std::size_t (*_counter_ptr) ();
+    std::locale _locale;
+    string_deque _lexer_state_names;
+
+    std::size_t add (const CharT *curr_state_, const string &regex_,
+        const std::size_t id_, const CharT *new_state_, const bool check_,
+        const std::size_t uid_ = npos)
+    {
+        const bool star_ = *curr_state_ == '*' && *(curr_state_ + 1) == 0;
+        const bool dot_ = *new_state_ == '.' && *(new_state_ + 1) == 0;
+
+        if (check_)
+        {
+            check_for_invalid_id (id_);
+        }
+
+        if (!dot_)
+        {
+            validate (new_state_);
+        }
+
+        std::size_t new_ = string::npos;
+        typename string_size_t_map::const_iterator iter_;
+        typename string_size_t_map::const_iterator end_ = _statemap.end ();
+        id_vector states_;
+
+        if (!dot_)
+        {
+            iter_ = _statemap.find (new_state_);
+
+            if (iter_ == end_)
+            {
+                std::basic_stringstream<CharT> ss_;
+                std::ostringstream os_;
+
+                os_ << "Unknown state name '";
+
+                while (*new_state_)
+                {
+                    os_ << ss_.narrow (*new_state_++, ' ');
+                }
+
+                os_ << "'.";
+                throw runtime_error (os_.str ());
+            }
+
+            new_ = iter_->second;
+        }
+
+        if (star_)
+        {
+            const std::size_t size_ = _statemap.size ();
+
+            for (std::size_t i_ = 0; i_ < size_; ++i_)
+            {
+                states_.push_back (i_);
+            }
+        }
+        else
+        {
+            const CharT *start_ = curr_state_;
+            string state_;
+
+            while (*curr_state_)
+            {
+                while (*curr_state_ && *curr_state_ != ',')
+                {
+                    ++curr_state_;
+                }
+
+                state_.assign (start_, curr_state_);
+
+                if (*curr_state_)
+                {
+                    ++curr_state_;
+                    start_ = curr_state_;
+                }
+
+                validate (state_.c_str ());
+                iter_ = _statemap.find (state_.c_str ());
+
+                if (iter_ == end_)
+                {
+                    std::basic_stringstream<CharT> ss_;
+                    std::ostringstream os_;
+
+                    os_ << "Unknown state name '";
+                    curr_state_ = state_.c_str ();
+
+                    while (*curr_state_)
+                    {
+                        os_ << ss_.narrow (*curr_state_++, ' ');
+                    }
+
+                    os_ << "'.";
+                    throw runtime_error (os_.str ());
+                }
+
+                states_.push_back (iter_->second);
+            }
+        }
+
+        std::size_t first_counter_ = npos;
+
+        for (std::size_t i_ = 0, size_ = states_.size (); i_ < size_; ++i_)
+        {
+            const std::size_t curr_ = states_[i_];
+
+            _regexes[curr_].push_back (regex_);
+            _ids[curr_].push_back (id_);
+
+            if (uid_ == npos)
+            {
+                const std::size_t counter_ = next_unique_id ();
+
+                if (first_counter_ == npos)
+                {
+                    first_counter_ = counter_;
+                }
+
+                _unique_ids[curr_].push_back (counter_);
+            }
+            else
+            {
+                if (first_counter_ == npos)
+                {
+                    first_counter_ = uid_;
+                }
+
+                _unique_ids[curr_].push_back (uid_);
+            }
+
+            _states[curr_].push_back (dot_ ? curr_ : new_);
+        }
+
+        return first_counter_;
+    }
+
+    void validate (const CharT *name_) const
+    {
+        const CharT *start_ = name_;
+
+        if (*name_ != '_' && !(*name_ >= 'A' && *name_ <= 'Z') &&
+            !(*name_ >= 'a' && *name_ <= 'z'))
+        {
+            std::basic_stringstream<CharT> ss_;
+            std::ostringstream os_;
+
+            os_ << "Invalid name '";
+
+            while (*name_)
+            {
+                os_ << ss_.narrow (*name_++, ' ');
+            }
+
+            os_ << "'.";
+            throw runtime_error (os_.str ());
+        }
+        else if (*name_)
+        {
+            ++name_;
+        }
+
+        while (*name_)
+        {
+            if (*name_ != '_' && *name_ != '-' &&
+                !(*name_ >= 'A' && *name_ <= 'Z') &&
+                !(*name_ >= 'a' && *name_ <= 'z') &&
+                !(*name_ >= '0' && *name_ <= '9'))
+            {
+                std::basic_stringstream<CharT> ss_;
+                std::ostringstream os_;
+
+                os_ << "Invalid name '";
+                name_ = start_;
+
+                while (*name_)
+                {
+                    os_ << ss_.narrow (*name_++, ' ');
+                }
+
+                os_ << "'.";
+                throw runtime_error (os_.str ());
+            }
+
+            ++name_;
+        }
+
+        if (name_ - start_ > static_cast<std::ptrdiff_t>(max_macro_len))
+        {
+            std::basic_stringstream<CharT> ss_;
+            std::ostringstream os_;
+
+            os_ << "Name '";
+            name_ = start_;
+
+            while (*name_)
+            {
+                os_ << ss_.narrow (*name_++, ' ');
+            }
+
+            os_ << "' too long.";
+            throw runtime_error (os_.str ());
+        }
+    }
+
+    void check_for_invalid_id (const std::size_t id_) const
+    {
+        switch (id_)
+        {
+        case 0:
+            throw runtime_error ("id 0 is reserved for EOF.");
+        case npos:
+            throw runtime_error ("id npos is reserved for the "
+                "UNKNOWN token.");
+        default:
+            // OK
+            break;
+        }
+    }
+};
+
+typedef basic_rules<char> rules;
+typedef basic_rules<wchar_t> wrules;
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/runtime_error.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/runtime_error.hpp
new file mode 100644
index 0000000..2ab716a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/runtime_error.hpp
@@ -0,0 +1,26 @@
+// runtime_error.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_RUNTIME_ERROR_HPP
+#define BOOST_LEXER_RUNTIME_ERROR_HPP
+
+#include <stdexcept>
+
+namespace boost
+{
+namespace lexer
+{
+class runtime_error : public std::runtime_error
+{
+public:
+    runtime_error (const std::string &what_arg_) :
+        std::runtime_error (what_arg_)
+    {
+    }
+};
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp
new file mode 100644
index 0000000..349aa6d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp
@@ -0,0 +1,21 @@
+// size_t.h
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_SIZE_T_H
+#define BOOST_LEXER_SIZE_T_H
+
+#include <stddef.h> // ptrdiff_t
+
+#if defined _MSC_VER && _MSC_VER <= 1200
+namespace std
+{
+    using ::ptrdiff_t;
+    using ::size_t;
+}
+#else
+#include <string>
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp
new file mode 100644
index 0000000..e09e991
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp
@@ -0,0 +1,439 @@
+// state_machine.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_STATE_MACHINE_HPP
+#define BOOST_LEXER_STATE_MACHINE_HPP
+
+#include <algorithm>
+#include "conversion/char_state_machine.hpp"
+#include "consts.hpp"
+#include <deque>
+#include "internals.hpp"
+#include <map>
+#include "containers/ptr_vector.hpp"
+#include "size_t.hpp"
+#include <string>
+
+namespace boost
+{
+namespace lexer
+{
+template<typename CharT>
+class basic_state_machine
+{
+public:
+    typedef CharT char_type;
+
+    class iterator
+    {
+    public:
+#if defined _MSC_VER && _MSC_VER <= 1200
+        friend basic_state_machine;
+#else
+        friend class basic_state_machine;
+#endif
+
+        struct data
+        {
+            // Current iterator info
+            std::size_t dfa;
+            std::size_t states;
+            std::size_t state;
+            std::size_t transitions;
+            std::size_t transition;
+
+            // Current state info
+            bool end_state;
+            std::size_t id;
+            std::size_t unique_id;
+            std::size_t goto_dfa;
+            std::size_t bol_index;
+            std::size_t eol_index;
+
+            // Current transition info
+            basic_string_token<CharT> token;
+            std::size_t goto_state;
+
+            data () :
+                dfa (npos),
+                states (0),
+                state (npos),
+                transitions (0),
+                transition (npos),
+                end_state (false),
+                id (npos),
+                unique_id (npos),
+                goto_dfa (npos),
+                bol_index (npos),
+                eol_index (npos),
+                goto_state (npos)
+            {
+            }
+
+            bool operator == (const data &rhs_) const
+            {
+                return dfa == rhs_.dfa &&
+                    states == rhs_.states &&
+                    state == rhs_.state &&
+                    transitions == rhs_.transitions &&
+                    transition == rhs_.transition &&
+                    end_state == rhs_.end_state &&
+                    id == rhs_.id &&
+                    unique_id == rhs_.unique_id &&
+                    goto_dfa == rhs_.goto_dfa &&
+                    bol_index == rhs_.bol_index &&
+                    eol_index == rhs_.eol_index &&
+                    token == rhs_.token &&
+                    transition == rhs_.transition;
+            }
+        };
+
+        iterator () :
+            _sm (0),
+            _dfas (0),
+            _dfa (npos),
+            _states (0),
+            _state (npos),
+            _transitions (0),
+            _transition (npos)
+        {
+        }
+
+        bool operator == (const iterator &rhs_) const
+        {
+            return _dfas == rhs_._dfas && _dfa == rhs_._dfa &&
+                _states == rhs_._states && _state == rhs_._state &&
+                _transitions == rhs_._transitions &&
+                _transition == rhs_._transition;
+        }
+
+        bool operator != (const iterator &rhs_) const
+        {
+            return !(*this == rhs_);
+        }
+
+        data &operator * ()
+        {
+            return _data;
+        }
+
+        data *operator -> ()
+        {
+            return &_data;
+        }
+
+        // Let compiler generate operator = ().
+
+        // prefix version
+        iterator &operator ++ ()
+        {
+            next ();
+            return *this;
+        }
+
+        // postfix version
+        iterator operator ++ (int)
+        {
+            iterator iter_ = *this;
+
+            next ();
+            return iter_;
+        }
+
+        void clear ()
+        {
+            _dfas = _states = _transitions = 0;
+            _dfa = _state = _transition = npos;
+        }
+
+    private:
+        basic_state_machine *_sm;
+        data _data;
+        std::size_t _dfas;
+        std::size_t _dfa;
+        std::size_t _states;
+        std::size_t _state;
+        std::size_t _transitions;
+        std::size_t _transition;
+        typename detail::basic_char_state_machine<CharT>::state::
+            size_t_string_token_map::const_iterator _token_iter;
+        typename detail::basic_char_state_machine<CharT>::state::
+            size_t_string_token_map::const_iterator _token_end;
+
+        void next ()
+        {
+            bool reset_state_ = false;
+
+            if (_transition >= _transitions)
+            {
+                _transition = _data.transition = 0;
+                _data.state = ++_state;
+                reset_state_ = true;
+
+                if (_state >= _states)
+                {
+                    ++_dfa;
+
+                    if (_dfa >= _dfas)
+                    {
+                        clear ();
+                        reset_state_ = false;
+                    }
+                    else
+                    {
+                        _states = _data.states =
+                            _sm->_csm._sm_vector[_dfa].size ();
+                        _state = _data.state = 0;
+                    }
+                }
+            }
+            else
+            {
+                _data.transition = _transition;
+            }
+
+            if (reset_state_)
+            {
+                const typename detail::basic_char_state_machine<CharT>::
+                    state *ptr_ = &_sm->_csm._sm_vector[_dfa][_state];
+
+                _transitions = _data.transitions = ptr_->_transitions.size ();
+                _data.end_state = ptr_->_end_state;
+                _data.id = ptr_->_id;
+                _data.unique_id = ptr_->_unique_id;
+                _data.goto_dfa = ptr_->_state;
+                _data.bol_index = ptr_->_bol_index;
+                _data.eol_index = ptr_->_eol_index;
+                _token_iter = ptr_->_transitions.begin ();
+                _token_end = ptr_->_transitions.end ();
+            }
+
+            if (_token_iter != _token_end)
+            {
+                _data.token = _token_iter->second;
+                _data.goto_state = _token_iter->first;
+                ++_token_iter;
+                ++_transition;
+            }
+            else
+            {
+                _data.token.clear ();
+                _data.goto_state = npos;
+            }
+        }
+    };
+
+#if defined _MSC_VER && _MSC_VER <= 1200
+    friend iterator;
+#else
+    friend class iterator;
+#endif
+
+    basic_state_machine ()
+    {
+    }
+
+    void clear ()
+    {
+        _internals.clear ();
+        _csm.clear ();
+    }
+
+    bool empty () const
+    {
+        // Don't include _csm in this test, as irrelevant to state.
+        return _internals._lookup->empty () &&
+            _internals._dfa_alphabet.empty () &&
+            _internals._dfa->empty ();
+    }
+
+    std::size_t size () const
+    {
+        return _internals._dfa->size ();
+    }
+
+    bool operator == (const basic_state_machine &rhs_) const
+    {
+        // Don't include _csm in this test, as irrelevant to state.
+        return _internals._lookup == rhs_._internals._lookup &&
+            _internals._dfa_alphabet == rhs_._internals._dfa_alphabet &&
+            _internals._dfa == rhs_._internals._dfa &&
+            _internals._seen_BOL_assertion ==
+                rhs_._internals._seen_BOL_assertion &&
+            _internals._seen_EOL_assertion ==
+                rhs_._internals._seen_EOL_assertion;
+    }
+
+    iterator begin () const
+    {
+        iterator iter_;
+
+        iter_._sm = const_cast<basic_state_machine *>(this);
+        check_for_csm ();
+
+        if (!_csm.empty ())
+        {
+            const typename detail::basic_char_state_machine<CharT>::
+                state_vector *ptr_ = &_csm._sm_vector.front ();
+
+            iter_._dfas = _csm._sm_vector.size ();
+            iter_._states = iter_._data.states = ptr_->size ();
+            iter_._transitions = iter_._data.transitions =
+                ptr_->front ()._transitions.size ();
+            iter_._dfa = iter_._data.dfa = 0;
+            iter_._state = iter_._data.state = 0;
+            iter_._transition = 0;
+            iter_._data.end_state = ptr_->front ()._end_state;
+            iter_._data.id = ptr_->front ()._id;
+            iter_._data.unique_id = ptr_->front ()._unique_id;
+            iter_._data.goto_dfa = ptr_->front ()._state;
+            iter_._data.bol_index = ptr_->front ()._bol_index;
+            iter_._data.eol_index = ptr_->front ()._eol_index;
+            iter_._token_iter = ptr_->front ()._transitions.begin ();
+            iter_._token_end = ptr_->front ()._transitions.end ();
+
+            // Deal with case where there is only a bol or eol
+            // but no other transitions.
+            if (iter_._transitions)
+            {
+                ++iter_;
+            }
+        }
+
+        return iter_;
+    }
+
+    iterator end () const
+    {
+        iterator iter_;
+
+        iter_._sm = const_cast<basic_state_machine *>(this);
+        return iter_;
+    }
+
+    void swap (basic_state_machine &sm_)
+    {
+        _internals.swap (sm_._internals);
+        _csm.swap (sm_._csm);
+    }
+
+    const detail::internals &data () const
+    {
+        return _internals;
+    }
+
+private:
+    detail::internals _internals;
+    mutable detail::basic_char_state_machine<CharT> _csm;
+
+    void check_for_csm () const
+    {
+        if (_csm.empty ())
+        {
+            human_readable (_csm);
+        }
+    }
+
+    void human_readable (detail::basic_char_state_machine<CharT> &sm_) const
+    {
+        const std::size_t max_ = sizeof (CharT) == 1 ?
+            num_chars : num_wchar_ts;
+        const std::size_t start_states_ = _internals._dfa->size ();
+
+        sm_.clear ();
+        sm_._sm_vector.resize (start_states_);
+
+        for (std::size_t start_state_index_ = 0;
+            start_state_index_ < start_states_; ++start_state_index_)
+        {
+            const detail::internals::size_t_vector *lu_ =
+                _internals._lookup[start_state_index_];
+            const std::size_t alphabet_ =
+                _internals._dfa_alphabet[start_state_index_] - dfa_offset;
+            std::vector<std::basic_string<CharT> > chars_ (alphabet_);
+            const std::size_t states_ = _internals._dfa[start_state_index_]->
+                size () / (alphabet_ + dfa_offset);
+            const std::size_t *read_ptr_ = &_internals.
+                _dfa[start_state_index_]->front () + alphabet_ + dfa_offset;
+
+            sm_._sm_vector[start_state_index_].resize (states_ - 1);
+
+            for (std::size_t alpha_index_ = 0; alpha_index_ < max_;
+                ++alpha_index_)
+            {
+                const std::size_t col_ = lu_->at (alpha_index_);
+
+                if (col_ != dead_state_index)
+                {
+                    chars_[col_ - dfa_offset] += static_cast<CharT>
+                        (alpha_index_);
+                }
+            }
+
+            for (std::size_t state_index_ = 1; state_index_ < states_;
+                ++state_index_)
+            {
+                typename detail::basic_char_state_machine<CharT>::state
+                    *state_ = &sm_._sm_vector[start_state_index_]
+                    [state_index_ - 1];
+
+                state_->_end_state = *read_ptr_ != 0;
+                state_->_id = *(read_ptr_ + id_index);
+                state_->_unique_id = *(read_ptr_ + unique_id_index);
+                state_->_state = *(read_ptr_ + state_index);
+                state_->_bol_index = *(read_ptr_ + bol_index) - 1;
+                state_->_eol_index = *(read_ptr_ + eol_index) - 1;
+                read_ptr_ += dfa_offset;
+
+                for (std::size_t col_index_ = 0; col_index_ < alphabet_;
+                    ++col_index_, ++read_ptr_)
+                {
+                    const std::size_t transition_ = *read_ptr_;
+
+                    if (transition_ != 0)
+                    {
+                        const std::size_t i_ = transition_ - 1;
+                        typename detail::basic_char_state_machine<CharT>::
+                            state::size_t_string_token_map::iterator iter_ =
+                            state_->_transitions.find (i_);
+
+                        if (iter_ == state_->_transitions.end ())
+                        {
+                            basic_string_token<CharT> token_
+                                (false, chars_[col_index_]);
+                            typename detail::basic_char_state_machine<CharT>::
+                                state::size_t_string_token_pair pair_
+                                (i_, token_);
+
+                            state_->_transitions.insert (pair_);
+                        }
+                        else
+                        {
+                            iter_->second._charset += chars_[col_index_];
+                        }
+                    }
+                }
+
+                for (typename detail::basic_char_state_machine<CharT>::state::
+                    size_t_string_token_map::iterator iter_ =
+                    state_->_transitions.begin (),
+                    end_ = state_->_transitions.end ();
+                    iter_ != end_; ++iter_)
+                {
+                    std::sort (iter_->second._charset.begin (),
+                        iter_->second._charset.end ());
+                    iter_->second.normalise ();
+                }
+            }
+        }
+    }
+};
+
+typedef basic_state_machine<char> state_machine;
+typedef basic_state_machine<wchar_t> wstate_machine;
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp
new file mode 100644
index 0000000..6bfa6ff
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp
@@ -0,0 +1,413 @@
+// string_token.hpp
+// Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_LEXER_STRING_TOKEN_HPP
+#define BOOST_LEXER_STRING_TOKEN_HPP
+
+#include <algorithm>
+#include "size_t.hpp"
+#include "consts.hpp" // num_chars, num_wchar_ts
+#include <string>
+
+namespace boost
+{
+namespace lexer
+{
+template<typename CharT>
+struct basic_string_token
+{
+    typedef std::basic_string<CharT> string;
+
+    bool _negated;
+    string _charset;
+
+    basic_string_token () :
+        _negated (false)
+    {
+    }
+
+    basic_string_token (const bool negated_, const string &charset_) :
+        _negated (negated_),
+        _charset (charset_)
+    {
+    }
+
+    void remove_duplicates ()
+    {
+        const CharT *start_ = _charset.c_str ();
+        const CharT *end_ = start_ + _charset.size ();
+
+        // Optimisation for very large charsets:
+        // sorting via pointers is much quicker than
+        // via iterators...
+        std::sort (const_cast<CharT *> (start_), const_cast<CharT *> (end_));
+        _charset.erase (std::unique (_charset.begin (), _charset.end ()),
+            _charset.end ());
+    }
+
+    void normalise ()
+    {
+        const std::size_t max_chars_ = sizeof (CharT) == 1 ?
+            num_chars : num_wchar_ts;
+
+        if (_charset.length () == max_chars_)
+        {
+            _negated = !_negated;
+#if defined _MSC_VER && _MSC_VER <= 1200
+            _charset.erase ();
+#else
+            _charset.clear ();
+#endif
+        }
+        else if (_charset.length () > max_chars_ / 2)
+        {
+            negate ();
+        }
+    }
+
+    void negate ()
+    {
+        const std::size_t max_chars_ = sizeof (CharT) == 1 ?
+            num_chars : num_wchar_ts;
+        CharT curr_char_ = sizeof (CharT) == 1 ? -128 : 0;
+        string temp_;
+        const CharT *curr_ = _charset.c_str ();
+        const CharT *chars_end_ = curr_ + _charset.size ();
+
+        _negated = !_negated;
+        temp_.resize (max_chars_ - _charset.size ());
+
+        CharT *ptr_ = const_cast<CharT *> (temp_.c_str ());
+        std::size_t i_ = 0;
+
+        while (curr_ < chars_end_)
+        {
+            while (*curr_ > curr_char_)
+            {
+                *ptr_ = curr_char_;
+                ++ptr_;
+                ++curr_char_;
+                ++i_;
+            }
+
+            ++curr_char_;
+            ++curr_;
+            ++i_;
+        }
+
+        for (; i_ < max_chars_; ++i_)
+        {
+            *ptr_ = curr_char_;
+            ++ptr_;
+            ++curr_char_;
+        }
+
+        _charset = temp_;
+    }
+
+    bool operator < (const basic_string_token &rhs_) const
+    {
+        return _negated < rhs_._negated ||
+            (_negated == rhs_._negated && _charset < rhs_._charset);
+    }
+
+    bool empty () const
+    {
+        return _charset.empty () && !_negated;
+    }
+
+    bool any () const
+    {
+        return _charset.empty () && _negated;
+    }
+
+    void clear ()
+    {
+        _negated = false;
+#if defined _MSC_VER && _MSC_VER <= 1200
+            _charset.erase ();
+#else
+            _charset.clear ();
+#endif
+    }
+
+    void intersect (basic_string_token &rhs_, basic_string_token &overlap_)
+    {
+        if ((any () && rhs_.any ()) || (_negated == rhs_._negated &&
+            !any () && !rhs_.any ()))
+        {
+            intersect_same_types (rhs_, overlap_);
+        }
+        else
+        {
+            intersect_diff_types (rhs_, overlap_);
+        }
+    }
+
+    static void escape_char (const CharT ch_, string &out_)
+    {
+        switch (ch_)
+        {
+            case '\0':
+                out_ += '\\';
+                out_ += '0';
+                break;
+            case '\a':
+                out_ += '\\';
+                out_ += 'a';
+                break;
+            case '\b':
+                out_ += '\\';
+                out_ += 'b';
+                break;
+            case 27:
+                out_ += '\\';
+                out_ += 'x';
+                out_ += '1';
+                out_ += 'b';
+                break;
+            case '\f':
+                out_ += '\\';
+                out_ += 'f';
+                break;
+            case '\n':
+                out_ += '\\';
+                out_ += 'n';
+                break;
+            case '\r':
+                out_ += '\\';
+                out_ += 'r';
+                break;
+            case '\t':
+                out_ += '\\';
+                out_ += 't';
+                break;
+            case '\v':
+                out_ += '\\';
+                out_ += 'v';
+                break;
+            case '\\':
+                out_ += '\\';
+                out_ += '\\';
+                break;
+            case '"':
+                out_ += '\\';
+                out_ += '"';
+                break;
+            case '\'':
+                out_ += '\\';
+                out_ += '\'';
+                break;
+            default:
+            {
+                if (ch_ < 32 && ch_ >= 0)
+                {
+                    std::basic_stringstream<CharT> ss_;
+
+                    out_ += '\\';
+                    out_ += 'x';
+                    ss_ << std::hex <<
+                        static_cast<std::size_t> (ch_);
+                    out_ += ss_.str ();
+                }
+                else
+                {
+                    out_ += ch_;
+                }
+
+                break;
+            }
+        }
+    }
+
+private:
+    void intersect_same_types (basic_string_token &rhs_,
+        basic_string_token &overlap_)
+    {
+        if (any ())
+        {
+            clear ();
+            overlap_._negated = true;
+            rhs_.clear ();
+        }
+        else
+        {
+            typename string::iterator iter_ = _charset.begin ();
+            typename string::iterator end_ = _charset.end ();
+            typename string::iterator rhs_iter_ = rhs_._charset.begin ();
+            typename string::iterator rhs_end_ = rhs_._charset.end ();
+
+            overlap_._negated = _negated;
+
+            while (iter_ != end_ && rhs_iter_ != rhs_end_)
+            {
+                if (*iter_ < *rhs_iter_)
+                {
+                    ++iter_;
+                }
+                else if (*iter_ > *rhs_iter_)
+                {
+                    ++rhs_iter_;
+                }
+                else
+                {
+                    overlap_._charset += *iter_;
+                    iter_ = _charset.erase (iter_);
+                    end_ = _charset.end ();
+                    rhs_iter_ = rhs_._charset.erase (rhs_iter_);
+                    rhs_end_ = rhs_._charset.end ();
+                }
+            }
+
+            if (_negated)
+            {
+                // duplicates already merged, so safe to merge
+                // using std lib.
+
+                // src, dest
+                merge (_charset, overlap_._charset);
+                // duplicates already merged, so safe to merge
+                // using std lib.
+
+                // src, dest
+                merge (rhs_._charset, overlap_._charset);
+                _negated = false;
+                rhs_._negated = false;
+                std::swap (_charset, rhs_._charset);
+                normalise ();
+                overlap_.normalise ();
+                rhs_.normalise ();
+            }
+            else if (!overlap_._charset.empty ())
+            {
+                normalise ();
+                overlap_.normalise ();
+                rhs_.normalise ();
+            }
+        }
+    }
+
+    void intersect_diff_types (basic_string_token &rhs_,
+        basic_string_token &overlap_)
+    {
+        if (any ())
+        {
+            intersect_any (rhs_, overlap_);
+        }
+        else if (_negated)
+        {
+            intersect_negated (rhs_, overlap_);
+        }
+        else // _negated == false
+        {
+            intersect_charset (rhs_, overlap_);
+        }
+    }
+
+    void intersect_any (basic_string_token &rhs_, basic_string_token &overlap_)
+    {
+        if (rhs_._negated)
+        {
+            rhs_.intersect_negated (*this, overlap_);
+        }
+        else // rhs._negated == false
+        {
+            rhs_.intersect_charset (*this, overlap_);
+        }
+    }
+
+    void intersect_negated (basic_string_token &rhs_,
+        basic_string_token &overlap_)
+    {
+        if (rhs_.any ())
+        {
+            overlap_._negated = true;
+            overlap_._charset = _charset;
+            rhs_._negated = false;
+            rhs_._charset = _charset;
+            clear ();
+        }
+        else // rhs._negated == false
+        {
+            rhs_.intersect_charset (*this, overlap_);
+        }
+    }
+
+    void intersect_charset (basic_string_token &rhs_,
+        basic_string_token &overlap_)
+    {
+        if (rhs_.any ())
+        {
+            overlap_._charset = _charset;
+            rhs_._negated = true;
+            rhs_._charset = _charset;
+            clear ();
+        }
+        else // rhs_._negated == true
+        {
+            typename string::iterator iter_ = _charset.begin ();
+            typename string::iterator end_ = _charset.end ();
+            typename string::iterator rhs_iter_ = rhs_._charset.begin ();
+            typename string::iterator rhs_end_ = rhs_._charset.end ();
+
+            while (iter_ != end_ && rhs_iter_ != rhs_end_)
+            {
+                if (*iter_ < *rhs_iter_)
+                {
+                    overlap_._charset += *iter_;
+                    rhs_iter_ = rhs_._charset.insert (rhs_iter_, *iter_);
+                    ++rhs_iter_;
+                    rhs_end_ = rhs_._charset.end ();
+                    iter_ = _charset.erase (iter_);
+                    end_ = _charset.end ();
+                }
+                else if (*iter_ > *rhs_iter_)
+                {
+                    ++rhs_iter_;
+                }
+                else
+                {
+                    ++iter_;
+                    ++rhs_iter_;
+                }
+            }
+
+            if (iter_ != end_)
+            {
+                // nothing bigger in rhs_ than iter_,
+                // so safe to merge using std lib.
+                string temp_ (iter_, end_);
+
+                // src, dest
+                merge (temp_, overlap_._charset);
+                _charset.erase (iter_, end_);
+            }
+
+            if (!overlap_._charset.empty ())
+            {
+                merge (overlap_._charset, rhs_._charset);
+                // possible duplicates, so check for any and erase.
+                rhs_._charset.erase (std::unique (rhs_._charset.begin (),
+                    rhs_._charset.end ()), rhs_._charset.end ());
+                normalise ();
+                overlap_.normalise ();
+                rhs_.normalise ();
+            }
+        }
+    }
+
+    void merge (string &src_, string &dest_)
+    {
+        string tmp_ (src_.size () + dest_.size (), 0);
+
+        std::merge (src_.begin (), src_.end (), dest_.begin (), dest_.end (),
+            tmp_.begin ());
+        dest_ = tmp_;
+    }
+};
+}
+}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp
new file mode 100644
index 0000000..cbbb73b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp
@@ -0,0 +1,86 @@
+/*=============================================================================
+  Copyright (c) 2001-2011 Joel de Guzman
+  http://spirit.sourceforge.net/
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_MAKE_CONS_OCTOBER_16_2008_1252PM
+#define BOOST_SPIRIT_MAKE_CONS_OCTOBER_16_2008_1252PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_limits.hpp>      // needs to be included before proto
+#include <boost/proto/proto.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/fusion/include/cons.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename T>
+    struct as_meta_element
+      : mpl::eval_if_c<is_abstract<T>::value || is_function<T>::value
+          , add_reference<T>, remove_const<T> >
+    {};
+
+    template <typename T>
+    struct as_meta_element<T&> : as_meta_element<T>   // always store by value
+    {};
+
+    template <typename T, int N>
+    struct as_meta_element<T[N]>
+    {
+        typedef const T(&type)[N];
+    };
+
+    namespace result_of
+    {
+        template <typename Car, typename Cdr = fusion::nil>
+        struct make_cons
+        {
+            typedef typename as_meta_element<Car>::type car_type;
+            typedef typename fusion::cons<car_type, Cdr> type;
+        };
+    }
+
+    template <typename Car, typename Cdr>
+    fusion::cons<typename as_meta_element<Car>::type, Cdr>
+    make_cons(Car const& car, Cdr const& cdr)
+    {
+        typedef typename as_meta_element<Car>::type car_type;
+        typedef typename fusion::cons<car_type, Cdr> result;
+        return result(car, cdr);
+    }
+
+    template <typename Car>
+    fusion::cons<typename as_meta_element<Car>::type>
+    make_cons(Car const& car)
+    {
+        typedef typename as_meta_element<Car>::type car_type;
+        typedef typename fusion::cons<car_type> result;
+        return result(car);
+    }
+
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 0)
+    // workaround for gcc-4.0 bug where illegal function types
+    // can be formed (const is added to function type)
+    // description: http://lists.boost.org/Archives/boost/2009/04/150743.php
+    template <typename Car>
+    fusion::cons<typename as_meta_element<Car>::type>
+    make_cons(Car& car, typename enable_if<is_function<Car> >::type* = 0)
+    {
+        typedef typename as_meta_element<Car>::type car_type;
+        typedef typename fusion::cons<car_type> result;
+        return result(car);
+    }
+#endif
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/make_vector.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_vector.hpp
new file mode 100644
index 0000000..92fb2c9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_vector.hpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/version.hpp>
+
+// This is the same as the one in fusion in Boost 1.41. This is provided
+// for compatibility with Boost 1.40 and below.
+
+#if (BOOST_VERSION > 104000)
+
+#include <boost/fusion/include/make_vector.hpp>
+
+namespace boost { namespace spirit { namespace detail
+{
+    namespace result_of
+    {
+        using fusion::result_of::make_vector;
+    }
+    using fusion::make_vector;
+}}}
+
+#else
+
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(SPIRIT_MAKE_VECTOR_07162005_0243)
+#define SPIRIT_MAKE_VECTOR_07162005_0243
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+}}
+
+namespace boost { namespace spirit { namespace detail
+{
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_VECTOR_SIZE, typename T, fusion::void_)
+          , typename Extra = fusion::void_
+        >
+        struct make_vector;
+
+        template <>
+        struct make_vector<>
+        {
+            typedef fusion::vector0 type;
+        };
+    }
+
+    inline fusion::vector0
+    make_vector()
+    {
+        return fusion::vector0();
+    }
+
+#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
+    typename fusion::detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
+
+#define BOOST_PP_FILENAME_1 <boost/spirit/home/support/detail/make_vector.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_AS_FUSION_ELEMENT
+
+}}}
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+        #define TEXT(z, n, text) , text
+        struct make_vector< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, fusion::void_) >
+        #undef TEXT
+#else
+        struct make_vector<BOOST_PP_ENUM_PARAMS(N, T)>
+#endif
+        {
+            typedef BOOST_PP_CAT(fusion::vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    inline BOOST_PP_CAT(fusion::vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
+    make_vector(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
+    {
+        return BOOST_PP_CAT(fusion::vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
+            BOOST_PP_ENUM_PARAMS(N, _));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+#endif // (BOOST_VERSION > 103800)
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp
new file mode 100644
index 0000000..70979a6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp
@@ -0,0 +1,28 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  http://spirit.sourceforge.net/
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_SPIRIT_SCOPED_ENUM_EMULATION_HPP
+#define BOOST_SPIRIT_SCOPED_ENUM_EMULATION_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/version.hpp>
+#include <boost/config.hpp>
+
+#if BOOST_VERSION >= 104000
+# include <boost/detail/scoped_enum_emulation.hpp>
+#else
+# if !defined(BOOST_NO_SCOPED_ENUMS)
+#  define BOOST_NO_SCOPED_ENUMS
+# endif 
+# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type
+# define BOOST_SCOPED_ENUM_END };
+# define BOOST_SCOPED_ENUM(name) name::enum_type
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/handles_container.hpp b/3rdParty/Boost/src/boost/spirit/home/support/handles_container.hpp
new file mode 100644
index 0000000..876c9a9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/handles_container.hpp
@@ -0,0 +1,55 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_HANDLES_CONTAINER_DEC_18_2010_0920AM)
+#define BOOST_SPIRIT_HANDLES_CONTAINER_DEC_18_2010_0920AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    // Finds out whether a component handles container attributes intrinsically
+    // (or whether container attributes need to be split up separately).
+    template <typename T, typename Attribute, typename Context
+            , typename Iterator, typename Enable>
+    struct handles_container : mpl::false_ {};
+
+    template <typename Subject, typename Attribute, typename Context
+            , typename Iterator>
+    struct unary_handles_container
+      : handles_container<Subject, Attribute, Context, Iterator> {};
+
+    template <typename Left, typename Right, typename Attribute
+            , typename Context, typename Iterator>
+    struct binary_handles_container 
+      : mpl::or_<
+            handles_container<Left, Attribute, Context, Iterator>
+          , handles_container<Right, Attribute, Context, Iterator> > 
+    {};
+
+    template <typename Elements, typename Attribute, typename Context
+            , typename Iterator>
+    struct nary_handles_container
+      : mpl::not_<
+            is_same<
+                typename mpl::find_if<
+                    Elements, handles_container<mpl::_, Attribute
+                                              , Context, Iterator> 
+                >::type
+              , typename mpl::end<Elements>::type> > 
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/has_semantic_action.hpp b/3rdParty/Boost/src/boost/spirit/home/support/has_semantic_action.hpp
new file mode 100644
index 0000000..b4cb4e7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/has_semantic_action.hpp
@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_HAS_SEMANTIC_ACTION_SEP_20_2009_0626PM)
+#define BOOST_SPIRIT_HAS_SEMANTIC_ACTION_SEP_20_2009_0626PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    // finding out, whether a component contains a semantic action
+    template <typename T, typename Enable = void>
+    struct has_semantic_action
+      : mpl::false_ {};
+
+    template <typename Subject>
+    struct unary_has_semantic_action 
+      : has_semantic_action<Subject> {};
+
+    template <typename Left, typename Right>
+    struct binary_has_semantic_action 
+      : mpl::or_<has_semantic_action<Left>, has_semantic_action<Right> > {};
+
+    template <typename Elements>
+    struct nary_has_semantic_action
+      : mpl::not_<
+            is_same<
+                typename mpl::find_if<
+                    Elements, has_semantic_action<mpl::_> 
+                >::type
+              , typename mpl::end<Elements>::type
+            > 
+        > {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/info.hpp b/3rdParty/Boost/src/boost/spirit/home/support/info.hpp
new file mode 100644
index 0000000..ff523ab
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/info.hpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_INFO_NOVEMBER_22_2008_1132AM)
+#define BOOST_SPIRIT_INFO_NOVEMBER_22_2008_1132AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/variant/variant.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/foreach.hpp>
+#include <boost/spirit/home/support/utf8.hpp>
+#include <list>
+#include <iterator>
+#include <utility>
+
+namespace boost { namespace spirit
+{
+    // info provides information about a component. Each component
+    // has a what member function that returns an info object.
+    // strings in the info object are assumed to be encoded as UTF8
+    // for uniformity.
+    struct info
+    {
+        struct nil {};
+
+        typedef
+            boost::variant<
+                nil
+              , utf8_string
+              , recursive_wrapper<info>
+              , recursive_wrapper<std::pair<info, info> >
+              , recursive_wrapper<std::list<info> >
+            >
+        value_type;
+
+        explicit info(utf8_string const& tag)
+          : tag(tag), value(nil()) {}
+
+        template <typename T>
+        info(utf8_string const& tag, T const& value)
+          : tag(tag), value(value) {}
+
+        info(utf8_string const& tag, char value)
+          : tag(tag), value(utf8_string(1, value)) {}
+
+        info(utf8_string const& tag, wchar_t value)
+          : tag(tag), value(to_utf8(value)) {}
+
+        info(utf8_string const& tag, ucs4_char value)
+          : tag(tag), value(to_utf8(value)) {}
+
+        template <typename Char>
+        info(utf8_string const& tag, Char const* str)
+          : tag(tag), value(to_utf8(str)) {}
+
+        template <typename Char, typename Traits, typename Allocator>
+        info(utf8_string const& tag
+              , std::basic_string<Char, Traits, Allocator> const& str)
+          : tag(tag), value(to_utf8(str)) {}
+
+        utf8_string tag;
+        value_type value;
+    };
+
+    template <typename Callback>
+    struct basic_info_walker
+    {
+        typedef void result_type;
+        typedef basic_info_walker<Callback> this_type;
+
+        basic_info_walker(Callback& callback, utf8_string const& tag, int depth)
+          : callback(callback), tag(tag), depth(depth) {}
+
+        void operator()(info::nil) const
+        {
+            callback.element(tag, "", depth);
+        }
+
+        void operator()(utf8_string const& str) const
+        {
+            callback.element(tag, str, depth);
+        }
+
+        void operator()(info const& what) const
+        {
+            boost::apply_visitor(
+                this_type(callback, what.tag, depth+1), what.value);
+        }
+
+        void operator()(std::pair<info, info> const& pair) const
+        {
+            callback.element(tag, "", depth);
+            boost::apply_visitor(
+                this_type(callback, pair.first.tag, depth+1), pair.first.value);
+            boost::apply_visitor(
+                this_type(callback, pair.second.tag, depth+1), pair.second.value);
+        }
+
+        void operator()(std::list<info> const& l) const
+        {
+            callback.element(tag, "", depth);
+            BOOST_FOREACH(info const& what, l)
+            {
+                boost::apply_visitor(
+                    this_type(callback, what.tag, depth+1), what.value);
+            }
+        }
+
+        Callback& callback;
+        utf8_string const& tag;
+        int depth;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        basic_info_walker& operator= (basic_info_walker const&);
+    };
+
+    // bare-bones print support
+    template <typename Out>
+    struct simple_printer
+    {
+        typedef utf8_string string;
+
+        simple_printer(Out& out)
+          : out(out) {}
+
+        void element(string const& tag, string const& value, int /*depth*/) const
+        {
+            if (value == "")
+                out << '<' << tag << '>';
+            else
+                out << '"' << value << '"';
+        }
+
+        Out& out;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        simple_printer& operator= (simple_printer const&);
+    };
+
+    template <typename Out>
+    Out& operator<<(Out& out, info const& what)
+    {
+        simple_printer<Out> pr(out);
+        basic_info_walker<simple_printer<Out> > walker(pr, what.tag, 0);
+        boost::apply_visitor(walker, what.value);
+        return out;
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp
new file mode 100644
index 0000000..9df2d9c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp
@@ -0,0 +1,90 @@
+//  Copyright (c) 2001, Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_BUF_ID_CHECK_POLICY_MAR_16_2007_1108AM)
+#define BOOST_SPIRIT_ITERATOR_BUF_ID_CHECK_POLICY_MAR_16_2007_1108AM
+
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <exception>    // for std::exception
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  class illegal_backtracking
+    //  thrown by buf_id_check CheckingPolicy if an instance of an iterator is
+    //  used after another one has invalidated the queue
+    ///////////////////////////////////////////////////////////////////////////
+    class illegal_backtracking : public std::exception
+    {
+    public:
+        illegal_backtracking() throw() {}
+        ~illegal_backtracking() throw() {}
+
+        char const* what() const throw()
+        { 
+            return "boost::spirit::multi_pass::illegal_backtracking"; 
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  class buf_id_check
+    //  Implementation of the CheckingPolicy used by multi_pass
+    //  This policy is most effective when used together with the std_deque
+    //  StoragePolicy.
+    // 
+    //  If used with the fixed_size_queue StoragePolicy, it will not detect
+    //  iterator dereferences that are out of the range of the queue.
+    ///////////////////////////////////////////////////////////////////////////////
+    struct buf_id_check
+    {
+        ///////////////////////////////////////////////////////////////////////
+        struct unique //: detail::default_checking_policy
+        {
+            unique() : buf_id(0) {}
+            unique(unique const& x) : buf_id(x.buf_id) {}
+
+            void swap(unique& x)
+            {
+                boost::swap(buf_id, x.buf_id);
+            }
+
+            // called to verify that everything is ok.
+            template <typename MultiPass>
+            static void docheck(MultiPass const& mp) 
+            {
+                if (mp.buf_id != mp.shared()->shared_buf_id)
+                    boost::throw_exception(illegal_backtracking());
+            }
+
+            // called from multi_pass::clear_queue, so we can increment the count
+            template <typename MultiPass>
+            static void clear_queue(MultiPass& mp)
+            {
+                ++mp.shared()->shared_buf_id;
+                ++mp.buf_id;
+            }
+
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+
+        protected:
+            unsigned long buf_id;
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        struct shared
+        {
+            shared() : shared_buf_id(0) {}
+            unsigned long shared_buf_id;
+        };
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp
new file mode 100644
index 0000000..cfac882
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp
@@ -0,0 +1,558 @@
+//  Copyright (c) 2001-2012 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_COMBINE_POLICIES_APR_06_2008_0136PM)
+#define BOOST_SPIRIT_ITERATOR_COMBINE_POLICIES_APR_06_2008_0136PM
+
+#include <boost/config.hpp>
+#include <boost/type_traits/is_empty.hpp>
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The purpose of the multi_pass_unique template is to eliminate
+    //  empty policy classes (policies not containing any data items) from the
+    //  multiple inheritance chain. This is necessary since some compilers
+    //  fail to apply the empty base optimization if multiple inheritance is
+    //  involved.
+    //  Additionally this can be used to combine separate policies into one
+    //  single multi_pass_policy as required by the multi_pass template
+    ///////////////////////////////////////////////////////////////////////////
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    // without partial template specialization there is nothing much to do in
+    // terms of empty base optimization anyways...
+    template <typename T, typename Ownership, typename Checking,
+        typename Input, typename Storage>
+    struct multi_pass_unique
+      : Ownership, Checking, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Checking::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+    };
+#else
+    ///////////////////////////////////////////////////////////////////////////
+    // select the correct derived classes based on if a policy is empty
+    template <typename T
+      , typename Ownership, typename Checking, typename Input, typename Storage
+      , bool OwnershipIsEmpty = boost::is_empty<Ownership>::value
+      , bool CheckingIsEmpty = boost::is_empty<Checking>::value
+      , bool InputIsEmpty = boost::is_empty<Input>::value>
+    struct multi_pass_unique;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, false, false>
+      : Ownership, Checking, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Checking::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, false, true>
+      : Ownership, Checking, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Checking::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // implement input policy functions by forwarding to the Input type
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, true, false>
+      : Ownership, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // checking policy functions are forwarded to the Checking type
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, true, true>
+      : Ownership, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // implement input policy functions by forwarding to the Input type
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+
+        // checking policy functions are forwarded to the Checking type
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, false, false>
+      : Checking, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Checking::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // ownership policy functions are forwarded to the Ownership type
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, false, true>
+      : Checking, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Checking::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // implement input policy functions by forwarding to the Input type
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+
+        // ownership policy functions are forwarded to the Ownership type
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, true, false>
+      : Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // checking policy functions are forwarded to the Checking type
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+
+        // ownership policy functions are forwarded to the Ownership type
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, true, true>
+      : Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+
+        void swap(multi_pass_unique& x)
+        {
+            this->Storage::swap(x);
+        }
+
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+
+        // implement input policy functions by forwarding to the Input type
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+
+        // checking policy functions are forwarded to the Checking type
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+
+        // ownership policy functions are forwarded to the Ownership type
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////
+    // the multi_pass_shared structure is used to combine the shared data items
+    // of all policies into one single structure
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Ownership, typename Checking, typename Input
+      , typename Storage>
+    struct multi_pass_shared : Ownership, Checking, Input, Storage
+    {
+        explicit multi_pass_shared(T& input) : Input(input) {}
+        explicit multi_pass_shared(T const& input) : Input(input) {}
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This is a default implementation of a policy class as required by the
+    //  multi_pass template, combining 4 separate policies into one. Any other
+    //  multi_pass policy class needs to follow the scheme as shown below.
+    template<typename Ownership, typename Checking, typename Input
+      , typename Storage>
+    struct default_policy
+    {
+        typedef Ownership ownership_policy;
+        typedef Checking checking_policy;
+        typedef Input input_policy;
+        typedef Storage storage_policy;
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename T>
+        struct unique : multi_pass_unique<T
+          , typename Ownership::unique, typename Checking::unique
+          , typename Input::BOOST_NESTED_TEMPLATE unique<T>
+          , typename Storage::BOOST_NESTED_TEMPLATE unique<
+                typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type> >
+        {
+            typedef typename Ownership::unique ownership_policy;
+            typedef typename Checking::unique checking_policy;
+            typedef typename Input::BOOST_NESTED_TEMPLATE unique<T>
+                input_policy;
+            typedef typename Storage::BOOST_NESTED_TEMPLATE unique<
+                typename input_policy::value_type> storage_policy;
+
+            typedef multi_pass_unique<T, ownership_policy, checking_policy
+              , input_policy, storage_policy> unique_base_type;
+
+            unique() {}
+            explicit unique(T& input) : unique_base_type(input) {}
+            explicit unique(T const& input) : unique_base_type(input) {}
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename T>
+        struct shared : multi_pass_shared<T
+          , typename Ownership::shared, typename Checking::shared
+          , typename Input::BOOST_NESTED_TEMPLATE shared<T>
+          , typename Storage::BOOST_NESTED_TEMPLATE shared<
+                typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type> >
+        {
+            typedef typename Ownership::shared ownership_policy;
+            typedef typename Checking::shared checking_policy;
+            typedef typename Input::BOOST_NESTED_TEMPLATE shared<T>
+                input_policy;
+            typedef typename Storage::BOOST_NESTED_TEMPLATE shared<
+                typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type>
+            storage_policy;
+
+            typedef multi_pass_shared<T, ownership_policy, checking_policy
+              , input_policy, storage_policy> shared_base_type;
+
+            explicit shared(T& input)
+              : shared_base_type(input), inhibit_clear_queue_(false) {}
+            explicit shared(T const& input)
+              : shared_base_type(input), inhibit_clear_queue_(false) {}
+
+            // This is needed for the correct implementation of expectation
+            // points. Normally expectation points flush any multi_pass
+            // iterator they may act on, but if the corresponding error handler
+            // is of type 'retry' no flushing of the internal buffers should be
+            // executed (even if explicitly requested).
+            bool inhibit_clear_queue_;
+        };
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp
new file mode 100644
index 0000000..088b39a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp
@@ -0,0 +1,132 @@
+//  Copyright (c) 2001 Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_MAR_16_2007_1122AM)
+#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_MAR_16_2007_1122AM
+
+#include <boost/config.hpp>
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/iterator.hpp>
+#include <boost/mpl/bool.hpp>
+#include <iterator>
+#include <algorithm> 
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace detail
+{
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    ///////////////////////////////////////////////////////////////////////////
+    //  Meta-function to generate a std::iterator<> base class for multi_pass. 
+    //  This is used mainly to improve conformance of compilers not supporting 
+    //  PTS and thus relying on inheritance to recognize an iterator.
+    //
+    //  We are using boost::iterator<> because it offers an automatic 
+    //  workaround for broken std::iterator<> implementations.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename InputPolicy>
+    struct iterator_base_creator
+    {
+        typedef typename InputPolicy::BOOST_NESTED_TEMPLATE unique<T> input_type;
+
+        typedef boost::iterator <
+            std::forward_iterator_tag
+          , typename input_type::value_type
+          , typename input_type::difference_type
+          , typename input_type::pointer
+          , typename input_type::reference
+        > type;
+    };
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Default implementations of the different policies to be used with a 
+    //  multi_pass iterator
+    ///////////////////////////////////////////////////////////////////////////
+    struct default_input_policy
+    {
+        default_input_policy() {}
+
+        template <typename Functor>
+        default_input_policy(Functor const&) {}
+
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+
+        void swap(default_input_policy&) {}
+
+        template <typename MultiPass, typename TokenType>
+        static void advance_input(MultiPass& mp);
+
+        template <typename MultiPass>
+        static typename MultiPass::reference get_input(MultiPass& mp);
+
+        template <typename MultiPass>
+        static bool input_at_eof(MultiPass const& mp);
+
+        template <typename MultiPass, typename TokenType>
+        static bool input_is_valid(MultiPass& mp, TokenType& curtok);
+    };
+
+    struct default_ownership_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+
+        void swap(default_ownership_policy&) {}
+
+        template <typename MultiPass>
+        static void clone(MultiPass&) {}
+
+        template <typename MultiPass>
+        static bool release(MultiPass& mp);
+
+        template <typename MultiPass>
+        static bool is_unique(MultiPass const& mp);
+    };
+
+    struct default_storage_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+
+        void swap(default_storage_policy&) {}
+
+        template <typename MultiPass>
+        static typename MultiPass::reference dereference(MultiPass const& mp);
+
+        template <typename MultiPass>
+        static void increment(MultiPass&) {}
+
+        template <typename MultiPass>
+        static void clear_queue(MultiPass&) {}
+
+        template <typename MultiPass>
+        static bool is_eof(MultiPass const& mp);
+
+        template <typename MultiPass>
+        static bool equal_to(MultiPass const& mp, MultiPass const& x);
+
+        template <typename MultiPass>
+        static bool less_than(MultiPass const& mp, MultiPass const& x);
+    };
+
+    struct default_checking_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+
+        void swap(default_checking_policy&) {}
+
+        template <typename MultiPass>
+        static void docheck(MultiPass const&) {}
+
+        template <typename MultiPass>
+        static void clear_queue(MultiPass&) {}
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/no_check_policy.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/no_check_policy.hpp
new file mode 100644
index 0000000..8f4a26d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/no_check_policy.hpp
@@ -0,0 +1,31 @@
+//  Copyright (c) 2001 Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_NO_CHECK_POLICY_MAR_16_2007_1121AM)
+#define BOOST_SPIRIT_ITERATOR_NO_CHECK_POLICY_MAR_16_2007_1121AM
+
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  class no_check
+    //  Implementation of the CheckingPolicy used by multi_pass
+    //  It does not do anything :-)
+    ///////////////////////////////////////////////////////////////////////////
+    struct no_check
+    {
+        ///////////////////////////////////////////////////////////////////////
+        struct unique : public detail::default_checking_policy {};
+
+        ///////////////////////////////////////////////////////////////////////
+        struct shared {};
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp
new file mode 100644
index 0000000..723bbee
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp
@@ -0,0 +1,79 @@
+//  Copyright (c) 2001 Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_REF_COUNTED_POLICY_MAR_16_2007_1108AM)
+#define BOOST_SPIRIT_ITERATOR_REF_COUNTED_POLICY_MAR_16_2007_1108AM
+
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+#if defined(BOOST_HAS_THREADS)
+#include <boost/detail/atomic_count.hpp>
+#endif
+#include <cstdlib>
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  class ref_counted
+    //  Implementation of an OwnershipPolicy used by multi_pass.
+    //
+    //  Implementation modified from RefCounted class from the Loki library by
+    //  Andrei Alexandrescu.
+    ///////////////////////////////////////////////////////////////////////////
+    struct ref_counted
+    {
+        ///////////////////////////////////////////////////////////////////////
+        struct unique // : detail::default_ownership_policy
+        {
+            void swap(unique&) {}
+
+            // clone is called when a copy of the iterator is made, so 
+            // increment the ref-count.
+            template <typename MultiPass>
+            static void clone(MultiPass& mp)
+            {
+                if (0 != mp.shared())
+                    ++mp.shared()->count;
+            }
+
+            // called when a copy is deleted. Decrement the ref-count. Return
+            // value of true indicates that the last copy has been released.
+            template <typename MultiPass>
+            static bool release(MultiPass& mp)
+            {
+                return 0 != mp.shared() && 0 == --mp.shared()->count;
+            }
+
+            // returns true if there is only one iterator in existence.
+            // std_deque StoragePolicy will free it's buffered data if this
+            // returns true.
+            template <typename MultiPass>
+            static bool is_unique(MultiPass const& mp) 
+            {
+                return 0 == mp.shared() || 1 == mp.shared()->count;
+            }
+
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+        };
+
+        ////////////////////////////////////////////////////////////////////////
+        struct shared
+        {
+            shared() : count(1) {}
+
+#if defined(BOOST_HAS_THREADS)
+            boost::detail::atomic_count count;
+#else
+            std::size_t count;
+#endif
+        };
+
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp
new file mode 100644
index 0000000..711ae90
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp
@@ -0,0 +1,201 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_SPLIT_FUNCTOR_INPUT_POLICY_JAN_17_2008_0103PM)
+#define BOOST_SPIRIT_ITERATOR_SPLIT_FUNCTOR_INPUT_POLICY_JAN_17_2008_0103PM
+
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_empty.hpp>
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    namespace split_functor_input_is_valid_test_
+    {
+        template <typename Token>
+        inline bool token_is_valid(Token const&)
+        {
+            return true;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  class split_functor_input
+    //  Implementation of the InputPolicy used by multi_pass
+    //  split_functor_input gets tokens from a functor
+    // 
+    //  This policy should be used when the functor holds two parts of data: a
+    //  unique part (unique for each instance of the iterator) and a shared 
+    //  part (to be shared between the different copies of the same iterator).
+    //  Using this policy allows to merge the shared part of the functor with 
+    //  the shared part of the iterator data, saving one pointer and one 
+    //  allocation per iterator instance.
+    //
+    //  The Functor template parameter of this policy is expected to be a 
+    //  std::pair<unique, shared>, where 'unique' and 'shared' represent the
+    //  respective parts of the functor itself.
+    //
+    //  Note: the unique part of the functor must have a typedef for result_type
+    //        It also must have a static variable of type result_type defined 
+    //        to represent EOF that is called eof.
+    //
+    ///////////////////////////////////////////////////////////////////////////
+    struct split_functor_input
+    {
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Functor
+          , bool FunctorIsEmpty = is_empty<typename Functor::first_type>::value>
+        class unique;
+
+        // the unique part of the functor is empty, do not include the functor 
+        // as a member at all to avoid unnecessary padding bytes to be included 
+        // into the generated structure
+        template <typename Functor>
+        class unique<Functor, true> // : public detail::default_input_policy
+        {
+        protected:
+            typedef typename Functor::first_type functor_type;
+            typedef typename functor_type::result_type result_type;
+
+        public:
+            typedef result_type value_type;
+            typedef std::ptrdiff_t difference_type;
+            typedef std::ptrdiff_t distance_type;
+            typedef result_type const* pointer;
+            typedef result_type const& reference;
+
+        protected:
+            unique() {}
+            explicit unique(Functor const&) {}
+
+        public:
+            void swap(unique&) {}
+
+            // get the next token
+            template <typename MultiPass>
+            static typename MultiPass::reference get_input(MultiPass& mp)
+            {
+                value_type& curtok = mp.shared()->curtok;
+                using namespace split_functor_input_is_valid_test_;
+                if (!token_is_valid(curtok))
+                    functor_type::get_next(mp, curtok);
+                return curtok;
+            }
+
+            template <typename MultiPass>
+            static void advance_input(MultiPass& mp)
+            {
+                functor_type::get_next(mp, mp.shared()->curtok);
+            }
+
+            // test, whether we reached the end of the underlying stream
+            template <typename MultiPass>
+            static bool input_at_eof(MultiPass const& mp) 
+            {
+                return mp.shared()->curtok == functor_type::eof;
+            }
+
+            template <typename MultiPass>
+            static bool input_is_valid(MultiPass const&, value_type const& t) 
+            {
+                using namespace split_functor_input_is_valid_test_;
+                return token_is_valid(t);
+            }
+
+            template <typename MultiPass>
+            static void destroy(MultiPass& mp) 
+            {
+                functor_type::destroy(mp);
+            }
+        };
+
+        // the unique part of the functor is non-empty
+        template <typename Functor>
+        class unique<Functor, false> : public unique<Functor, true>
+        {
+        protected:
+            typedef typename Functor::first_type functor_type;
+            typedef typename functor_type::result_type result_type;
+
+        protected:
+            unique() {}
+            explicit unique(Functor const& x) : ftor(x.first) {}
+
+            void swap(unique& x)
+            {
+                boost::swap(ftor, x.ftor);
+            }
+
+        public:
+            typedef result_type value_type;
+            typedef std::ptrdiff_t difference_type;
+            typedef std::ptrdiff_t distance_type;
+            typedef result_type const* pointer;
+            typedef result_type const& reference;
+
+        public:
+            // get the next token
+            template <typename MultiPass>
+            static typename MultiPass::reference get_input(MultiPass& mp)
+            {
+                value_type& curtok = mp.shared()->curtok;
+                using namespace split_functor_input_is_valid_test_;
+                if (!token_is_valid(curtok))
+                    functor_type::get_next(mp, curtok);
+                return curtok;
+            }
+
+            template <typename MultiPass>
+            static void advance_input(MultiPass& mp)
+            {
+                mp.ftor.get_next(mp, mp.shared()->curtok);
+            }
+
+            template <typename MultiPass>
+            static bool input_is_valid(MultiPass const&, value_type const& t) 
+            {
+                using namespace split_functor_input_is_valid_test_;
+                return token_is_valid(t);
+            }
+
+            // test, whether we reached the end of the underlying stream
+            template <typename MultiPass>
+            static bool input_at_eof(MultiPass const& mp) 
+            {
+                return mp.shared()->curtok == mp.ftor.eof;
+            }
+
+            typename Functor::first_type& get_functor() const
+            {
+                return ftor;
+            }
+
+            mutable functor_type ftor;
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Functor>
+        struct shared
+        {
+        protected:
+            typedef typename Functor::first_type functor_type;
+            typedef typename functor_type::result_type result_type;
+
+        public:
+            explicit shared(Functor const& x) : ftor(x.second), curtok(0) {}
+
+            mutable typename Functor::second_type ftor;
+            result_type curtok;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            shared& operator= (shared const&);
+        };
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp
new file mode 100644
index 0000000..402956b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp
@@ -0,0 +1,170 @@
+//  Copyright (c) 2001 Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_SPLIT_DEQUE_POLICY_APR_06_2008_0138PM)
+#define BOOST_SPIRIT_ITERATOR_SPLIT_DEQUE_POLICY_APR_06_2008_0138PM
+
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+#include <boost/assert.hpp>
+#include <vector>
+
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  class split_std_deque
+    //
+    //  Implementation of the StoragePolicy used by multi_pass
+    //  This stores all data in a std::vector (despite its name), and keeps an 
+    //  offset to the current position. It stores all the data unless there is 
+    //  only one iterator using the queue.
+    // 
+    ///////////////////////////////////////////////////////////////////////////
+    struct split_std_deque
+    {
+        enum { threshold = 16 };
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Value>
+        class unique //: public detail::default_storage_policy
+        {
+        private:
+            typedef std::vector<Value> queue_type;
+
+        protected:
+            unique() : queued_position(0) {}
+
+            unique(unique const& x)
+              : queued_position(x.queued_position) {}
+
+            void swap(unique& x)
+            {
+                boost::swap(queued_position, x.queued_position);
+            }
+
+            // This is called when the iterator is dereferenced.  It's a 
+            // template method so we can recover the type of the multi_pass 
+            // iterator and call advance_input and input_is_valid.
+            template <typename MultiPass>
+            static typename MultiPass::reference 
+            dereference(MultiPass const& mp)
+            {
+                queue_type& queue = mp.shared()->queued_elements;
+                typename queue_type::size_type size = queue.size();
+
+                BOOST_ASSERT(mp.queued_position <= size);
+
+                if (mp.queued_position == size)
+                {
+                    // check if this is the only iterator
+                    if (size >= threshold && MultiPass::is_unique(mp))
+                    {
+                        // free up the memory used by the queue.
+                        queue.clear();
+                        mp.queued_position = 0;
+                    }
+                    return MultiPass::get_input(mp);
+                }
+
+                return queue[mp.queued_position];
+            }
+
+            // This is called when the iterator is incremented. It's a template
+            // method so we can recover the type of the multi_pass iterator
+            // and call is_unique and advance_input.
+            template <typename MultiPass>
+            static void increment(MultiPass& mp)
+            {
+                queue_type& queue = mp.shared()->queued_elements;
+                typename queue_type::size_type size = queue.size();
+
+                BOOST_ASSERT(mp.queued_position <= size);
+
+//                 // do not increment iterator as long as the current token is
+//                 // invalid
+//                 if (size > 0 && !MultiPass::input_is_valid(mp, queue[mp.queued_position-1]))
+//                     return;
+
+                if (mp.queued_position == size)
+                {
+                    // check if this is the only iterator
+                    if (size >= threshold && MultiPass::is_unique(mp))
+                    {
+                        // free up the memory used by the queue. we avoid 
+                        // clearing the queue on every increment, though, 
+                        // because this would be too time consuming
+                        queue.clear();
+                        mp.queued_position = 0;
+                    }
+                    else
+                    {
+                        queue.push_back(MultiPass::get_input(mp));
+                        ++mp.queued_position;
+                    }
+                    MultiPass::advance_input(mp);
+                }
+                else
+                {
+                    ++mp.queued_position;
+                }
+            }
+
+            // called to forcibly clear the queue
+            template <typename MultiPass>
+            static void clear_queue(MultiPass& mp)
+            {
+                mp.shared()->queued_elements.clear();
+                mp.queued_position = 0;
+            }
+
+            // called to determine whether the iterator is an eof iterator
+            template <typename MultiPass>
+            static bool is_eof(MultiPass const& mp)
+            {
+                return mp.queued_position == mp.shared()->queued_elements.size() 
+                    && MultiPass::input_at_eof(mp);
+            }
+
+            // called by operator==
+            template <typename MultiPass>
+            static bool equal_to(MultiPass const& mp, MultiPass const& x) 
+            {
+                return mp.queued_position == x.queued_position;
+            }
+
+            // called by operator<
+            template <typename MultiPass>
+            static bool less_than(MultiPass const& mp, MultiPass const& x)
+            {
+                return mp.queued_position < x.queued_position;
+            }
+
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+
+        protected:
+            mutable typename queue_type::size_type queued_position;
+        }; 
+
+        ///////////////////////////////////////////////////////////////////////
+        template <typename Value>
+        struct shared
+        {
+            shared() 
+            {
+                queued_elements.reserve(threshold); 
+            }
+
+            typedef std::vector<Value> queue_type;
+            queue_type queued_elements;
+        }; 
+
+    }; // split_std_deque
+
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp
new file mode 100644
index 0000000..2b355bf
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp
@@ -0,0 +1,252 @@
+//  Copyright (c) 2001, Daniel C. Nuffer
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  http://spirit.sourceforge.net/
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_MAR_16_2007_1124AM)
+#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_MAR_16_2007_1124AM
+
+#include <boost/config.hpp>
+#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
+#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
+#include <boost/spirit/home/support/iterators/detail/combine_policies.hpp>
+#include <boost/limits.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/utility/base_from_member.hpp>
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // The default multi_pass instantiation uses a ref-counted std_deque scheme.
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Policies>
+    class multi_pass
+      : private boost::base_from_member<
+            typename Policies::BOOST_NESTED_TEMPLATE shared<T>*>
+      , public Policies::BOOST_NESTED_TEMPLATE unique<T>
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+      , typename iterator_base_creator<T, typename Policies::input_policy>::type
+#endif
+    {
+    private:
+        // unique and shared data types
+        typedef typename Policies::BOOST_NESTED_TEMPLATE unique<T>
+            policies_base_type;
+        typedef typename Policies::BOOST_NESTED_TEMPLATE shared<T>
+            shared_data_type;
+
+        typedef boost::base_from_member<shared_data_type*> member_base;
+
+        // define the types the standard embedded iterator typedefs are taken
+        // from
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+        typedef typename iterator_base_creator<Input, T>::type iterator_type;
+#else
+        typedef typename policies_base_type::input_policy iterator_type;
+#endif
+
+    public:
+        // standard iterator typedefs
+        typedef std::forward_iterator_tag iterator_category;
+        typedef typename iterator_type::value_type value_type;
+        typedef typename iterator_type::difference_type difference_type;
+        typedef typename iterator_type::distance_type distance_type;
+        typedef typename iterator_type::reference reference;
+        typedef typename iterator_type::pointer pointer;
+
+        multi_pass() : member_base(static_cast<shared_data_type*>(0)) {}
+
+        explicit multi_pass(T& input)
+          : member_base(new shared_data_type(input)), policies_base_type(input) {}
+
+        explicit multi_pass(T const& input)
+          : member_base(new shared_data_type(input)), policies_base_type(input) {}
+
+        multi_pass(multi_pass const& x)
+          : member_base(x.member), policies_base_type(x)
+        {
+            policies_base_type::clone(*this);
+        }
+
+#if BOOST_WORKAROUND(__GLIBCPP__, == 20020514)
+        // The standard library shipped with gcc-3.1 has a bug in
+        // bits/basic_string.tcc. It tries to use iter::iter(0) to
+        // construct an iterator. Ironically, this  happens in sanity
+        // checking code that isn't required by the standard.
+        // The workaround is to provide an additional constructor that
+        // ignores its int argument and behaves like the default constructor.
+        multi_pass(int) : member_base(static_cast<shared_data_type*>(0)) {}
+#endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514)
+
+        ~multi_pass()
+        {
+            if (policies_base_type::release(*this)) {
+                policies_base_type::destroy(*this);
+                delete this->member;
+            }
+        }
+
+        multi_pass& operator=(multi_pass const& x)
+        {
+            if (this != &x) {
+                multi_pass temp(x);
+                temp.swap(*this);
+            }
+            return *this;
+        }
+
+        void swap(multi_pass& x)
+        {
+            boost::swap(this->member, x.member);
+            this->policies_base_type::swap(x);
+        }
+
+        reference operator*() const
+        {
+            policies_base_type::docheck(*this);
+            return policies_base_type::dereference(*this);
+        }
+        pointer operator->() const
+        {
+            return &(operator*());
+        }
+
+        multi_pass& operator++()
+        {
+            policies_base_type::docheck(*this);
+            policies_base_type::increment(*this);
+            return *this;
+        }
+        multi_pass operator++(int)
+        {
+            multi_pass tmp(*this);
+            ++*this;
+            return tmp;
+        }
+
+        void clear_queue(BOOST_SCOPED_ENUM(traits::clear_mode) mode =
+            traits::clear_mode::clear_if_enabled)
+        {
+            if (mode == traits::clear_mode::clear_always || !inhibit_clear_queue())
+                policies_base_type::clear_queue(*this);
+        }
+        bool inhibit_clear_queue() const
+        {
+            return this->member->inhibit_clear_queue_;
+        }
+        void inhibit_clear_queue(bool flag)
+        {
+            this->member->inhibit_clear_queue_ = flag;
+        }
+
+        bool operator==(multi_pass const& y) const
+        {
+            if (is_eof())
+                return y.is_eof();
+            if (y.is_eof())
+                return false;
+
+            return policies_base_type::equal_to(*this, y);
+        }
+        bool operator<(multi_pass const& y) const
+        {
+            return policies_base_type::less_than(*this, y);
+        }
+
+        bool operator!=(multi_pass const& y)
+        {
+            return !(*this == y);
+        }
+        bool operator>(multi_pass const& y)
+        {
+            return y < *this;
+        }
+        bool operator>=(multi_pass const& y)
+        {
+            return !(*this < y);
+        }
+        bool operator<=(multi_pass const& y)
+        {
+            return !(y < *this);
+        }
+
+        // allow access to base member
+        shared_data_type* shared() const { return this->member; }
+
+    private: // helper functions
+        bool is_eof() const
+        {
+            return (0 == this->member) || policies_base_type::is_eof(*this);
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Generator function
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Policies, typename T>
+    inline multi_pass<T, Policies>
+    make_multi_pass(T& i)
+    {
+        return multi_pass<T, Policies>(i);
+    }
+    template <typename Policies, typename T>
+    inline multi_pass<T, Policies>
+    make_multi_pass(T const& i)
+    {
+        return multi_pass<T, Policies>(i);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    inline multi_pass<T>
+    make_default_multi_pass(T& i)
+    {
+        return multi_pass<T>(i);
+    }
+    template <typename T>
+    inline multi_pass<T>
+    make_default_multi_pass(T const& i)
+    {
+        return multi_pass<T>(i);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Policies>
+    inline void
+    swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y)
+    {
+        x.swap(y);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // define special functions allowing to integrate any multi_pass iterator
+    // with expectation points
+    namespace traits
+    {
+        template <typename T, typename Policies>
+        void clear_queue(multi_pass<T, Policies>& mp
+          , BOOST_SCOPED_ENUM(traits::clear_mode) mode)
+        {
+            mp.clear_queue(mode);
+        }
+
+        template <typename T, typename Policies>
+        void inhibit_clear_queue(multi_pass<T, Policies>& mp, bool flag)
+        {
+            mp.inhibit_clear_queue(flag);
+        }
+
+        template <typename T, typename Policies>
+        bool inhibit_clear_queue(multi_pass<T, Policies>& mp)
+        {
+            return mp.inhibit_clear_queue();
+        }
+    }
+
+}} // namespace boost::spirit
+
+#endif
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass_fwd.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass_fwd.hpp
new file mode 100644
index 0000000..4724d11
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass_fwd.hpp
@@ -0,0 +1,91 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_APR_18_2008_1102AM)
+#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_FWD_APR_18_2008_1102AM
+
+#include <cstddef>
+#include <boost/spirit/home/support/multi_pass_wrapper.hpp>
+#include <boost/swap.hpp>
+
+namespace boost { namespace spirit {
+
+    namespace iterator_policies
+    {
+        // input policies
+        struct input_iterator;
+        struct buffering_input_iterator;
+        struct istream;
+        struct lex_input;
+        struct functor_input;
+        struct split_functor_input;
+
+        // ownership policies
+        struct ref_counted;
+        struct first_owner;
+
+        // checking policies
+        class illegal_backtracking;
+        struct buf_id_check;
+        struct no_check;
+
+        // storage policies
+        struct split_std_deque;
+        template<std::size_t N> struct fixed_size_queue;
+
+        // policy combiner
+#if defined(BOOST_SPIRIT_DEBUG)
+        template<typename Ownership = ref_counted
+          , typename Checking = buf_id_check
+          , typename Input = buffering_input_iterator
+          , typename Storage = split_std_deque>
+        struct default_policy;
+#else
+        template<typename Ownership = ref_counted
+          , typename Checking = no_check
+          , typename Input = buffering_input_iterator
+          , typename Storage = split_std_deque>
+        struct default_policy;
+#endif
+    }
+
+    template <typename T
+      , typename Policies = iterator_policies::default_policy<> >
+    class multi_pass;
+
+    template <typename T, typename Policies>
+    void swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y);
+
+}} // namespace boost::spirit
+
+namespace boost { namespace spirit { namespace traits
+{
+    // declare special functions allowing to integrate any multi_pass iterator
+    // with expectation points
+
+    // multi_pass iterators require special handling (for the non-specialized
+    // versions of these functions see support/multi_pass_wrapper.hpp)
+    template <typename T, typename Policies>
+    void clear_queue(multi_pass<T, Policies>&
+      , BOOST_SCOPED_ENUM(clear_mode) mode = clear_mode::clear_if_enabled);
+
+    template <typename T, typename Policies>
+    void inhibit_clear_queue(multi_pass<T, Policies>&, bool);
+
+    template <typename T, typename Policies>
+    bool inhibit_clear_queue(multi_pass<T, Policies>&);
+
+    // Helper template to recognize a multi_pass iterator. This specialization
+    // will be instantiated for any multi_pass iterator.
+    template <typename T, typename Policies>
+    struct is_multi_pass<multi_pass<T, Policies> > : mpl::true_ {};
+
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp b/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp
new file mode 100644
index 0000000..ff53967
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp
@@ -0,0 +1,35 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_SUPPORT_LIMITS_MAR_26_2011_0833PM)
+#define BOOST_SPIRIT_SUPPORT_LIMITS_MAR_26_2011_0833PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+
+#if !defined(SPIRIT_ARGUMENTS_LIMIT)
+# define SPIRIT_ARGUMENTS_LIMIT PHOENIX_LIMIT
+#endif
+#if !defined(SPIRIT_ATTRIBUTES_LIMIT)
+# define SPIRIT_ATTRIBUTES_LIMIT PHOENIX_LIMIT
+#endif
+
+#else
+
+#if !defined(SPIRIT_ARGUMENTS_LIMIT)
+# define SPIRIT_ARGUMENTS_LIMIT BOOST_PHOENIX_LIMIT
+#endif
+#if !defined(SPIRIT_ATTRIBUTES_LIMIT)
+# define SPIRIT_ATTRIBUTES_LIMIT BOOST_PHOENIX_LIMIT
+#endif
+
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp b/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp
new file mode 100644
index 0000000..04a7437
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp
@@ -0,0 +1,474 @@
+/*=============================================================================
+  Copyright (c) 2001-2011 Joel de Guzman
+  http://spirit.sourceforge.net/
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_MAKE_COMPONENT_OCTOBER_16_2008_1250PM
+#define BOOST_SPIRIT_MAKE_COMPONENT_OCTOBER_16_2008_1250PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/proto/proto.hpp>
+#include <boost/spirit/home/support/detail/make_cons.hpp>
+#include <boost/spirit/home/support/modify.hpp>
+
+namespace boost { namespace spirit
+{
+    // There is no real "component" class. Each domain is responsible
+    // for creating its own components. You need to specialize this for
+    // each component in your domain. Use this as a guide.
+
+    template <typename Domain, typename Tag, typename Enable = void>
+    struct make_component
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>;
+
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const;
+    };
+
+    namespace tag
+    {
+        // Normally, we use proto tags as-is to distinguish operators.
+        // The special case is proto::tag::subscript. Spirit uses this
+        // as either sementic actions or directives. To distinguish between
+        // the two, we use these special tags below.
+
+        struct directive;
+        struct action;
+    }
+
+    template <typename Domain, typename T, typename Enable = void>
+    struct flatten_tree;
+}}
+
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl
+      : proto::transform_impl<Expr, State, Data>
+    {
+        typedef typename
+            proto::result_of::value<Expr>::type 
+        value;
+
+        typedef typename result_of::make_cons<value>::type elements;
+
+        typedef
+            make_component<Domain, proto::tag::terminal>
+        make_component_;
+
+        typedef typename
+            make_component_::template
+                result<make_component_(elements, Data)>::type
+        result_type;
+
+        result_type operator()(
+            typename make_terminal_impl::expr_param expr
+          , typename make_terminal_impl::state_param /*state*/
+          , typename make_terminal_impl::data_param data
+        ) const
+        {
+            return typename make_terminal_impl::make_component_()(
+                detail::make_cons(proto::value(expr))
+              , data
+            );
+        }
+    };
+
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+      : proto::transform_impl<phoenix::actor<Expr>, State, Data>
+    {
+        typedef phoenix::actor<Expr> value;
+        typedef typename result_of::make_cons<value>::type elements;
+        typedef make_component<Domain, proto::tag::terminal> make_component_;
+
+        typedef typename
+            make_component_::template
+                result<make_component_(elements, Data)>::type
+        result_type;
+
+        result_type operator()(
+            typename make_terminal_impl::expr_param expr
+          , typename make_terminal_impl::state_param /*state*/
+          , typename make_terminal_impl::data_param data
+        ) const
+        {
+            return typename make_terminal_impl::make_component_()(
+                detail::make_cons(expr)
+              , data
+            );
+        }
+    };
+
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr> &, State, Data, Domain>
+        : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+    {};
+
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr> const &, State, Data, Domain>
+        : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+    {};
+
+    template <typename Domain>
+    struct make_terminal : proto::transform<make_terminal<Domain> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : make_terminal_impl<Expr, State, Data, Domain> {};
+    };
+
+    template <typename Domain, typename Tag, typename Grammar>
+    struct make_unary : proto::transform<make_unary<Domain, Tag, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::result_of::child_c<Expr, 0>::type
+            child;
+
+            typedef typename Grammar::
+                template result<Grammar(child, State, Data)>::type
+            child_component;
+
+            typedef typename
+                result_of::make_cons<child_component>::type
+            elements;
+
+            typedef make_component<Domain, Tag> make_component_;
+
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements, Data)>::type
+            result_type;
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return typename impl::make_component_()(
+                    detail::make_cons(
+                        Grammar()(proto::child(expr), state, data))
+                  , data
+                );
+            }
+        };
+    };
+
+    // un-flattened version
+    template <typename Domain, typename Tag, typename Grammar,
+        bool flatten = flatten_tree<Domain, Tag>::value>
+    struct make_binary
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 0>::type
+                  , State, Data)>::type
+            lhs_component;
+
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 1>::type
+                  , State, Data)>::type
+            rhs_component;
+
+            typedef typename
+                result_of::make_cons<
+                    lhs_component
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+
+            typedef make_component<Domain, Tag> make_component_;
+
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)       // LHS
+                      , detail::make_cons(
+                            Grammar()(
+                                proto::child_c<1>(expr), state, data)   // RHS
+                        )
+                    );
+
+                return make_component_()(elements, data);
+            }
+        };
+    };
+
+    template <typename Grammar>
+    struct make_binary_helper : proto::transform<make_binary_helper<Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(Expr, State, Data)>::type
+            lhs;
+
+            typedef typename result_of::make_cons<lhs, State>::type result_type;
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return detail::make_cons(Grammar()(expr, state, data), state);
+            }
+        };
+    };
+
+    // Flattened version
+    template <typename Domain, typename Tag, typename Grammar>
+    struct make_binary<Domain, Tag, Grammar, true>
+      : proto::transform<make_binary<Domain, Tag, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::reverse_fold_tree<
+                    proto::_
+                  , proto::make<fusion::nil>
+                  , make_binary_helper<Grammar>
+                >::template impl<Expr, State, Data>
+            reverse_fold_tree;
+
+            typedef typename reverse_fold_tree::result_type elements;
+            typedef make_component<Domain, Tag> make_component_;
+
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements, Data)>::type
+            result_type;
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return make_component_()(
+                    reverse_fold_tree()(expr, state, data), data);
+            }
+        };
+    };
+
+    template <typename Domain, typename Grammar>
+    struct make_directive : proto::transform<make_directive<Domain, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::result_of::child_c<Expr, 0>::type
+            lhs;
+
+            typedef typename
+                proto::result_of::value<lhs>::type
+            tag_type;
+
+            typedef typename modify<Domain>::
+                template result<modify<Domain>(tag_type, Data)>::type
+            modifier_type;
+
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 1>::type
+                  , State
+                  , modifier_type
+                )>::type
+            rhs_component;
+
+            typedef typename
+                result_of::make_cons<
+                    tag_type
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+
+            typedef make_component<Domain, tag::directive> make_component_;
+
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                tag_type tag = proto::value(proto::child_c<0>(expr));
+                typename remove_reference<modifier_type>::type
+                    modifier = modify<Domain>()(tag, data);
+
+                elements_type elements =
+                    detail::make_cons(
+                        tag                                 // LHS
+                      , detail::make_cons(
+                            Grammar()(
+                                proto::child_c<1>(expr)     // RHS
+                              , state, modifier)
+                        )
+                    );
+
+                return make_component_()(elements, data);
+            }
+        };
+    };
+
+    template <typename Domain, typename Grammar>
+    struct make_action : proto::transform<make_action<Domain, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 0>::type
+                  , State
+                  , Data
+                )>::type
+            lhs_component;
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+            typedef typename
+                proto::result_of::value<
+                    typename proto::result_of::child_c<Expr, 1>::type
+                >::type
+            rhs_component;
+#else
+            typedef
+                typename mpl::eval_if_c<
+                    phoenix::is_actor<
+                        typename proto::result_of::child_c<Expr, 1>::type
+                    >::type::value
+                  , proto::result_of::child_c<Expr, 1>
+                  , proto::result_of::value<
+                        typename proto::result_of::child_c<Expr, 1>::type
+                    >
+                >::type
+                rhs_component;
+#endif
+
+            typedef typename
+                result_of::make_cons<
+                    lhs_component
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+
+            typedef make_component<Domain, tag::action> make_component_;
+
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)   // LHS
+                      , detail::make_cons(
+                            proto::value(proto::child_c<1>(expr)))  // RHS
+                    );
+
+                return make_component_()(elements, data);
+            }
+#else
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return
+                    (*this)(
+                        expr
+                      , state
+                      , data
+                      , typename phoenix::is_actor<
+                            typename proto::result_of::child_c<Expr, 1>::type
+                        >::type()
+                    );
+            }
+            
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+              , mpl::false_
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)   // LHS
+                      , detail::make_cons(
+                            proto::value(proto::child_c<1>(expr)))  // RHS
+                    );
+
+                return make_component_()(elements, data);
+            }
+
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+              , mpl::true_
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)   // LHS
+                      , detail::make_cons(
+                            proto::child_c<1>(expr))               // RHS
+                    );
+
+                return make_component_()(elements, data);
+            }
+#endif
+        };
+    };
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/meta_compiler.hpp b/3rdParty/Boost/src/boost/spirit/home/support/meta_compiler.hpp
new file mode 100644
index 0000000..a525ef3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/meta_compiler.hpp
@@ -0,0 +1,320 @@
+/*=============================================================================
+  Copyright (c) 2001-2011 Joel de Guzman
+  http://spirit.sourceforge.net/
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_META_COMPILER_OCTOBER_16_2008_1258PM
+#define BOOST_SPIRIT_META_COMPILER_OCTOBER_16_2008_1258PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/spirit/include/phoenix_limits.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/spirit/include/phoenix_limits.hpp>      // needs to be included before proto
+#include <boost/proto/proto.hpp>
+#include <boost/spirit/home/support/make_component.hpp>
+#include <boost/spirit/home/support/modify.hpp>
+#include <boost/spirit/home/support/detail/make_cons.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/assert_msg.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace spirit
+{
+    // Some defaults...
+
+    template <typename Domain, typename Tag, typename Enable = void>
+    struct use_operator : mpl::false_ {};
+
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_function : mpl::false_ {};
+
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_directive : mpl::false_ {};
+
+    template <typename Domain, typename T, typename Enable /* = void */>
+    struct is_modifier_directive : mpl::false_ {};
+
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_terminal : mpl::false_ {};
+
+    template <typename Domain, typename T, typename Enable /*= void*/>
+    struct flatten_tree : mpl::false_ {};
+
+    // Our meta-compiler. This is the main engine that hooks Spirit
+    // to the proto expression template engine.
+
+    template <typename Domain>
+    struct meta_compiler
+    {
+        struct meta_grammar;
+
+        BOOST_SPIRIT_ASSERT_MSG((
+            !use_operator<Domain, proto::tag::subscript>::value
+        ), error_proto_tag_subscript_cannot_be_used, ());
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+        // this is the non-broken part for compilers properly supporting 
+        // partial template specialization (VC7.1 does not)
+        struct cases
+        {
+            template <typename Tag, typename Enable = void>
+            struct case_
+              : proto::not_<proto::_>
+            {};
+
+            ///////////////////////////////////////////////////////////////////
+            // terminals
+            ///////////////////////////////////////////////////////////////////
+            template <typename Enable>
+            struct case_<proto::tag::terminal, Enable>
+              : proto::when<
+                    proto::if_<use_terminal<Domain, proto::_value>()>,
+                    detail::make_terminal<Domain>
+                >
+            {};
+
+            template <typename Tag>
+            struct case_<Tag, typename enable_if<use_operator<Domain, Tag> >::type>
+              : proto::or_<
+            ///////////////////////////////////////////////////////////////////
+            // binary operators
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<Tag, meta_grammar, meta_grammar>,
+                        detail::make_binary<Domain, Tag, meta_grammar>
+                    >,
+            ///////////////////////////////////////////////////////////////////
+            // unary operators
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::unary_expr<Tag, meta_grammar>,
+                        detail::make_unary<Domain, Tag, meta_grammar>
+                    >
+                >
+            {};
+
+            template <typename Enable>
+            struct case_<proto::tag::subscript, Enable>
+              : proto::or_<
+            ///////////////////////////////////////////////////////////////////
+            // directives
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , proto::and_<
+                            proto::terminal<proto::_>
+                          , proto::if_<use_directive<Domain, proto::_value >()> >
+                      , meta_grammar>,
+                        detail::make_directive<Domain, meta_grammar>
+                    >,
+            ///////////////////////////////////////////////////////////////////
+            // semantic actions
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , meta_grammar, proto::_>,
+                        detail::make_action<Domain, meta_grammar>
+                    >
+                >
+            {};
+        };
+#else
+        // this part actually constitutes invalid C++ code, but it allows us to
+        // convince VC7.1 to do what we want
+        struct cases
+        {
+            template <typename Tag, typename Enable = void>
+            struct case_
+              : proto::not_<proto::_>
+            {};
+
+            ///////////////////////////////////////////////////////////////////
+            // terminals
+            ///////////////////////////////////////////////////////////////////
+            template <>
+            struct case_<proto::tag::terminal>
+              : proto::when<
+                    proto::if_<use_terminal<Domain, proto::_value>()>,
+                    detail::make_terminal<Domain>
+                >
+            {};
+
+            template <typename Tag>
+            struct case_<Tag>
+              : proto::or_<
+            ///////////////////////////////////////////////////////////////////
+            // binary operators
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<
+                        typename enable_if<use_operator<Domain, Tag>, Tag>::type
+                          , meta_grammar, meta_grammar>
+                      , detail::make_binary<Domain, Tag, meta_grammar>
+                    >,
+            ///////////////////////////////////////////////////////////////////
+            // unary operators
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::unary_expr<
+                        typename enable_if<use_operator<Domain, Tag>, Tag>::type
+                          , meta_grammar>
+                      , detail::make_unary<Domain, Tag, meta_grammar>
+                    >
+                >
+            {};
+
+            template <>
+            struct case_<proto::tag::subscript>
+              : proto::or_<
+            ///////////////////////////////////////////////////////////////////
+            // directives
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , proto::and_<
+                            proto::terminal<proto::_>
+                          , proto::if_<use_directive<Domain, proto::_value >()> >
+                      , meta_grammar>,
+                        detail::make_directive<Domain, meta_grammar>
+                    >,
+            ///////////////////////////////////////////////////////////////////
+            // semantic actions
+            ///////////////////////////////////////////////////////////////////
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , meta_grammar, proto::_>,
+                        detail::make_action<Domain, meta_grammar>
+                    >
+                >
+            {};
+        };
+#endif
+
+        struct meta_grammar
+          : proto::switch_<cases>
+        {};
+    };
+
+    namespace result_of
+    {
+        // Default case
+        template <typename Domain, typename Expr
+          , typename Modifiers = unused_type, typename Enable = void>
+        struct compile
+        {
+            typedef typename meta_compiler<Domain>::meta_grammar meta_grammar;
+            typedef typename meta_grammar::
+                template result<meta_grammar(Expr, mpl::void_, Modifiers)>::type
+            type;
+        };
+
+        // If Expr is not a proto expression, make it a terminal
+        template <typename Domain, typename Expr, typename Modifiers>
+        struct compile<Domain, Expr, Modifiers,
+            typename disable_if<proto::is_expr<Expr> >::type>
+          : compile<Domain, typename proto::terminal<Expr>::type, Modifiers> {};
+    }
+
+    namespace traits
+    {
+        // Check if Expr matches the domain's grammar
+        template <typename Domain, typename Expr>
+        struct matches :
+            proto::matches<
+                typename proto::result_of::as_expr<
+                    typename remove_reference<Expr>::type>::type,
+                typename meta_compiler<Domain>::meta_grammar
+            >
+        {
+        };
+    }
+
+    namespace detail
+    {
+        template <typename Domain>
+        struct compiler
+        {
+            // Default case
+            template <typename Expr, typename Modifiers>
+            static typename spirit::result_of::compile<Domain, Expr, Modifiers>::type
+            compile(Expr const& expr, Modifiers modifiers, mpl::true_)
+            {
+                typename meta_compiler<Domain>::meta_grammar compiler;
+                return compiler(expr, mpl::void_(), modifiers);
+            }
+
+            // If Expr is not a proto expression, make it a terminal
+            template <typename Expr, typename Modifiers>
+            static typename spirit::result_of::compile<Domain, Expr, Modifiers>::type
+            compile(Expr const& expr, Modifiers modifiers, mpl::false_)
+            {
+                typename meta_compiler<Domain>::meta_grammar compiler;
+                typedef typename detail::as_meta_element<Expr>::type expr_;
+                typename proto::terminal<expr_>::type term = {expr};
+                return compiler(term, mpl::void_(), modifiers);
+            }
+        };
+    }
+
+    template <typename Domain, typename Expr>
+    inline typename result_of::compile<Domain, Expr, unused_type>::type
+    compile(Expr const& expr)
+    {
+        typedef typename proto::is_expr<Expr>::type is_expr;
+        return detail::compiler<Domain>::compile(expr, unused, is_expr());
+    }
+
+    template <typename Domain, typename Expr, typename Modifiers>
+    inline typename result_of::compile<Domain, Expr, Modifiers>::type
+    compile(Expr const& expr, Modifiers modifiers)
+    {
+        typedef typename proto::is_expr<Expr>::type is_expr;
+        return detail::compiler<Domain>::compile(expr, modifiers, is_expr());
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Elements, template <typename Subject> class generator>
+    struct make_unary_composite
+    {
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 0>::type
+        element_type;
+        typedef generator<element_type> result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(elements));
+        }
+    };
+
+    template <typename Elements, template <typename Left, typename Right> class generator>
+    struct make_binary_composite
+    {
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 0>::type
+        left_type;
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 1>::type
+        right_type;
+        typedef generator<left_type, right_type> result_type;
+
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(elements)
+              , fusion::at_c<1>(elements)
+            );
+        }
+    };
+
+    template <typename Elements, template <typename Elements_> class generator>
+    struct make_nary_composite
+    {
+        typedef generator<Elements> result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(elements);
+        }
+    };
+
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/modify.hpp b/3rdParty/Boost/src/boost/spirit/home/support/modify.hpp
new file mode 100644
index 0000000..80d2f71
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/modify.hpp
@@ -0,0 +1,124 @@
+/*=============================================================================
+  Copyright (c) 2001-2011 Joel de Guzman
+  http://spirit.sourceforge.net/
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_MODIFY_OCTOBER_25_2008_0142PM
+#define BOOST_SPIRIT_MODIFY_OCTOBER_25_2008_0142PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_limits.hpp>      // needs to be included before proto
+#include <boost/proto/proto.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+
+namespace boost { namespace spirit
+{
+    template <typename Domain, typename T, typename Enable = void>
+    struct is_modifier_directive;
+
+    // Testing if a modifier set includes a modifier T involves
+    // checking for inheritance (i.e. Modifiers is derived from T)
+    template <typename Modifiers, typename T>
+    struct has_modifier
+        : is_base_of<T, Modifiers> {};
+
+    // Adding modifiers is done using multi-inheritance
+    template <typename Current, typename New, typename Enable = void>
+    struct compound_modifier : Current, New
+    {
+        compound_modifier()
+          : Current(), New() {}
+
+        compound_modifier(Current const& current, New const& new_)
+          : Current(current), New(new_) {}
+    };
+
+    // Don't add if New is already in Current
+    template <typename Current, typename New>
+    struct compound_modifier<
+        Current, New, typename enable_if<has_modifier<Current, New> >::type>
+      : Current
+    {
+        compound_modifier()
+          : Current() {}
+
+        compound_modifier(Current const& current, New const&)
+          : Current(current) {}
+    };
+
+    // Special case if Current is unused_type
+    template <typename New, typename Enable>
+    struct compound_modifier<unused_type, New, Enable> : New
+    {
+        compound_modifier()
+          : New() {}
+
+        compound_modifier(unused_type, New const& new_)
+          : New(new_) {}
+    };
+
+    // Domains may specialize this modify metafunction to allow
+    // directives to add information to the Modifier template
+    // parameter that is passed to the make_component metafunction.
+    // By default, we return the modifiers untouched
+    template <typename Domain, typename Enable = void>
+    struct modify
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Tag, typename Modifiers>
+        struct result<This(Tag, Modifiers)>
+        {
+            typedef typename remove_const<
+                typename remove_reference<Tag>::type>::type
+            tag_type;
+            typedef typename remove_const<
+                typename remove_reference<Modifiers>::type>::type
+            modifiers_type;
+
+            typedef typename mpl::if_<
+                is_modifier_directive<Domain, tag_type>
+              , compound_modifier<modifiers_type, tag_type>
+              , Modifiers>::type
+            type;
+        };
+
+        template <typename Tag, typename Modifiers>
+        typename result<modify(Tag, Modifiers)>::type
+        operator()(Tag tag, Modifiers modifiers) const
+        {
+            return op(tag, modifiers, is_modifier_directive<Domain, Tag>());
+        }
+
+        template <typename Tag, typename Modifiers>
+        Modifiers
+        op(Tag /*tag*/, Modifiers modifiers, mpl::false_) const
+        {
+            return modifiers;
+        }
+
+        template <typename Tag, typename Modifiers>
+        compound_modifier<Modifiers, Tag>
+        op(Tag tag, Modifiers modifiers, mpl::true_) const
+        {
+            return compound_modifier<Modifiers, Tag>(modifiers, tag);
+        }
+    };
+}}
+
+namespace boost { namespace proto
+{
+    template <typename Domain, typename Enable>
+    struct is_callable<spirit::modify<Domain, Enable> >
+      : mpl::true_ {};
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/multi_pass_wrapper.hpp b/3rdParty/Boost/src/boost/spirit/home/support/multi_pass_wrapper.hpp
new file mode 100644
index 0000000..ec5fa36
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/multi_pass_wrapper.hpp
@@ -0,0 +1,52 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+// 
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_SPIRIT_ITERATOR_MULTI_PASS_WRAPPER_JUL_12_2009_0914PM)
+#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_WRAPPER_JUL_12_2009_0914PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    // declare special functions allowing to integrate any multi_pass iterator
+    // with expectation points
+
+    // normal iterators require no special handling
+    BOOST_SCOPED_ENUM_START(clear_mode) 
+    {
+        clear_if_enabled,
+        clear_always
+    };
+    BOOST_SCOPED_ENUM_END
+
+    template <typename Iterator>
+    void clear_queue(Iterator&
+      , BOOST_SCOPED_ENUM(clear_mode) /*mode*/ = clear_mode::clear_if_enabled) 
+    {}
+
+    template <typename Iterator>
+    void inhibit_clear_queue(Iterator&, bool) 
+    {}
+
+    template <typename Iterator>
+    bool inhibit_clear_queue(Iterator&) 
+    { 
+        return false; 
+    }
+
+    // Helper template to recognize a multi_pass iterator. This specialization
+    // will be instantiated for any non-multi_pass iterator.
+    template <typename Iterator>
+    struct is_multi_pass : mpl::false_ {};
+
+}}}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp
new file mode 100644
index 0000000..f037acc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp
@@ -0,0 +1,88 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_EXPAND_ARG_FEB_19_2007_1107AM)
+#define BOOST_SPIRIT_EXPAND_ARG_FEB_19_2007_1107AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/spirit/home/support/string_traits.hpp>
+
+namespace boost { namespace spirit { namespace detail
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Context>
+    struct expand_arg
+    {
+        template <typename T>
+        struct result_type
+        {
+            // This is a temporary hack. The better way is to detect if T
+            // can be called given unused context.
+            typedef typename
+                mpl::eval_if<
+                    mpl::or_<is_scalar<T>, traits::is_string<T> >
+                  , mpl::identity<T const &>
+                  , boost::result_of<T(unused_type, Context)>
+                >::type
+            type;
+        };
+
+        template <typename T>
+        struct result;
+
+        template <typename F, typename A0>
+        struct result<F(A0)>
+          : result_type<A0> {};
+
+        template <typename F, typename A0>
+        struct result<F(A0&)>
+          : result_type<A0> {};
+
+        expand_arg(Context& context)
+          : context(context)
+        {
+        }
+
+        template <typename T>
+        typename result_type<T>::type
+        call(T const& f, mpl::false_) const
+        {
+            return f(unused, context);
+        }
+
+        template <typename T>
+        typename result_type<T>::type
+        call(T const& val, mpl::true_) const
+        {
+            return val;
+        }
+
+        template <typename T>
+        typename result_type<T>::type
+        operator()(T const& x) const
+        {
+            return call(x, mpl::or_<is_scalar<T>, traits::is_string<T> >());
+        }
+
+        Context& context;
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        expand_arg& operator= (expand_arg const&);
+    };
+
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/extract_param.hpp b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/extract_param.hpp
new file mode 100644
index 0000000..6149932
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/extract_param.hpp
@@ -0,0 +1,123 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2009 Francois Barel
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_EXTRACT_PARAM_AUGUST_08_2009_0848AM)
+#define BOOST_SPIRIT_EXTRACT_PARAM_AUGUST_08_2009_0848AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/support/nonterminal/locals.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/common_terminals.hpp>
+
+#include <boost/function_types/is_function.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/fusion/include/as_list.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace spirit { namespace detail
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Helpers to extract params (locals, attributes, ...) from nonterminal
+    // template arguments
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Types, typename Pred, typename Default>
+    struct extract_param
+    {
+        typedef typename mpl::find_if<Types, Pred>::type pos;
+
+        typedef typename
+            mpl::eval_if<
+                is_same<pos, typename mpl::end<Types>::type>
+              , mpl::identity<Default>
+              , mpl::deref<pos>
+            >::type
+        type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Types>
+    struct extract_locals
+      : fusion::result_of::as_vector<
+            typename extract_param<
+                Types
+              , is_locals<mpl::_>
+              , locals<>
+            >::type
+        >
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Domain, typename Types>
+    struct extract_component
+      : spirit::result_of::compile<
+            Domain
+          , typename extract_param<
+                Types
+              , traits::matches<Domain, mpl::_>
+              , unused_type
+            >::type
+        >
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Types>
+    struct extract_sig
+      : extract_param<
+            Types
+          , function_types::is_function<mpl::_>
+          , void()
+        >
+    {};
+
+    template <typename Sig>
+    struct attr_from_sig
+    {
+        typedef typename function_types::result_type<Sig>::type attr;
+
+        typedef typename
+            mpl::if_<
+                is_same<attr, void>
+              , unused_type
+              , attr
+            >::type
+        type;
+    };
+
+    template <typename Sig>
+    struct params_from_sig
+    {
+        typedef typename function_types::parameter_types<Sig>::type params;
+
+        typedef typename fusion::result_of::as_list<params>::type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Types>
+    struct extract_encoding
+      : extract_param<
+            Types
+          , is_char_encoding<mpl::_>
+          , unused_type
+        >
+    {};
+}}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/locals.hpp b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/locals.hpp
new file mode 100644
index 0000000..4db0349
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/locals.hpp
@@ -0,0 +1,54 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_LOCALS_APRIL_03_2007_0506PM)
+#define BOOST_SPIRIT_LOCALS_APRIL_03_2007_0506PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/bool.hpp>
+
+#if !defined(BOOST_SPIRIT_MAX_LOCALS_SIZE)
+# define BOOST_SPIRIT_MAX_LOCALS_SIZE 10
+#else
+# if BOOST_SPIRIT_MAX_LOCALS_SIZE < 3
+#   undef BOOST_SPIRIT_MAX_LOCALS_SIZE
+#   define BOOST_SPIRIT_MAX_LOCALS_SIZE 10
+# endif
+#endif
+
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <
+        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            BOOST_SPIRIT_MAX_LOCALS_SIZE, typename T, mpl::na)
+    >
+    struct locals
+      : mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_SPIRIT_MAX_LOCALS_SIZE, T)> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename T>
+        struct is_locals
+          : mpl::false_
+        {};
+
+        template <BOOST_PP_ENUM_PARAMS(BOOST_SPIRIT_MAX_LOCALS_SIZE, typename T)>
+        struct is_locals<locals<BOOST_PP_ENUM_PARAMS(BOOST_SPIRIT_MAX_LOCALS_SIZE, T)> >
+          : mpl::true_
+        {};
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/string_traits.hpp b/3rdParty/Boost/src/boost/spirit/home/support/string_traits.hpp
new file mode 100644
index 0000000..f970012
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/string_traits.hpp
@@ -0,0 +1,358 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c)      2010 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+================================================_==============================*/
+#if !defined(BOOST_SPIRIT_STRING_TRAITS_OCTOBER_2008_1252PM)
+#define BOOST_SPIRIT_STRING_TRAITS_OCTOBER_2008_1252PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/container.hpp>
+#include <string>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/type_traits/is_const.hpp>
+#if defined(__GNUC__) && (__GNUC__ < 4)
+#include <boost/type_traits/add_const.hpp>
+#endif
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Determine if T is a character type
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct is_char : mpl::false_ {};
+
+    template <typename T>
+    struct is_char<T const> : is_char<T> {};
+
+    template <>
+    struct is_char<char> : mpl::true_ {};
+
+    template <>
+    struct is_char<wchar_t> : mpl::true_ {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Determine if T is a string
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct is_string : mpl::false_ {};
+
+    template <typename T>
+    struct is_string<T const> : is_string<T> {};
+
+    template <>
+    struct is_string<char const*> : mpl::true_ {};
+
+    template <>
+    struct is_string<wchar_t const*> : mpl::true_ {};
+
+    template <>
+    struct is_string<char*> : mpl::true_ {};
+
+    template <>
+    struct is_string<wchar_t*> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<char[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<wchar_t[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<char const[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<wchar_t const[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<char(&)[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<wchar_t(&)[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<char const(&)[N]> : mpl::true_ {};
+
+    template <std::size_t N>
+    struct is_string<wchar_t const(&)[N]> : mpl::true_ {};
+
+    template <typename T, typename Traits, typename Allocator>
+    struct is_string<std::basic_string<T, Traits, Allocator> > : mpl::true_ {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Get the underlying char type of a string
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct char_type_of;
+
+    template <typename T>
+    struct char_type_of<T const> : char_type_of<T> {};
+
+    template <>
+    struct char_type_of<char> : mpl::identity<char> {};
+
+    template <>
+    struct char_type_of<wchar_t> : mpl::identity<wchar_t> {};
+
+    template <>
+    struct char_type_of<char const*> : mpl::identity<char const> {};
+
+    template <>
+    struct char_type_of<wchar_t const*> : mpl::identity<wchar_t const> {};
+
+    template <>
+    struct char_type_of<char*> : mpl::identity<char> {};
+
+    template <>
+    struct char_type_of<wchar_t*> : mpl::identity<wchar_t> {};
+
+    template <std::size_t N>
+    struct char_type_of<char[N]> : mpl::identity<char> {};
+
+    template <std::size_t N>
+    struct char_type_of<wchar_t[N]> : mpl::identity<wchar_t> {};
+
+    template <std::size_t N>
+    struct char_type_of<char const[N]> : mpl::identity<char const> {};
+
+    template <std::size_t N>
+    struct char_type_of<wchar_t const[N]> : mpl::identity<wchar_t const> {};
+
+    template <std::size_t N>
+    struct char_type_of<char(&)[N]> : mpl::identity<char> {};
+
+    template <std::size_t N>
+    struct char_type_of<wchar_t(&)[N]> : mpl::identity<wchar_t> {};
+
+    template <std::size_t N>
+    struct char_type_of<char const(&)[N]> : mpl::identity<char const> {};
+
+    template <std::size_t N>
+    struct char_type_of<wchar_t const(&)[N]> : mpl::identity<wchar_t const> {};
+
+    template <typename T, typename Traits, typename Allocator>
+    struct char_type_of<std::basic_string<T, Traits, Allocator> >
+      : mpl::identity<T> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Get the C string from a string
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename String>
+    struct extract_c_string;
+
+    template <typename String>
+    struct extract_c_string
+    {
+        typedef typename char_type_of<String>::type char_type;
+
+        template <typename T>
+        static T const* call (T* str)
+        {
+            return (T const*)str; 
+        }
+
+        template <typename T>
+        static T const* call (T const* str)
+        {
+            return str; 
+        }
+    }; 
+    
+    // Forwarder that strips const
+    template <typename T>
+    struct extract_c_string<T const>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+
+        static typename extract_c_string<T>::char_type const* call (T const str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+
+    // Forwarder that strips references
+    template <typename T>
+    struct extract_c_string<T&>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+
+        static typename extract_c_string<T>::char_type const* call (T& str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+
+    // Forwarder that strips const references
+    template <typename T>
+    struct extract_c_string<T const&>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+
+        static typename extract_c_string<T>::char_type const* call (T const& str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+
+    template <typename T, typename Traits, typename Allocator>
+    struct extract_c_string<std::basic_string<T, Traits, Allocator> >
+    {
+        typedef T char_type;
+
+        typedef std::basic_string<T, Traits, Allocator> string;
+
+        static T const* call (string const& str)
+        {
+            return str.c_str();
+        }
+    };
+    
+    template <typename T>
+    typename extract_c_string<T*>::char_type const*
+    get_c_string (T* str)
+    {
+        return extract_c_string<T*>::call(str);
+    }
+
+    template <typename T>
+    typename extract_c_string<T const*>::char_type const*
+    get_c_string (T const* str)
+    {
+        return extract_c_string<T const*>::call(str);
+    }
+    
+    template <typename String>
+    typename extract_c_string<String>::char_type const*
+    get_c_string (String& str)
+    {
+        return extract_c_string<String>::call(str);
+    }
+
+    template <typename String>
+    typename extract_c_string<String>::char_type const*
+    get_c_string (String const& str)
+    {
+        return extract_c_string<String>::call(str);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Get the begin/end iterators from a string
+    ///////////////////////////////////////////////////////////////////////////
+
+    // Implementation for C-style strings.
+
+// gcc 3.x.x has problems resolving ambiguities here
+#if defined(__GNUC__) && (__GNUC__ < 4)
+    template <typename T>
+    inline typename add_const<T>::type * get_begin(T* str) { return str; }
+
+    template <typename T>
+    inline typename add_const<T>::type* get_end(T* str)
+    {
+        T* last = str;
+        while (*last)
+            last++;
+        return last;
+    }
+#else
+    template <typename T>
+    inline T const* get_begin(T const* str) { return str; }
+
+    template <typename T>
+    inline T* get_begin(T* str) { return str; }
+
+    template <typename T>
+    inline T const* get_end(T const* str)
+    {
+        T const* last = str;
+        while (*last)
+            last++;
+        return last;
+    }
+
+    template <typename T>
+    inline T* get_end(T* str)
+    {
+        T* last = str;
+        while (*last)
+            last++;
+        return last;
+    }
+#endif
+
+    // Implementation for containers (includes basic_string).
+    template <typename T, typename Str>
+    inline typename Str::const_iterator get_begin(Str const& str)
+    { return str.begin(); }
+
+    template <typename T, typename Str>
+    inline typename Str::iterator
+    get_begin(Str& str BOOST_PROTO_DISABLE_IF_IS_CONST(Str))
+    { return str.begin(); }
+
+    template <typename T, typename Str>
+    inline typename Str::const_iterator get_end(Str const& str)
+    { return str.end(); }
+
+    template <typename T, typename Str>
+    inline typename Str::iterator
+    get_end(Str& str BOOST_PROTO_DISABLE_IF_IS_CONST(Str))
+    { return str.end(); }
+
+    // Default implementation for other types: try a C-style string
+    // conversion.
+    // These overloads are explicitly disabled for containers,
+    // as they would be ambiguous with the previous ones.
+    template <typename T, typename Str>
+    inline typename disable_if<is_container<Str>
+      , T const*>::type get_begin(Str const& str)
+    { return str; }
+
+    template <typename T, typename Str>
+    inline typename disable_if<is_container<Str>
+      , T const*>::type get_end(Str const& str)
+    { return get_end(get_begin<T>(str)); }
+}
+
+namespace result_of
+{
+    template <typename Char, typename T, typename Enable = void>
+    struct get_begin
+    {
+        typedef typename traits::char_type_of<T>::type char_type;
+
+        typedef typename mpl::if_<
+            is_const<char_type>
+          , char_type const 
+          , char_type
+        >::type* type;
+    };
+
+    template <typename Char, typename Str>
+    struct get_begin<Char, Str
+      , typename enable_if<traits::is_container<Str> >::type>
+    {
+        typedef typename mpl::if_<
+            is_const<Str>
+          , typename Str::const_iterator
+          , typename Str::iterator
+        >::type type;
+    };
+
+    template <typename Char, typename T>
+    struct get_end : get_begin<Char, T> {};
+}
+
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp b/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp
new file mode 100644
index 0000000..d52fad2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp
@@ -0,0 +1,655 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c)      2011 Thomas Heller
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_TERMINAL_NOVEMBER_04_2008_0906AM)
+#define BOOST_SPIRIT_TERMINAL_NOVEMBER_04_2008_0906AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/proto/proto.hpp>
+#include <boost/fusion/include/void.hpp>
+#include <boost/spirit/home/support/meta_compiler.hpp>
+#include <boost/spirit/home/support/detail/make_vector.hpp>
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/detail/is_spirit_tag.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+
+#include <boost/spirit/home/support/terminal_expression.hpp>
+
+namespace boost { namespace spirit
+{
+    template <typename Terminal, typename Args>
+    struct terminal_ex
+    {
+        typedef Terminal terminal_type;
+        typedef Args args_type;
+
+        terminal_ex(Args const& args)
+          : args(args) {}
+        terminal_ex(Args const& args, Terminal const& term)
+          : args(args), term(term) {}
+
+        Args args;  // Args is guaranteed to be a fusion::vectorN so you
+                    // can use that template for detection and specialization
+        Terminal term;
+    };
+
+    template <typename Terminal, typename Actor, int Arity>
+    struct lazy_terminal
+    {
+        typedef Terminal terminal_type;
+        typedef Actor actor_type;
+        static int const arity = Arity;
+
+        lazy_terminal(Actor const& actor)
+          : actor(actor) {}
+        lazy_terminal(Actor const& actor, Terminal const& term)
+          : actor(actor), term(term) {}
+
+        Actor actor;
+        Terminal term;
+    };
+
+    template <typename Domain, typename Terminal, int Arity, typename Enable = void>
+    struct use_lazy_terminal : mpl::false_ {};
+
+    template <typename Domain, typename Terminal, int Arity, typename Enable = void>
+    struct use_lazy_directive : mpl::false_ {};
+
+    template <typename Terminal>
+    struct terminal;
+
+    template <typename Domain, typename Terminal>
+    struct use_terminal<Domain, terminal<Terminal> >
+        : use_terminal<Domain, Terminal> {};
+
+    template <typename Domain, typename Terminal, int Arity, typename Actor>
+    struct use_terminal<Domain, lazy_terminal<Terminal, Actor, Arity> >
+        : use_lazy_terminal<Domain, Terminal, Arity> {};
+
+    template <typename Domain, typename Terminal, int Arity, typename Actor>
+    struct use_directive<Domain, lazy_terminal<Terminal, Actor, Arity> >
+        : use_lazy_directive<Domain, Terminal, Arity> {};
+
+    template <
+        typename F
+      , typename A0 = unused_type
+      , typename A1 = unused_type
+      , typename A2 = unused_type
+      , typename Unused = unused_type
+    >
+    struct make_lazy;
+
+    template <typename F, typename A0>
+    struct make_lazy<F, A0>
+    {
+        typedef typename
+            proto::terminal<
+                lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0>::type
+                  , 1 // arity
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+
+        result_type
+        operator()(F f, A0 const& _0) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0>::make(f, _0)
+              , f.proto_base().child0
+            ));
+        }
+    };
+
+    template <typename F, typename A0, typename A1>
+    struct make_lazy<F, A0, A1>
+    {
+        typedef typename
+            proto::terminal<
+               lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0, A1>::type
+                  , 2 // arity
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+
+        result_type
+        operator()(F f, A0 const& _0, A1 const& _1) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0, _1)
+              , f.proto_base().child0
+            ));
+        }
+    };
+
+    template <typename F, typename A0, typename A1, typename A2>
+    struct make_lazy<F, A0, A1, A2>
+    {
+        typedef typename
+            proto::terminal<
+               lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0, A1, A2>::type
+                  , 3 // arity
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+
+        result_type
+        operator()(F f, A0 const& _0, A1 const& _1, A2 const& _2) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0, _1, _2)
+              , f.proto_base().child0
+            ));
+        }
+    };
+
+    namespace detail
+    {
+        // Helper struct for SFINAE purposes
+        template <bool C> struct bool_;
+
+        template <>
+        struct bool_<true> : mpl::bool_<true>
+        { 
+            typedef bool_<true>* is_true; 
+        };
+
+        template <>
+        struct bool_<false> : mpl::bool_<false>
+        { 
+            typedef bool_<false>* is_false; 
+        };
+
+        // Metafunction to detect if at least one arg is a Phoenix actor
+        template <
+            typename A0
+          , typename A1 = unused_type
+          , typename A2 = unused_type
+        >
+        struct contains_actor
+            : bool_<
+                  phoenix::is_actor<A0>::value
+               || phoenix::is_actor<A1>::value
+               || phoenix::is_actor<A2>::value
+              >
+        {};
+
+        // to_lazy_arg: convert a terminal arg type to the type make_lazy needs
+        template <typename A>
+        struct to_lazy_arg
+          : phoenix::as_actor<A> // wrap A in a Phoenix actor if not already one
+        {};
+
+        template <typename A>
+        struct to_lazy_arg<const A>
+          : to_lazy_arg<A>
+        {};
+        
+        template <typename A>
+        struct to_lazy_arg<A &>
+          : to_lazy_arg<A>
+        {};
+
+        template <>
+        struct to_lazy_arg<unused_type>
+        {
+            // unused arg: make_lazy wants unused_type
+            typedef unused_type type;
+        };
+
+        // to_nonlazy_arg: convert a terminal arg type to the type make_vector needs
+        template <typename A>
+        struct to_nonlazy_arg
+        {
+            // identity
+            typedef A type;
+        };
+
+        template <typename A>
+        struct to_nonlazy_arg<const A>
+          : to_nonlazy_arg<A>
+        {};
+
+        template <typename A>
+        struct to_nonlazy_arg<A &>
+          : to_nonlazy_arg<A>
+        {};
+
+        template <>
+        struct to_nonlazy_arg<unused_type>
+        {
+            // unused arg: make_vector wants fusion::void_
+            typedef fusion::void_ type;
+        };
+    }
+
+    template <typename Terminal>
+    struct terminal
+      : proto::extends<
+            typename proto::terminal<Terminal>::type
+          , terminal<Terminal>
+        >
+    {
+        typedef terminal<Terminal> this_type;
+        typedef Terminal terminal_type;
+
+        typedef proto::extends<
+            typename proto::terminal<Terminal>::type
+          , terminal<Terminal>
+        > base_type;
+
+        terminal() {}
+
+        terminal(Terminal const& t)
+          : base_type(proto::terminal<Terminal>::type::make(t)) 
+        {}
+
+        template <
+            bool Lazy
+          , typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper;
+
+        template <
+            typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper<false, A0, A1, A2>
+        {
+            typedef typename
+                proto::terminal<
+                    terminal_ex<
+                        Terminal
+                      , typename detail::result_of::make_vector<
+                            typename detail::to_nonlazy_arg<A0>::type
+                          , typename detail::to_nonlazy_arg<A1>::type
+                          , typename detail::to_nonlazy_arg<A2>::type>::type>
+                >::type
+            type;
+        };
+
+        template <
+            typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper<true, A0, A1, A2>
+        {
+            typedef typename
+                make_lazy<this_type
+                  , typename detail::to_lazy_arg<A0>::type
+                  , typename detail::to_lazy_arg<A1>::type
+                  , typename detail::to_lazy_arg<A2>::type>::type
+            type;
+        };
+
+        // FIXME: we need to change this to conform to the result_of protocol
+        template <
+            typename A0
+          , typename A1 = unused_type
+          , typename A2 = unused_type      // Support up to 3 args
+        >
+        struct result
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, A1, A2>::value
+                  , A0, A1, A2
+                >::type
+            type;
+        };
+
+        template <typename This, typename A0>
+        struct result<This(A0)>
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, unused_type, unused_type>::value
+                  , A0, unused_type, unused_type
+                >::type
+            type;
+        };
+
+        template <typename This, typename A0, typename A1>
+        struct result<This(A0, A1)>
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, A1, unused_type>::value
+                  , A0, A1, unused_type
+                >::type
+            type;
+        };
+
+
+        template <typename This, typename A0, typename A1, typename A2>
+        struct result<This(A0, A1, A2)>
+        {
+            typedef typename
+                result_helper<
+                     detail::contains_actor<A0, A1, A2>::value
+                   , A0, A1, A2
+                 >::type
+                 type;
+        };
+
+        // Note: in the following overloads, SFINAE cannot
+        // be done on return type because of gcc bug #24915:
+        //   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24915
+        // Hence an additional, fake argument is used for SFINAE,
+        // using a type which can never be a real argument type.
+
+        // Non-lazy overloads. Only enabled when all
+        // args are immediates (no Phoenix actor).
+
+        template <typename A0>
+        typename result<A0>::type
+        operator()(A0 const& _0
+          , typename detail::contains_actor<A0>::is_false = 0) const
+        {
+            typedef typename result<A0>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0)
+                  , this->proto_base().child0)
+            );
+        }
+
+        template <typename A0, typename A1>
+        typename result<A0, A1>::type
+        operator()(A0 const& _0, A1 const& _1
+          , typename detail::contains_actor<A0, A1>::is_false = 0) const
+        {
+            typedef typename result<A0, A1>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0, _1)
+                  , this->proto_base().child0)
+            );
+        }
+
+        template <typename A0, typename A1, typename A2>
+        typename result<A0, A1, A2>::type
+        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+          , typename detail::contains_actor<A0, A1, A2>::is_false = 0) const
+        {
+            typedef typename result<A0, A1, A2>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0, _1, _2)
+                  , this->proto_base().child0)
+            );
+        }
+
+        // Lazy overloads. Enabled when at
+        // least one arg is a Phoenix actor.
+        template <typename A0>
+        typename result<A0>::type
+        operator()(A0 const& _0
+          , typename detail::contains_actor<A0>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0));
+        }
+
+        template <typename A0, typename A1>
+        typename result<A0, A1>::type
+        operator()(A0 const& _0, A1 const& _1
+          , typename detail::contains_actor<A0, A1>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type
+              , typename phoenix::as_actor<A1>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0)
+              , phoenix::as_actor<A1>::convert(_1));
+        }
+
+        template <typename A0, typename A1, typename A2>
+        typename result<A0, A1, A2>::type
+        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+          , typename detail::contains_actor<A0, A1, A2>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type
+              , typename phoenix::as_actor<A1>::type
+              , typename phoenix::as_actor<A2>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0)
+              , phoenix::as_actor<A1>::convert(_1)
+              , phoenix::as_actor<A2>::convert(_2));
+        }
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        terminal& operator= (terminal const&);
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace result_of
+    {
+        // Calculate the type of the compound terminal if generated by one of
+        // the spirit::terminal::operator() overloads above
+
+        // The terminal type itself is passed through without modification
+        template <typename Tag>
+        struct terminal
+        {
+            typedef spirit::terminal<Tag> type;
+        };
+
+        template <typename Tag, typename A0>
+        struct terminal<Tag(A0)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0>::type type;
+        };
+
+        template <typename Tag, typename A0, typename A1>
+        struct terminal<Tag(A0, A1)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0, A1>::type type;
+        };
+
+        template <typename Tag, typename A0, typename A1, typename A2>
+        struct terminal<Tag(A0, A1, A2)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0, A1, A2>::type type;
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // support for stateful tag types
+    namespace tag
+    {
+        template <
+            typename Data, typename Tag
+          , typename DataTag1 = unused_type, typename DataTag2 = unused_type>
+        struct stateful_tag
+        {
+            BOOST_SPIRIT_IS_TAG()
+
+            typedef Data data_type;
+
+            stateful_tag() {}
+            stateful_tag(data_type const& data) : data_(data) {}
+
+            data_type data_;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            stateful_tag& operator= (stateful_tag const&);
+        };
+    }
+
+    template <
+        typename Data, typename Tag
+      , typename DataTag1 = unused_type, typename DataTag2 = unused_type>
+    struct stateful_tag_type
+      : spirit::terminal<tag::stateful_tag<Data, Tag, DataTag1, DataTag2> >
+    {
+        typedef tag::stateful_tag<Data, Tag, DataTag1, DataTag2> tag_type;
+
+        stateful_tag_type() {}
+        stateful_tag_type(Data const& data)
+          : spirit::terminal<tag_type>(data) 
+        {}
+
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        stateful_tag_type& operator= (stateful_tag_type const&);
+    };
+
+    namespace detail
+    {
+        // extract expression if this is a Tag
+        template <typename StatefulTag>
+        struct get_stateful_data
+        {
+            typedef typename StatefulTag::data_type data_type;
+
+            // is invoked if given tag is != Tag
+            template <typename Tag_>
+            static data_type call(Tag_) { return data_type(); }
+
+            // this is invoked if given tag is same as'Tag'
+            static data_type const& call(StatefulTag const& t) { return t.data_; }
+        };
+    }
+
+}}
+
+#ifdef BOOST_SPIRIT_USE_PHOENIX_V3
+namespace boost { namespace phoenix
+{
+    template <typename Tag>
+    struct is_custom_terminal<Tag, typename Tag::is_spirit_tag>
+      : mpl::true_
+    {};
+
+    template <typename Tag>
+    struct custom_terminal<Tag, typename Tag::is_spirit_tag>
+    {
+        typedef spirit::terminal<Tag> result_type;
+
+        template <typename Context>
+        result_type operator()(Tag const & t, Context const &)
+        {
+            return spirit::terminal<Tag>(t);
+        }
+    };
+}}
+#endif
+
+// Define a spirit terminal. This macro may be placed in any namespace.
+// Common placeholders are placed in the main boost::spirit namespace
+// (see common_terminals.hpp)
+
+#define BOOST_SPIRIT_TERMINAL_X(x, y) ((x, y)) BOOST_SPIRIT_TERMINAL_Y
+#define BOOST_SPIRIT_TERMINAL_Y(x, y) ((x, y)) BOOST_SPIRIT_TERMINAL_X
+#define BOOST_SPIRIT_TERMINAL_X0
+#define BOOST_SPIRIT_TERMINAL_Y0
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define BOOST_SPIRIT_TERMINAL_NAME(name, type_name)                             \
+    namespace tag { struct name { BOOST_SPIRIT_IS_TAG() }; }                    \
+    typedef boost::proto::terminal<tag::name>::type type_name;                  \
+    type_name const name = {{}};                                                \
+    inline void BOOST_PP_CAT(silence_unused_warnings_, name)() { (void) name; } \
+    /***/
+
+#else
+
+#define BOOST_SPIRIT_TERMINAL_NAME(name, type_name)                             \
+    namespace tag { struct name { BOOST_SPIRIT_IS_TAG() }; }                    \
+    typedef boost::proto::terminal<tag::name>::type type_name;                  \
+    /***/
+
+#endif
+
+#define BOOST_SPIRIT_TERMINAL(name)                                             \
+    BOOST_SPIRIT_TERMINAL_NAME(name, name ## _type)                             \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE_TERMINALS_NAME_A(r, _, names)                       \
+    BOOST_SPIRIT_TERMINAL_NAME(                                                 \
+        BOOST_PP_TUPLE_ELEM(2, 0, names),                                       \
+        BOOST_PP_TUPLE_ELEM(2, 1, names)                                        \
+    )                                                                           \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE_TERMINALS_NAME(seq)                                 \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_SPIRIT_DEFINE_TERMINALS_NAME_A, _,              \
+        BOOST_PP_CAT(BOOST_SPIRIT_TERMINAL_X seq, 0))                           \
+    /***/
+
+// Define a spirit extended terminal. This macro may be placed in any namespace.
+// Common placeholders are placed in the main boost::spirit namespace
+// (see common_terminals.hpp)
+
+#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#define BOOST_SPIRIT_TERMINAL_NAME_EX(name, type_name)                          \
+    namespace tag { struct name { BOOST_SPIRIT_IS_TAG() }; }                    \
+    typedef boost::spirit::terminal<tag::name> type_name;                       \
+    type_name const name = type_name();                                         \
+    inline void BOOST_PP_CAT(silence_unused_warnings_, name)() { (void) name; } \
+    /***/
+
+#else
+
+#define BOOST_SPIRIT_TERMINAL_NAME_EX(name, type_name)                          \
+    namespace tag { struct name { BOOST_SPIRIT_IS_TAG() }; }                    \
+    typedef boost::spirit::terminal<tag::name> type_name;                       \
+    /***/
+
+#endif
+
+#define BOOST_SPIRIT_TERMINAL_EX(name)                                          \
+    BOOST_SPIRIT_TERMINAL_NAME_EX(name, name ## _type)                          \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX_A(r, _, names)                    \
+    BOOST_SPIRIT_TERMINAL_NAME_EX(                                              \
+        BOOST_PP_TUPLE_ELEM(2, 0, names),                                       \
+        BOOST_PP_TUPLE_ELEM(2, 1, names)                                        \
+    )                                                                           \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX(seq)                              \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX_A, _,           \
+        BOOST_PP_CAT(BOOST_SPIRIT_TERMINAL_X seq, 0))                           \
+    /***/
+
+#endif
+
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp b/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp
new file mode 100644
index 0000000..cf6bc5d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c)      2011 Thomas Heller
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM)
+#define BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM
+
+#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
+
+namespace boost { namespace phoenix { namespace detail
+{
+    namespace expression
+    {
+        template <
+            typename F, typename A0 = void, typename A1 = void
+          , typename A2 = void, typename Dummy = void>
+        struct function_eval;
+
+        template <typename F, typename A0>
+        struct function_eval<F, A0>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<1>, F, A0
+                >::type
+            > type;
+
+            static type make(F f, A0 const & _0)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<1> >(f, _0);
+            }
+        };
+        
+        template <typename F, typename A0, typename A1>
+        struct function_eval<F, A0, A1>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<2>, F, A0, A1
+                >::type
+            > type;
+
+            static type make(F f, A0 const & _0, A1 const & _1)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<2> >(f, _0, _1);
+            }
+        };
+
+        template <typename F, typename A0, typename A1, typename A2>
+        struct function_eval<F, A0, A1, A2>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<3>, F, A0, A1, A2
+                >::type
+            > type;
+
+            static type make(F f, A0 const & _0, A1 const & _1, A2 const & _2)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<3> >(f, _0, _1, _2);
+            }
+        };
+    }
+}}}
+
+#endif // !BOOST_SPIRIT_USE_PHOENIX_V3
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/unused.hpp b/3rdParty/Boost/src/boost/spirit/home/support/unused.hpp
new file mode 100644
index 0000000..4197d6a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/unused.hpp
@@ -0,0 +1,105 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_UNUSED_APRIL_16_2006_0616PM)
+#define BOOST_SPIRIT_UNUSED_APRIL_16_2006_0616PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4522) // multiple assignment operators specified warning
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // We do not import fusion ::unused_type anymore to avoid boost::fusion
+    // being turned into an associate namespace for boost::spirit, as this
+    // interferes with ADL in unexpected ways. We rather copy the full 
+    // unused_type implementation from boost::fusion.
+    ///////////////////////////////////////////////////////////////////////////
+    struct unused_type
+    {
+        unused_type()
+        {
+        }
+
+        template <typename T>
+        unused_type(T const&)
+        {
+        }
+
+        template <typename T>
+        unused_type const&
+        operator=(T const&) const
+        {
+            return *this;
+        }
+
+        template <typename T>
+        unused_type&
+        operator=(T const&)
+        {
+            return *this;
+        }
+
+        unused_type const&
+        operator=(unused_type const&) const
+        {
+            return *this;
+        }
+
+        unused_type&
+        operator=(unused_type const&)
+        {
+            return *this;
+        }
+    };
+
+    unused_type const unused = unused_type();
+
+    namespace detail
+    {
+        struct unused_only
+        {
+            unused_only(unused_type const&) {}
+        };
+    }
+
+    template <typename Out>
+    inline Out& operator<<(Out& out, detail::unused_only const&)
+    {
+        return out;
+    }
+
+    template <typename In>
+    inline In& operator>>(In& in, unused_type&)
+    {
+        return in;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace traits
+    {
+        // We use this test to detect if the argument is not an unused_type
+        template <typename T> struct not_is_unused : mpl::true_ {};
+        template <> struct not_is_unused<unused_type> : mpl::false_ {};
+    }
+}}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/utf8.hpp b/3rdParty/Boost/src/boost/spirit/home/support/utf8.hpp
new file mode 100644
index 0000000..c488342
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/utf8.hpp
@@ -0,0 +1,72 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_UC_TYPES_NOVEMBER_23_2008_0840PM)
+#define BOOST_SPIRIT_UC_TYPES_NOVEMBER_23_2008_0840PM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/foreach.hpp>
+#include <boost/regex/pending/unicode_iterator.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <string>
+
+namespace boost { namespace spirit
+{
+    typedef ::boost::uint32_t ucs4_char;
+    typedef char utf8_char;
+    typedef std::basic_string<ucs4_char> ucs4_string;
+    typedef std::basic_string<utf8_char> utf8_string;
+
+    template <typename Char>
+    inline utf8_string to_utf8(Char value)
+    {
+        // always store as UTF8
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        *utf8_iter = (UChar)value;
+        return result;
+    }
+
+    template <typename Char>
+    inline utf8_string to_utf8(Char const* str)
+    {
+        // always store as UTF8
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        while (*str)
+            *utf8_iter++ = (UChar)*str++;
+        return result;
+    }
+
+    template <typename Char, typename Traits, typename Allocator>
+    inline utf8_string 
+    to_utf8(std::basic_string<Char, Traits, Allocator> const& str)
+    {
+        // always store as UTF8
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        BOOST_FOREACH(Char ch, str)
+        {
+            *utf8_iter++ = (UChar)ch;
+        }
+        return result;
+    }
+}}
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/utree/utree_traits_fwd.hpp b/3rdParty/Boost/src/boost/spirit/home/support/utree/utree_traits_fwd.hpp
new file mode 100644
index 0000000..7830c79
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/utree/utree_traits_fwd.hpp
@@ -0,0 +1,24 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_OUTPUT_UTREE_TRAITS_FWD_FEB_14_2011_0632AM)
+#define BOOST_SPIRIT_OUTPUT_UTREE_TRAITS_FWD_FEB_14_2011_0632AM
+
+///////////////////////////////////////////////////////////////////////////////
+// forward declarations only
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit 
+{ 
+    class utree;
+}}
+
+namespace boost
+{
+    template <typename T>
+    inline T get(boost::spirit::utree const& x);
+}
+
+#endif
author	Kevin Smith <git@kismith.co.uk>	2013-01-12 18:41:34 (GMT)
committer	Swift Review <review@swift.im>	2013-01-13 10:36:26 (GMT)
commit	f3bc816af1b0d61452de973963e453bf3b3f95a2 (patch)
tree	e895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/spirit/home
parent	188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff)
download	swift-contrib-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip swift-contrib-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2