Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r68873 - in sandbox/local/libs/local: doc/qbk example params_name params_name/aux_ params_name/aux_/preprocessor params_name/aux_/preprocessor/keyword params_name/aux_/preprocessor/sign params_name/aux_/preprocessor/sign/params_ simpler_syntax
From: lorcaminiti_at_[hidden]
Date: 2011-02-14 17:06:04

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r68874 - trunk/boost/random"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r68872 - in trunk: boost/random libs/random/doc libs/random/performance"

Author: lcaminiti
Date: 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
New Revision: 68873
URL: http://svn.boost.org/trac/boost/changeset/68873

Log:
Started new macro parsers.
Added:
   sandbox/local/libs/local/doc/qbk/rationale.00.qbk (contents, props changed)
   sandbox/local/libs/local/example/00.cpp (contents, props changed)
   sandbox/local/libs/local/params_name/
   sandbox/local/libs/local/params_name/00.cpp (contents, props changed)
   sandbox/local/libs/local/params_name/02.cpp (contents, props changed)
   sandbox/local/libs/local/params_name/aux_/
   sandbox/local/libs/local/params_name/aux_/preprocessor/
   sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/
   sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/bind.hpp (contents, props changed)
   sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/const_bind.hpp (contents, props changed)
   sandbox/local/libs/local/params_name/aux_/preprocessor/sign/
   sandbox/local/libs/local/params_name/aux_/preprocessor/sign/params_/
   sandbox/local/libs/local/params_name/aux_/preprocessor/sign/params_/is_void.hpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/01.cpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/02.cpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/concepts.00.cpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/concepts_c99.00.cpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/factorial_nomacros.07.cpp (contents, props changed)
   sandbox/local/libs/local/simpler_syntax/pp_keyword.01.cpp (contents, props changed)
Text files modified:
   sandbox/local/libs/local/simpler_syntax/00.cpp | 12 +---------
   sandbox/local/libs/local/simpler_syntax/TODO.txt | 42 +++++++++++++++++++++++++++++++++++++++
   sandbox/local/libs/local/simpler_syntax/jamfile.jam | 2
   3 files changed, 44 insertions(+), 12 deletions(-)

Added: sandbox/local/libs/local/doc/qbk/rationale.00.qbk
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/doc/qbk/rationale.00.qbk 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,167 @@
+
+[section:Rationale Appendix: Rationale]
+
+This section discusses rationale behind library design decisions in addition to the rationale already provided throughout the rationale footnotes in the rest of this documentation.
+
+[section Parenthesized Syntax Rationale]
+
+This section discusses the rationale behind parenthesized syntax design decisions.
+
+[section C99 Preprocessor]
+
+The C99 preprocessor (and therefore the C++0x preprocessor) allows for additional features like specifying empty macro parameters and variadic macro parameters which are not supported by the ISO C++ standard preprocessor.
+The additional features of the C99 preprocessor can be used to simplify the parenthesized syntax mainly by removing extra parenthesis and making it look more like normal C++ syntax.
+
+Most (and maybe all) modern compilers support the C99 preprocessor at this time and all new C++0x compilers will support the C99 preprocessor in the future.
+Therefore, the library macros have been programmed to automatically detect the presence of the C99 preprocessor and accept the simplified parenthesized syntax in these cases.
+The same macro will only accept the parenthesized syntax on non C99 preprocessor but will accept both the parenthesized syntax and the simplified parenthesized syntax on C99 preprocessors.
+This way, programmers that can afford to write C99 specific code can benefit from the simplifications of the parenthesized syntax.
+
+[endsect]
+
+[section Parameter Type and Name Separation]
+
+C++ allows to specify parameter names within function types:
+
+ void (int x, double& y)
+
+Therefore, the parenthesized syntax for local functions does not have to separate the function parameter type and name tokens:
+
+[table Parameter Types and Names
+[ [Normal C++ Syntax] [C++ Parenthesized Syntax] [C99-Only Parenthesized Syntax] ]
+[ [
+`void f(int x, double&y)`
+] [
+`(void) (f)( (int x) (double& y) ) // Is this better than its general version below selected by the authors? Local functions don't need the generality...`
+] [
+`(void) (f)(int x, double& y) // Authors' choice.`
+] ]
+]
+
+Note that a more general form of the parenthesized syntax would have been instead:
+[table Separated Parameter Types and Names
+[ [Normal C++ Syntax] [C++ Parenthesized Syntax] [C99-Only Parenthesized Syntax] ]
+[ [
+`void f(int x, double& y)`
+] [
+`(void) (f)( (int)(x) (double&)(y) ) // Authors' choice.`
+] [
+`(void) (f)(int, x, double&, y)` /-or-/
+
+`(void) (f)( (int, x) , (double&, y) )` /-or-/
+
+`(void) (f)( (int)(x) , (double&)(y) )`
+] ]
+]
+
+This more general form makes available the parameter types and names as separate tokens for preprocessor metaprogramming.
+In fact, there is no way for the preprocessor to split `(int x)` into the parameter type `int` and name `x` while it can split `(int)(x)`.
+The parameter types can be split at compile-time (for example to force some parameters to be constant, references, etc):
+
+ typedef arg_type<void (int x, double& y), 0>::type arg_type0; // int
+ typedef arg_type<void (int x, double& y), 1>::type arg_type1; // double&
+
+But the parameter name `x` remains inaccessible as a token separately from its type.
+However, local function do not need to access parameter types separately from their types so this lack of generality is not an issue for local function and the less general syntax (e.g., `(int x)`) is preferred over the more general one (e.g., `(int)(x)`) because it is simpler as it uses a smaller number of parenthesis and resembles more closely the normal C++ syntax for function parameters.
+
+[note *Overloaded functions.*
+An example where parameter names need to be accessed separately from their types is to support overloading.
+For example, if the macro need to expand to support code for an overloaded function, they might need to generate unique identifiers for symbols within the support code.
+Assume also `__LINE__` cannot be used in this context because the unique identifiers need to be referred by another macro expanding on a different line (so the unique identifier need to be generated upon the function syntactic elements -- function name, parameter names, etc).
+Such identifiers cannot simply use the function name because the same function name is used multiple times when the function is overloaded and therefore the identifiers will not be unique.
+The parameter names can be concatenated by the preprocessor together with the function name to generate such unique identifiers (with the limitation that overloaded function need to used different parameter names and not just different parameter types).
+]
+
+[endsect]
+
+[section Empty Function Parameters]
+
+The C++ preprocessor does not allow to specify an empty macro parameter as a consequence preprocessor sequences cannot contain empty elements `()`.
+Therefore the following parenthesized syntax for a function with no parameter `void f()` is not valid for the C++ preprocessor:
+
+ (void) (f)() // Error, cannot use empty `()`.
+
+This syntax is instead valid for the C99 preprocessor because it can instead accept empty macro parameter.
+
+C++ also allow to specify an empty parameter list using `void`:
+
+ void f(void)
+
+This leads to the valid parenthesized syntax:
+
+ (void) (f)( (void) )
+
+In summary:
+
+[table Empty Function Parameters
+[ [Normal C++ Syntax] [C++ Parenthesized Syntax] [C99-Only Parenthesized Syntax] ]
+[ [
+`void f()`
+] [
+`(void) (f)( (void) ) // Authors' choice.`
+] [
+`(void) (f)() // Authors' choice.`
+] ]
+]
+
+[endsect]
+
+[section Default Parameter Values]
+
+C++ does not allow to specify default parameter values within function types thus the following is not valid:
+
+ void (int x = -1, double y = -1.23) // Error, can't specify default parameters within function types.
+
+Therefore, the following parenthesized syntax cannot be used:
+
+ (void) (f)( (int x = -1) (double y = -1.23) )
+
+Because:
+
+# It does not allow to strip the default parameter values from the parameter type and name in order to construct and manipulate the local function type.
+# Default parameter values are not part of the type so it is not possible to program a metafunction that counts the number of default parameter values at compile-time but such information is also needed by the local functions in order to properly support default parameters.
+[footnote
+Specifically, the number of default parameter value is needed at compile-time to instantiate the proper `function_ref<typename F, size_t default_parameter_count` template to hold the local function.
+The `function_ref` functor is needed to implement the trick that allows local functions to be passed as template parameters (see [@http://lists.boost.org/Archives/boost/2010/09/170888.php]).
+]
+
+Default parameters can be separated by the rest of the parameter expression using:
+
+ (void) (f)( (int x)(default -1) (double y)(default -1.23) )
+
+Note that the `=` symbol needs to be replaced with the alphanumeric keyword `default` because parenthesized syntax elements cannot start with a non alphanumeric symbol like `=`.
+[footnote
+This is because the parenthesized syntax needs to check if its token matches a keyword like `void`, `inline`, etc.
+This checking is done by concatenating from the front the token with a special library-defined symbol that generates a new macro that will ultimately expand to `1` if and only if the element matches the searched keyword.
+The preprocessor does not allow to concatenate non-alphanumeric tokens so the parenthesized syntax tokens cannot start with a non-alphanumeric token otherwise the concatenation will generate a preprocessor error (see [@http://lists.boost.org/Archives/boost/2010/08/169859.php]).
+]
+
+For C99, some or all the parenthesis can be replaced by commas.
+
+[table Default Parameter Values
+[ [Normal C++ Syntax] [C++ Parenthesized Syntax] [C99-Only Parenthesized Syntax] ]
+[ [
+`void f(inx x = -1, double y = -1.23)`
+] [
+`(void) (f)( (int x)(default -1) (double y)(default -1.23) )`
+] [
+`(void) (f)(int x, default -1, double y, default -1.23)` /-or-/ `// Authors' choice.`
+
+`(void) (f)( (int x, default -1) , (double y, default -1.23) )` /-or-/
+
+`(void) (f)( (int x)(default -1) , (double y)(default -1.23) )`
+] ]
+]
+
+[section Function Name, Result, Inline, Etc]
+[endsect]
+
+[section Variable Binding]
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[endsect]
+

Added: sandbox/local/libs/local/example/00.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/example/00.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,302803 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning( disable : 4503 )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef __w64 unsigned int uintptr_t;
+
+
+
+
+
+
+
+
+typedef char * va_list;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef __w64 unsigned int size_t;
+
+
+
+
+
+
+typedef size_t rsize_t;
+
+
+
+
+
+
+
+
+typedef __w64 int intptr_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef __w64 int ptrdiff_t;
+
+
+
+
+
+
+
+
+
+
+typedef unsigned short wint_t;
+typedef unsigned short wctype_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("This name was supported during some Whidbey pre-releases. Instead, use the standard name errno_t.")) typedef int errcode;
+
+
+
+
+typedef int errno_t;
+
+
+
+typedef __w64 long __time32_t;
+
+
+
+
+
+typedef __int64 __time64_t;
+
+
+
+
+
+
+
+
+typedef __time64_t time_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct threadlocaleinfostruct;
+struct threadmbcinfostruct;
+typedef struct threadlocaleinfostruct * pthreadlocinfo;
+typedef struct threadmbcinfostruct * pthreadmbcinfo;
+struct __lc_time_data;
+
+typedef struct localeinfo_struct
+{
+ pthreadlocinfo locinfo;
+ pthreadmbcinfo mbcinfo;
+} _locale_tstruct, *_locale_t;
+
+
+typedef struct tagLC_ID {
+ unsigned short wLanguage;
+ unsigned short wCountry;
+ unsigned short wCodePage;
+} LC_ID, *LPLC_ID;
+
+
+
+
+typedef struct threadlocaleinfostruct {
+ int refcount;
+ unsigned int lc_codepage;
+ unsigned int lc_collate_cp;
+ unsigned long lc_handle[6];
+ LC_ID lc_id[6];
+ struct {
+ char *locale;
+ wchar_t *wlocale;
+ int *refcount;
+ int *wrefcount;
+ } lc_category[6];
+ int lc_clike;
+ int mb_cur_max;
+ int * lconv_intl_refcount;
+ int * lconv_num_refcount;
+ int * lconv_mon_refcount;
+ struct lconv * lconv;
+ int * ctype1_refcount;
+ unsigned short * ctype1;
+ const unsigned short * pctype;
+ const unsigned char * pclmap;
+ const unsigned char * pcumap;
+ struct __lc_time_data * lc_time_curr;
+} threadlocinfo;
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma comment(lib,"libcpmt")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+typedef bool _Bool;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef __int64 _Longlong;
+typedef unsigned __int64 _ULonglong;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4412)
+class _Lockit
+ {
+public:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ explicit __thiscall _Lockit();
+ explicit __thiscall _Lockit(int);
+ __thiscall ~_Lockit();
+
+
+ static void __cdecl _Lockit_ctor(int);
+ static void __cdecl _Lockit_dtor(int);
+
+private:
+ static void __cdecl _Lockit_ctor(_Lockit *);
+ static void __cdecl _Lockit_ctor(_Lockit *, int);
+ static void __cdecl _Lockit_dtor(_Lockit *);
+
+ _Lockit(const _Lockit&);
+ _Lockit& operator=(const _Lockit&);
+
+ int _Locktype;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class _Mutex
+ {
+public:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ __thiscall _Mutex();
+ __thiscall ~_Mutex();
+ void __thiscall _Lock();
+ void __thiscall _Unlock();
+
+
+private:
+ static void __cdecl _Mutex_ctor(_Mutex *);
+ static void __cdecl _Mutex_dtor(_Mutex *);
+ static void __cdecl _Mutex_Lock(_Mutex *);
+ static void __cdecl _Mutex_Unlock(_Mutex *);
+
+ _Mutex(const _Mutex&);
+ _Mutex& operator=(const _Mutex&);
+ void *_Mtx;
+
+
+
+
+
+
+
+
+
+
+
+ };
+
+class _Init_locks
+ {
+public:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ __thiscall _Init_locks();
+ __thiscall ~_Init_locks();
+
+
+private:
+ static void __cdecl _Init_locks_ctor(_Init_locks *);
+ static void __cdecl _Init_locks_dtor(_Init_locks *);
+
+
+
+
+
+
+
+
+
+
+
+ };
+#pragma warning(pop)
+}
+
+
+
+
+
+
+
+
+ void __cdecl _Atexit(void (__cdecl *)(void));
+
+typedef int _Mbstatet;
+
+
+
+
+
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern int * __cdecl _errno(void);
+
+
+errno_t __cdecl _set_errno( int _Value);
+errno_t __cdecl _get_errno( int * _Value);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern unsigned long __cdecl __threadid(void);
+
+ extern uintptr_t __cdecl __threadhandle(void);
+
+
+
+
+}
+
+
+
+
+
+
+
+namespace std {
+using ::ptrdiff_t; using ::size_t;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct _iobuf {
+ char *_ptr;
+ int _cnt;
+ char *_base;
+ int _flag;
+ int _file;
+ int _charbuf;
+ int _bufsiz;
+ char *_tmpfname;
+ };
+typedef struct _iobuf FILE;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FILE * __cdecl __iob_func(void);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef __int64 fpos_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl _filbuf( FILE * _File );
+ int __cdecl _flsbuf( int _Ch, FILE * _File);
+
+
+
+
+ FILE * __cdecl _fsopen( const char * _Filename, const char * _Mode, int _ShFlag);
+
+
+ void __cdecl clearerr( FILE * _File);
+ errno_t __cdecl clearerr_s( FILE * _File );
+ int __cdecl fclose( FILE * _File);
+ int __cdecl _fcloseall(void);
+
+
+
+
+ FILE * __cdecl _fdopen( int _FileHandle, const char * _Mode);
+
+
+ int __cdecl feof( FILE * _File);
+ int __cdecl ferror( FILE * _File);
+ int __cdecl fflush( FILE * _File);
+ int __cdecl fgetc( FILE * _File);
+ int __cdecl _fgetchar(void);
+ int __cdecl fgetpos( FILE * _File , fpos_t * _Pos);
+ char * __cdecl fgets( char * _Buf, int _MaxCount, FILE * _File);
+
+
+
+
+ int __cdecl _fileno( FILE * _File);
+
+
+
+
+
+
+
+ char * __cdecl _tempnam( const char * _DirName, const char * _FilePrefix);
+
+
+
+
+
+ int __cdecl _flushall(void);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "fopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) FILE * __cdecl fopen( const char * _Filename, const char * _Mode);
+
+ errno_t __cdecl fopen_s( FILE ** _File, const char * _Filename, const char * _Mode);
+
+ int __cdecl fprintf( FILE * _File, const char * _Format, ...);
+ int __cdecl fprintf_s( FILE * _File, const char * _Format, ...);
+ int __cdecl fputc( int _Ch, FILE * _File);
+ int __cdecl _fputchar( int _Ch);
+ int __cdecl fputs( const char * _Str, FILE * _File);
+ size_t __cdecl fread( void * _DstBuf, size_t _ElementSize, size_t _Count, FILE * _File);
+ size_t __cdecl fread_s( void * _DstBuf, size_t _DstSize, size_t _ElementSize, size_t _Count, FILE * _File);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "freopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) FILE * __cdecl freopen( const char * _Filename, const char * _Mode, FILE * _File);
+
+ errno_t __cdecl freopen_s( FILE ** _File, const char * _Filename, const char * _Mode, FILE * _OldFile);
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "fscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl fscanf( FILE * _File, const char * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_fscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _fscanf_l( FILE * _File, const char * _Format, _locale_t _Locale, ...);
+
+ int __cdecl fscanf_s( FILE * _File, const char * _Format, ...);
+
+ int __cdecl _fscanf_s_l( FILE * _File, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl fsetpos( FILE * _File, const fpos_t * _Pos);
+ int __cdecl fseek( FILE * _File, long _Offset, int _Origin);
+ long __cdecl ftell( FILE * _File);
+
+ int __cdecl _fseeki64( FILE * _File, __int64 _Offset, int _Origin);
+ __int64 __cdecl _ftelli64( FILE * _File);
+
+ size_t __cdecl fwrite( const void * _Str, size_t _Size, size_t _Count, FILE * _File);
+ int __cdecl getc( FILE * _File);
+ int __cdecl getchar(void);
+ int __cdecl _getmaxstdio(void);
+
+ char * __cdecl gets_s( char * _Buf, rsize_t _Size);
+
+extern "C++" { template <size_t _Size> inline char * __cdecl gets_s( char (&_Buffer)[_Size]) { return gets_s(_Buffer, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "gets_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl gets( char *_Buffer);
+ int __cdecl _getw( FILE * _File);
+
+
+ void __cdecl perror( const char * _ErrMsg);
+
+ int __cdecl _pclose( FILE * _File);
+ FILE * __cdecl _popen( const char * _Command, const char * _Mode);
+ int __cdecl printf( const char * _Format, ...);
+ int __cdecl printf_s( const char * _Format, ...);
+ int __cdecl putc( int _Ch, FILE * _File);
+ int __cdecl putchar( int _Ch);
+ int __cdecl puts( const char * _Str);
+ int __cdecl _putw( int _Word, FILE * _File);
+
+
+ int __cdecl remove( const char * _Filename);
+ int __cdecl rename( const char * _OldFilename, const char * _NewFilename);
+ int __cdecl _unlink( const char * _Filename);
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_unlink" ". See online help for details.")) int __cdecl unlink( const char * _Filename);
+
+
+ void __cdecl rewind( FILE * _File);
+ int __cdecl _rmtmp(void);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "scanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl scanf( const char * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_scanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _scanf_l( const char * _Format, _locale_t _Locale, ...);
+
+ int __cdecl scanf_s( const char * _Format, ...);
+
+ int __cdecl _scanf_s_l( const char * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "setvbuf" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl setbuf( FILE * _File, char * _Buffer);
+ int __cdecl _setmaxstdio( int _Max);
+ unsigned int __cdecl _set_output_format( unsigned int _Format);
+ unsigned int __cdecl _get_output_format(void);
+ int __cdecl setvbuf( FILE * _File, char * _Buf, int _Mode, size_t _Size);
+ int __cdecl _snprintf_s( char * _DstBuf, size_t _DstSize, size_t _MaxCount, const char * _Format, ...);
+extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline int __cdecl _snprintf_s( char (&_Dest)[_Size], size_t _Size, const char * _Format, ...) { va_list _ArgList; ( _ArgList = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) ); return _vsnprintf_s(_Dest, _Size, _Size, _Format, _ArgList); } __pragma(warning(pop)); }
+ int __cdecl sprintf_s( char * _DstBuf, size_t _DstSize, const char * _Format, ...);
+extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline int __cdecl sprintf_s( char (&_Dest)[_Size], const char * _Format, ...) { va_list _ArgList; ( _ArgList = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) ); return vsprintf_s(_Dest, _Size, _Format, _ArgList); } __pragma(warning(pop)); }
+ int __cdecl _scprintf( const char * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "sscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl sscanf( const char * _Src, const char * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_sscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _sscanf_l( const char * _Src, const char * _Format, _locale_t _Locale, ...);
+
+ int __cdecl sscanf_s( const char * _Src, const char * _Format, ...);
+
+ int __cdecl _sscanf_s_l( const char * _Src, const char * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snscanf( const char * _Src, size_t _MaxCount, const char * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snscanf_l( const char * _Src, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _snscanf_s( const char * _Src, size_t _MaxCount, const char * _Format, ...);
+ int __cdecl _snscanf_s_l( const char * _Src, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpfile_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) FILE * __cdecl tmpfile(void);
+
+ errno_t __cdecl tmpfile_s( FILE ** _File);
+ errno_t __cdecl tmpnam_s( char * _Buf, rsize_t _Size);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl tmpnam_s( char (&_Buf)[_Size]) { return tmpnam_s(_Buf, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpnam_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl tmpnam( char *_Buffer);
+ int __cdecl ungetc( int _Ch, FILE * _File);
+ int __cdecl vfprintf( FILE * _File, const char * _Format, va_list _ArgList);
+ int __cdecl vfprintf_s( FILE * _File, const char * _Format, va_list _ArgList);
+ int __cdecl vprintf( const char * _Format, va_list _ArgList);
+ int __cdecl vprintf_s( const char * _Format, va_list _ArgList);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "vsnprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl vsnprintf( char * _DstBuf, size_t _MaxCount, const char * _Format, va_list _ArgList);
+ int __cdecl vsnprintf_s( char * _DstBuf, size_t _DstSize, size_t _MaxCount, const char * _Format, va_list _ArgList);
+ int __cdecl _vsnprintf_s( char * _DstBuf, size_t _DstSize, size_t _MaxCount, const char * _Format, va_list _ArgList);
+extern "C++" { template <size_t _Size> inline int __cdecl _vsnprintf_s( char (&_Dest)[_Size], size_t _Size, const char * _Format, va_list _Args) { return _vsnprintf_s(_Dest, _Size, _Size, _Format, _Args); } }
+#pragma warning(push)
+#pragma warning(disable:4793)
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snprintf( char *_Dest, size_t _Count, const char * _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _vsnprintf( char *_Dest, size_t _Count, const char * _Format, va_list _Args);
+#pragma warning(pop)
+ int __cdecl vsprintf_s( char * _DstBuf, size_t _Size, const char * _Format, va_list _ArgList);
+extern "C++" { template <size_t _Size> inline int __cdecl vsprintf_s( char (&_Dest)[_Size], const char * _Format, va_list _Args) { return vsprintf_s(_Dest, _Size, _Format, _Args); } }
+#pragma warning(push)
+#pragma warning(disable:4793)
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "sprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl sprintf( char *_Dest, const char * _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "vsprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl vsprintf( char *_Dest, const char * _Format, va_list _Args);
+#pragma warning(pop)
+ int __cdecl _vscprintf( const char * _Format, va_list _ArgList);
+ int __cdecl _snprintf_c( char * _DstBuf, size_t _MaxCount, const char * _Format, ...);
+ int __cdecl _vsnprintf_c( char *_DstBuf, size_t _MaxCount, const char * _Format, va_list _ArgList);
+
+ int __cdecl _fprintf_p( FILE * _File, const char * _Format, ...);
+ int __cdecl _printf_p( const char * _Format, ...);
+ int __cdecl _sprintf_p( char * _Dst, size_t _MaxCount, const char * _Format, ...);
+ int __cdecl _vfprintf_p( FILE * _File, const char * _Format, va_list _ArgList);
+ int __cdecl _vprintf_p( const char * _Format, va_list _ArgList);
+ int __cdecl _vsprintf_p( char * _Dst, size_t _MaxCount, const char * _Format, va_list _ArgList);
+ int __cdecl _scprintf_p( const char * _Format, ...);
+ int __cdecl _vscprintf_p( const char * _Format, va_list _ArgList);
+ int __cdecl _set_printf_count_output( int _Value);
+ int __cdecl _get_printf_count_output();
+
+ int __cdecl _printf_l( const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _printf_p_l( const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _printf_s_l( const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _vprintf_l( const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vprintf_p_l( const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vprintf_s_l( const char * _Format, _locale_t _Locale, va_list _ArgList);
+
+ int __cdecl _fprintf_l( FILE * _File, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _fprintf_p_l( FILE * _File, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _fprintf_s_l( FILE * _File, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _vfprintf_l( FILE * _File, const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vfprintf_p_l( FILE * _File, const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vfprintf_s_l( FILE * _File, const char * _Format, _locale_t _Locale, va_list _ArgList);
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_sprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _sprintf_l( char * _DstBuf, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _sprintf_p_l( char * _DstBuf, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _sprintf_s_l( char * _DstBuf, size_t _DstSize, const char * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _vsprintf_l( char * _DstBuf, const char * _Format, _locale_t, va_list _ArgList);
+ int __cdecl _vsprintf_p_l( char * _DstBuf, size_t _MaxCount, const char* _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vsprintf_s_l( char * _DstBuf, size_t _DstSize, const char * _Format, _locale_t _Locale, va_list _ArgList);
+
+ int __cdecl _scprintf_l( const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _scprintf_p_l( const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _vscprintf_l( const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vscprintf_p_l( const char * _Format, _locale_t _Locale, va_list _ArgList);
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snprintf_l( char * _DstBuf, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _snprintf_c_l( char * _DstBuf, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+ int __cdecl _snprintf_s_l( char * _DstBuf, size_t _DstSize, size_t _MaxCount, const char * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _vsnprintf_l( char * _DstBuf, size_t _MaxCount, const char * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vsnprintf_c_l( char * _DstBuf, size_t _MaxCount, const char *, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vsnprintf_s_l( char * _DstBuf, size_t _DstSize, size_t _MaxCount, const char* _Format, _locale_t _Locale, va_list _ArgList);
+
+
+
+
+
+
+
+
+
+
+
+
+ FILE * __cdecl _wfsopen( const wchar_t * _Filename, const wchar_t * _Mode, int _ShFlag);
+
+
+ wint_t __cdecl fgetwc( FILE * _File);
+ wint_t __cdecl _fgetwchar(void);
+ wint_t __cdecl fputwc( wchar_t _Ch, FILE * _File);
+ wint_t __cdecl _fputwchar( wchar_t _Ch);
+ wint_t __cdecl getwc( FILE * _File);
+ wint_t __cdecl getwchar(void);
+ wint_t __cdecl putwc( wchar_t _Ch, FILE * _File);
+ wint_t __cdecl putwchar( wchar_t _Ch);
+ wint_t __cdecl ungetwc( wint_t _Ch, FILE * _File);
+
+ wchar_t * __cdecl fgetws( wchar_t * _Dst, int _SizeInWords, FILE * _File);
+ int __cdecl fputws( const wchar_t * _Str, FILE * _File);
+ wchar_t * __cdecl _getws_s( wchar_t * _Str, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline wchar_t * __cdecl _getws_s( wchar_t (&_String)[_Size]) { return _getws_s(_String, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_getws_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _getws( wchar_t *_String);
+ int __cdecl _putws( const wchar_t * _Str);
+
+ int __cdecl fwprintf( FILE * _File, const wchar_t * _Format, ...);
+ int __cdecl fwprintf_s( FILE * _File, const wchar_t * _Format, ...);
+ int __cdecl wprintf( const wchar_t * _Format, ...);
+ int __cdecl wprintf_s( const wchar_t * _Format, ...);
+ int __cdecl _scwprintf( const wchar_t * _Format, ...);
+ int __cdecl vfwprintf( FILE * _File, const wchar_t * _Format, va_list _ArgList);
+ int __cdecl vfwprintf_s( FILE * _File, const wchar_t * _Format, va_list _ArgList);
+ int __cdecl vwprintf( const wchar_t * _Format, va_list _ArgList);
+ int __cdecl vwprintf_s( const wchar_t * _Format, va_list _ArgList);
+
+ int __cdecl swprintf_s( wchar_t * _Dst, size_t _SizeInWords, const wchar_t * _Format, ...);
+extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline int __cdecl swprintf_s( wchar_t (&_Dest)[_Size], const wchar_t * _Format, ...) { va_list _ArgList; ( _ArgList = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) ); return vswprintf_s(_Dest, _Size, _Format, _ArgList); } __pragma(warning(pop)); }
+ int __cdecl vswprintf_s( wchar_t * _Dst, size_t _SizeInWords, const wchar_t * _Format, va_list _ArgList);
+extern "C++" { template <size_t _Size> inline int __cdecl vswprintf_s( wchar_t (&_Dest)[_Size], const wchar_t * _Format, va_list _Args) { return vswprintf_s(_Dest, _Size, _Format, _Args); } }
+
+ int __cdecl _swprintf_c( wchar_t * _DstBuf, size_t _SizeInWords, const wchar_t * _Format, ...);
+ int __cdecl _vswprintf_c( wchar_t * _DstBuf, size_t _SizeInWords, const wchar_t * _Format, va_list _ArgList);
+
+ int __cdecl _snwprintf_s( wchar_t * _DstBuf, size_t _DstSizeInWords, size_t _MaxCount, const wchar_t * _Format, ...);
+extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline int __cdecl _snwprintf_s( wchar_t (&_Dest)[_Size], size_t _Count, const wchar_t * _Format, ...) { va_list _ArgList; ( _ArgList = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) ); return _vsnwprintf_s(_Dest, _Size, _Count, _Format, _ArgList); } __pragma(warning(pop)); }
+ int __cdecl _vsnwprintf_s( wchar_t * _DstBuf, size_t _DstSizeInWords, size_t _MaxCount, const wchar_t * _Format, va_list _ArgList);
+extern "C++" { template <size_t _Size> inline int __cdecl _vsnwprintf_s( wchar_t (&_Dest)[_Size], size_t _Count, const wchar_t * _Format, va_list _Args) { return _vsnwprintf_s(_Dest, _Size, _Count, _Format, _Args); } }
+#pragma warning(push)
+#pragma warning(disable:4793)
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snwprintf( wchar_t *_Dest, size_t _Count, const wchar_t * _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _vsnwprintf( wchar_t *_Dest, size_t _Count, const wchar_t * _Format, va_list _Args);
+#pragma warning(pop)
+
+ int __cdecl _fwprintf_p( FILE * _File, const wchar_t * _Format, ...);
+ int __cdecl _wprintf_p( const wchar_t * _Format, ...);
+ int __cdecl _vfwprintf_p( FILE * _File, const wchar_t * _Format, va_list _ArgList);
+ int __cdecl _vwprintf_p( const wchar_t * _Format, va_list _ArgList);
+ int __cdecl _swprintf_p( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, ...);
+ int __cdecl _vswprintf_p( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, va_list _ArgList);
+ int __cdecl _scwprintf_p( const wchar_t * _Format, ...);
+ int __cdecl _vscwprintf_p( const wchar_t * _Format, va_list _ArgList);
+
+ int __cdecl _wprintf_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _wprintf_p_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _wprintf_s_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vwprintf_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vwprintf_p_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vwprintf_s_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+ int __cdecl _fwprintf_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _fwprintf_p_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _fwprintf_s_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vfwprintf_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vfwprintf_p_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vfwprintf_s_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+ int __cdecl _swprintf_c_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _swprintf_p_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _swprintf_s_l( wchar_t * _DstBuf, size_t _DstSize, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vswprintf_c_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vswprintf_p_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vswprintf_s_l( wchar_t * _DstBuf, size_t _DstSize, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+ int __cdecl _scwprintf_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _scwprintf_p_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vscwprintf_p_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snwprintf_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _snwprintf_s_l( wchar_t * _DstBuf, size_t _DstSize, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _vsnwprintf_l( wchar_t * _DstBuf, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vsnwprintf_s_l( wchar_t * _DstBuf, size_t _DstSize, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4141 4996 4793)
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_swprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) int __cdecl _swprintf( wchar_t *_Dest, const wchar_t * _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "vswprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) int __cdecl _vswprintf( wchar_t *_Dest, const wchar_t * _Format, va_list _Args);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "__swprintf_l_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) int __cdecl __swprintf_l( wchar_t *_Dest, const wchar_t * _Format, _locale_t _Plocinfo, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vswprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) int __cdecl __vswprintf_l( wchar_t *_Dest, const wchar_t * _Format, _locale_t _Plocinfo, va_list _Args
);
+#pragma warning(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning( push )
+#pragma warning( disable : 4793 4412 )
+static __inline int swprintf(wchar_t * _String, size_t _Count, const wchar_t * _Format, ...)
+{
+ va_list _Arglist;
+ int _Ret;
+ ( _Arglist = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) );
+ _Ret = _vswprintf_c_l(_String, _Count, _Format, 0, _Arglist);
+ ( _Arglist = (va_list)0 );
+ return _Ret;
+}
+#pragma warning( pop )
+
+#pragma warning( push )
+#pragma warning( disable : 4412 )
+static __inline int __cdecl vswprintf(wchar_t * _String, size_t _Count, const wchar_t * _Format, va_list _Ap)
+{
+ return _vswprintf_c_l(_String, _Count, _Format, 0, _Ap);
+}
+#pragma warning( pop )
+
+
+
+
+#pragma warning( push )
+#pragma warning( disable : 4793 4412 )
+static __inline int _swprintf_l(wchar_t * _String, size_t _Count, const wchar_t * _Format, _locale_t _Plocinfo, ...)
+{
+ va_list _Arglist;
+ int _Ret;
+ ( _Arglist = (va_list)( &reinterpret_cast<const char &>(_Plocinfo) ) + ( (sizeof(_Plocinfo) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) );
+ _Ret = _vswprintf_c_l(_String, _Count, _Format, _Plocinfo, _Arglist);
+ ( _Arglist = (va_list)0 );
+ return _Ret;
+}
+#pragma warning( pop )
+
+#pragma warning( push )
+#pragma warning( disable : 4412 )
+static __inline int __cdecl _vswprintf_l(wchar_t * _String, size_t _Count, const wchar_t * _Format, _locale_t _Plocinfo, va_list _Ap)
+{
+ return _vswprintf_c_l(_String, _Count, _Format, _Plocinfo, _Ap);
+}
+#pragma warning( pop )
+
+
+#pragma warning( push )
+#pragma warning( disable : 4996 )
+
+#pragma warning( push )
+#pragma warning( disable : 4793 4141 )
+extern "C++" __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "swprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __inline int swprintf( wchar_t * _String, const wchar_t * _Format, ...)
+{
+ va_list _Arglist;
+ ( _Arglist = (va_list)( &reinterpret_cast<const char &>(_Format) ) + ( (sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) );
+ int _Ret = _vswprintf(_String, _Format, _Arglist);
+ ( _Arglist = (va_list)0 );
+ return _Ret;
+}
+#pragma warning( pop )
+
+#pragma warning( push )
+#pragma warning( disable : 4141 )
+extern "C++" __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "vswprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __inline int __cdecl vswprintf( wchar_t * _String, const wchar_t * _Format, va_list _Ap)
+{
+ return _vswprintf(_String, _Format, _Ap);
+}
+#pragma warning( pop )
+
+#pragma warning( push )
+#pragma warning( disable : 4793 4141 )
+extern "C++" __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_swprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __inline int _swprintf_l( wchar_t * _String, const wchar_t * _Format, _locale_t _Plocinfo, ...)
+{
+ va_list _Arglist;
+ ( _Arglist = (va_list)( &reinterpret_cast<const char &>(_Plocinfo) ) + ( (sizeof(_Plocinfo) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) );
+ int _Ret = __vswprintf_l(_String, _Format, _Plocinfo, _Arglist);
+ ( _Arglist = (va_list)0 );
+ return _Ret;
+}
+#pragma warning( pop )
+
+#pragma warning( push )
+#pragma warning( disable : 4141 )
+extern "C++" __declspec(deprecated("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vswprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __inline int __cdecl _vswprintf_l( wchar_t * _String, const wchar_t * _Format, _locale_t _Plocinfo, va_list _Ap)
+{
+ return __vswprintf_l(_String, _Format, _Plocinfo, _Ap);
+}
+#pragma warning( pop )
+
+#pragma warning( pop )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ wchar_t * __cdecl _wtempnam( const wchar_t * _Directory, const wchar_t * _FilePrefix);
+
+
+
+
+
+ int __cdecl _vscwprintf( const wchar_t * _Format, va_list _ArgList);
+ int __cdecl _vscwprintf_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "fwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl fwscanf( FILE * _File, const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_fwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _fwscanf_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, ...);
+
+ int __cdecl fwscanf_s( FILE * _File, const wchar_t * _Format, ...);
+
+ int __cdecl _fwscanf_s_l( FILE * _File, const wchar_t * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "swscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl swscanf( const wchar_t * _Src, const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_swscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _swscanf_l( const wchar_t * _Src, const wchar_t * _Format, _locale_t _Locale, ...);
+
+ int __cdecl swscanf_s( const wchar_t *_Src, const wchar_t * _Format, ...);
+
+ int __cdecl _swscanf_s_l( const wchar_t * _Src, const wchar_t * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snwscanf( const wchar_t * _Src, size_t _MaxCount, const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _snwscanf_l( const wchar_t * _Src, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _snwscanf_s( const wchar_t * _Src, size_t _MaxCount, const wchar_t * _Format, ...);
+ int __cdecl _snwscanf_s_l( const wchar_t * _Src, size_t _MaxCount, const wchar_t * _Format, _locale_t _Locale, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl wscanf( const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _wscanf_l( const wchar_t * _Format, _locale_t _Locale, ...);
+
+ int __cdecl wscanf_s( const wchar_t * _Format, ...);
+
+ int __cdecl _wscanf_s_l( const wchar_t * _Format, _locale_t _Locale, ...);
+
+ FILE * __cdecl _wfdopen( int _FileHandle , const wchar_t * _Mode);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wfopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) FILE * __cdecl _wfopen( const wchar_t * _Filename, const wchar_t * _Mode);
+ errno_t __cdecl _wfopen_s( FILE ** _File, const wchar_t * _Filename, const wchar_t * _Mode);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wfreopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) FILE * __cdecl _wfreopen( const wchar_t * _Filename, const wchar_t * _Mode, FILE * _OldFile);
+ errno_t __cdecl _wfreopen_s( FILE ** _File, const wchar_t * _Filename, const wchar_t * _Mode, FILE * _OldFile);
+
+
+
+ void __cdecl _wperror( const wchar_t * _ErrMsg);
+
+ FILE * __cdecl _wpopen( const wchar_t *_Command, const wchar_t * _Mode);
+ int __cdecl _wremove( const wchar_t * _Filename);
+ errno_t __cdecl _wtmpnam_s( wchar_t * _DstBuf, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wtmpnam_s( wchar_t (&_Buffer)[_Size]) { return _wtmpnam_s(_Buffer, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wtmpnam_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wtmpnam( wchar_t *_Buffer);
+
+ wint_t __cdecl _fgetwc_nolock( FILE * _File);
+ wint_t __cdecl _fputwc_nolock( wchar_t _Ch, FILE * _File);
+ wint_t __cdecl _ungetwc_nolock( wint_t _Ch, FILE * _File);
+
+
+
+
+
+
+
+inline wint_t __cdecl getwchar()
+ {return (fgetwc((&__iob_func()[0]))); }
+inline wint_t __cdecl putwchar(wchar_t _C)
+ {return (fputwc(_C, (&__iob_func()[1]))); }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ void __cdecl _lock_file( FILE * _File);
+ void __cdecl _unlock_file( FILE * _File);
+
+
+
+
+
+
+ int __cdecl _fclose_nolock( FILE * _File);
+ int __cdecl _fflush_nolock( FILE * _File);
+ size_t __cdecl _fread_nolock( void * _DstBuf, size_t _ElementSize, size_t _Count, FILE * _File);
+ size_t __cdecl _fread_nolock_s( void * _DstBuf, size_t _DstSize, size_t _ElementSize, size_t _Count, FILE * _File);
+ int __cdecl _fseek_nolock( FILE * _File, long _Offset, int _Origin);
+ long __cdecl _ftell_nolock( FILE * _File);
+ int __cdecl _fseeki64_nolock( FILE * _File, __int64 _Offset, int _Origin);
+ __int64 __cdecl _ftelli64_nolock( FILE * _File);
+ size_t __cdecl _fwrite_nolock( const void * _DstBuf, size_t _Size, size_t _Count, FILE * _File);
+ int __cdecl _ungetc_nolock( int _Ch, FILE * _File);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_tempnam" ". See online help for details.")) char * __cdecl tempnam( const char * _Directory, const char * _FilePrefix);
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fcloseall" ". See online help for details.")) int __cdecl fcloseall(void);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fdopen" ". See online help for details.")) FILE * __cdecl fdopen( int _FileHandle, const char * _Format);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fgetchar" ". See online help for details.")) int __cdecl fgetchar(void);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fileno" ". See online help for details.")) int __cdecl fileno( FILE * _File);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_flushall" ". See online help for details.")) int __cdecl flushall(void);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fputchar" ". See online help for details.")) int __cdecl fputchar( int _Ch);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_getw" ". See online help for details.")) int __cdecl getw( FILE * _File);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_putw" ". See online help for details.")) int __cdecl putw( int _Ch, FILE * _File);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_rmtmp" ". See online help for details.")) int __cdecl rmtmp(void);
+
+
+
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+using ::size_t; using ::fpos_t; using ::FILE;
+using ::clearerr; using ::fclose; using ::feof;
+using ::ferror; using ::fflush; using ::fgetc;
+using ::fgetpos; using ::fgets; using ::fopen;
+using ::fprintf; using ::fputc; using ::fputs;
+using ::fread; using ::freopen; using ::fscanf;
+using ::fseek; using ::fsetpos; using ::ftell;
+using ::fwrite; using ::getc; using ::getchar;
+using ::gets; using ::perror;
+using ::putc; using ::putchar;
+using ::printf; using ::puts; using ::remove;
+using ::rename; using ::rewind; using ::scanf;
+using ::setbuf; using ::setvbuf; using ::sprintf;
+using ::sscanf; using ::tmpfile; using ::tmpnam;
+using ::ungetc; using ::vfprintf; using ::vprintf;
+using ::vsprintf;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ void * __cdecl _memccpy( void * _Dst, const void * _Src, int _Val, size_t _MaxCount);
+ const void * __cdecl memchr( const void * _Buf , int _Val, size_t _MaxCount);
+ int __cdecl _memicmp( const void * _Buf1, const void * _Buf2, size_t _Size);
+ int __cdecl _memicmp_l( const void * _Buf1, const void * _Buf2, size_t _Size, _locale_t _Locale);
+ int __cdecl memcmp( const void * _Buf1, const void * _Buf2, size_t _Size);
+ void * __cdecl memcpy( void * _Dst, const void * _Src, size_t _Size);
+
+ errno_t __cdecl memcpy_s( void * _Dst, rsize_t _DstSize, const void * _Src, rsize_t _MaxCount);
+
+ void * __cdecl memset( void * _Dst, int _Val, size_t _Size);
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_memccpy" ". See online help for details.")) void * __cdecl memccpy( void * _Dst, const void * _Src, int _Val, size_t _Size);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_memicmp" ". See online help for details.")) int __cdecl memicmp( const void * _Buf1, const void * _Buf2, size_t _Size);
+
+
+
+
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_strset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strset( char * _Str, int _Val);
+ errno_t __cdecl _strset_s( char * _Dst, size_t _DstSize, int _Value);
+
+ errno_t __cdecl strcpy_s( char * _Dst, rsize_t _DstSize, const char * _Src);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl strcpy_s( char (&_Dest)[_Size], const char * _Source) { return strcpy_s(_Dest, _Size, _Source); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strcpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strcpy( char *_Dest, const char * _Source);
+
+ errno_t __cdecl strcat_s( char * _Dst, rsize_t _DstSize, const char * _Src);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl strcat_s( char (&_Dest)[_Size], const char * _Source) { return strcat_s(_Dest, _Size, _Source); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strcat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strcat( char *_Dest, const char * _Source);
+ int __cdecl strcmp( const char * _Str1, const char * _Str2);
+ size_t __cdecl strlen( const char * _Str);
+ size_t __cdecl strnlen( const char * _Str, size_t _MaxCount);
+
+static __inline size_t __cdecl strnlen_s( const char * _Str, size_t _MaxCount)
+{
+ return strnlen(_Str, _MaxCount);
+}
+
+
+ errno_t __cdecl memmove_s( void * _Dst, rsize_t _DstSize, const void * _Src, rsize_t _MaxCount);
+
+
+
+
+
+ void * __cdecl memmove( void * _Dst, const void * _Src, size_t _Size);
+
+
+
+
+
+
+
+ char * __cdecl _strdup( const char * _Src);
+
+
+
+
+
+ const char * __cdecl strchr( const char * _Str, int _Val);
+ int __cdecl _stricmp( const char * _Str1, const char * _Str2);
+ int __cdecl _strcmpi( const char * _Str1, const char * _Str2);
+ int __cdecl _stricmp_l( const char * _Str1, const char * _Str2, _locale_t _Locale);
+ int __cdecl strcoll( const char * _Str1, const char * _Str2);
+ int __cdecl _strcoll_l( const char * _Str1, const char * _Str2, _locale_t _Locale);
+ int __cdecl _stricoll( const char * _Str1, const char * _Str2);
+ int __cdecl _stricoll_l( const char * _Str1, const char * _Str2, _locale_t _Locale);
+ int __cdecl _strncoll ( const char * _Str1, const char * _Str2, size_t _MaxCount);
+ int __cdecl _strncoll_l( const char * _Str1, const char * _Str2, size_t _MaxCount, _locale_t _Locale);
+ int __cdecl _strnicoll ( const char * _Str1, const char * _Str2, size_t _MaxCount);
+ int __cdecl _strnicoll_l( const char * _Str1, const char * _Str2, size_t _MaxCount, _locale_t _Locale);
+ size_t __cdecl strcspn( const char * _Str, const char * _Control);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strerror( const char * _ErrMsg);
+ errno_t __cdecl _strerror_s( char * _Buf, size_t _SizeInBytes, const char * _ErrMsg);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _strerror_s( char (&_Buffer)[_Size], const char * _ErrorMessage) { return _strerror_s(_Buffer, _Size, _ErrorMessage); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strerror( int);
+
+ errno_t __cdecl strerror_s( char * _Buf, size_t _SizeInBytes, int _ErrNum);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl strerror_s( char (&_Buffer)[_Size], int _ErrorMessage) { return strerror_s(_Buffer, _Size, _ErrorMessage); } }
+ errno_t __cdecl _strlwr_s( char * _Str, size_t _Size);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _strlwr_s( char (&_String)[_Size]) { return _strlwr_s(_String, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strlwr( char *_String);
+ errno_t __cdecl _strlwr_s_l( char * _Str, size_t _Size, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _strlwr_s_l( char (&_String)[_Size], _locale_t _Locale) { return _strlwr_s_l(_String, _Size, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strlwr_l( char *_String, _locale_t _Locale);
+
+ errno_t __cdecl strncat_s( char * _Dst, rsize_t _DstSize, const char * _Src, rsize_t _MaxCount);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl strncat_s( char (&_Dest)[_Size], const char * _Source, size_t _Count) { return strncat_s(_Dest, _Size, _Source, _Count); } }
+#pragma warning(push)
+#pragma warning(disable:4609 6059)
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strncat( char *_Dest, const char * _Source, size_t _Count);
+#pragma warning(pop)
+
+
+
+ int __cdecl strncmp( const char * _Str1, const char * _Str2, size_t _MaxCount);
+
+ int __cdecl _strnicmp( const char * _Str1, const char * _Str2, size_t _MaxCount);
+ int __cdecl _strnicmp_l( const char * _Str1, const char * _Str2, size_t _MaxCount, _locale_t _Locale);
+
+ errno_t __cdecl strncpy_s( char * _Dst, rsize_t _DstSize, const char * _Src, rsize_t _MaxCount);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl strncpy_s( char (&_Dest)[_Size], const char * _Source, size_t _Count) { return strncpy_s(_Dest, _Size, _Source, _Count); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strncpy( char *_Dest, const char * _Source, size_t _Count);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strnset( char * _Str, int _Val, size_t _MaxCount);
+ errno_t __cdecl _strnset_s( char * _Str, size_t _Size, int _Val, size_t _MaxCount);
+ const char * __cdecl strpbrk( const char * _Str, const char * _Control);
+ const char * __cdecl strrchr( const char * _Str, int _Ch);
+ char * __cdecl _strrev( char * _Str);
+ size_t __cdecl strspn( const char * _Str, const char * _Control);
+ const char * __cdecl strstr( const char * _Str, const char * _SubStr);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "strtok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl strtok( char * _Str, const char * _Delim);
+
+ char * __cdecl strtok_s( char * _Str, const char * _Delim, char ** _Context);
+
+ errno_t __cdecl _strupr_s( char * _Str, size_t _Size);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _strupr_s( char (&_String)[_Size]) { return _strupr_s(_String, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strupr( char *_String);
+ errno_t __cdecl _strupr_s_l( char * _Str, size_t _Size, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _strupr_s_l( char (&_String)[_Size], _locale_t _Locale) { return _strupr_s_l(_String, _Size, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _strupr_l( char *_String, _locale_t _Locale);
+ size_t __cdecl strxfrm ( char * _Dst, const char * _Src, size_t _MaxCount);
+ size_t __cdecl _strxfrm_l( char * _Dst, const char * _Src, size_t _MaxCount, _locale_t _Locale);
+
+
+extern "C++" {
+
+
+inline char * __cdecl strchr( char * _Str, int _Ch)
+ { return (char*)strchr((const char*)_Str, _Ch); }
+inline char * __cdecl strpbrk( char * _Str, const char * _Control)
+ { return (char*)strpbrk((const char*)_Str, _Control); }
+inline char * __cdecl strrchr( char * _Str, int _Ch)
+ { return (char*)strrchr((const char*)_Str, _Ch); }
+inline char * __cdecl strstr( char * _Str, const char * _SubStr)
+ { return (char*)strstr((const char*)_Str, _SubStr); }
+
+
+
+inline void * __cdecl memchr( void * _Pv, int _C, size_t _N)
+ { return (void*)memchr((const void*)_Pv, _C, _N); }
+
+}
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strdup" ". See online help for details.")) char * __cdecl strdup( const char * _Src);
+
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strcmpi" ". See online help for details.")) int __cdecl strcmpi( const char * _Str1, const char * _Str2);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_stricmp" ". See online help for details.")) int __cdecl stricmp( const char * _Str1, const char * _Str2);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strlwr" ". See online help for details.")) char * __cdecl strlwr( char * _Str);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strnicmp" ". See online help for details.")) int __cdecl strnicmp( const char * _Str1, const char * _Str, size_t _MaxCount);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strnset" ". See online help for details.")) char * __cdecl strnset( char * _Str, int _Val, size_t _MaxCount);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strrev" ". See online help for details.")) char * __cdecl strrev( char * _Str);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strset" ". See online help for details.")) char * __cdecl strset( char * _Str, int _Val);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_strupr" ". See online help for details.")) char * __cdecl strupr( char * _Str);
+
+
+
+
+
+
+
+
+
+
+
+
+
+ wchar_t * __cdecl _wcsdup( const wchar_t * _Str);
+
+
+
+
+
+
+ errno_t __cdecl wcscat_s( wchar_t * _Dst, rsize_t _DstSize, const wchar_t * _Src);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcscat_s( wchar_t (&_Dest)[_Size], const wchar_t * _Source) { return wcscat_s(_Dest, _Size, _Source); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl wcscat( wchar_t *_Dest, const wchar_t * _Source);
+ const wchar_t * __cdecl wcschr( const wchar_t * _Str, wchar_t _Ch);
+ int __cdecl wcscmp( const wchar_t * _Str1, const wchar_t * _Str2);
+
+ errno_t __cdecl wcscpy_s( wchar_t * _Dst, rsize_t _DstSize, const wchar_t * _Src);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcscpy_s( wchar_t (&_Dest)[_Size], const wchar_t * _Source) { return wcscpy_s(_Dest, _Size, _Source); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl wcscpy( wchar_t *_Dest, const wchar_t * _Source);
+ size_t __cdecl wcscspn( const wchar_t * _Str, const wchar_t * _Control);
+ size_t __cdecl wcslen( const wchar_t * _Str);
+ size_t __cdecl wcsnlen( const wchar_t * _Src, size_t _MaxCount);
+
+static __inline size_t __cdecl wcsnlen_s( const wchar_t * _Src, size_t _MaxCount)
+{
+ return wcsnlen(_Src, _MaxCount);
+}
+
+
+ errno_t __cdecl wcsncat_s( wchar_t * _Dst, rsize_t _DstSize, const wchar_t * _Src, rsize_t _MaxCount);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcsncat_s( wchar_t (&_Dest)[_Size], const wchar_t * _Source, size_t _Count) { return wcsncat_s(_Dest, _Size, _Source, _Count); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl wcsncat( wchar_t *_Dest, const wchar_t * _Source, size_t _Count);
+ int __cdecl wcsncmp( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount);
+
+ errno_t __cdecl wcsncpy_s( wchar_t * _Dst, rsize_t _DstSize, const wchar_t * _Src, rsize_t _MaxCount);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcsncpy_s( wchar_t (&_Dest)[_Size], const wchar_t * _Source, size_t _Count) { return wcsncpy_s(_Dest, _Size, _Source, _Count); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl wcsncpy( wchar_t *_Dest, const wchar_t * _Source, size_t _Count);
+ const wchar_t * __cdecl wcspbrk( const wchar_t * _Str, const wchar_t * _Control);
+ const wchar_t * __cdecl wcsrchr( const wchar_t * _Str, wchar_t _Ch);
+ size_t __cdecl wcsspn( const wchar_t * _Str, const wchar_t * _Control);
+ const wchar_t * __cdecl wcsstr( const wchar_t * _Str, const wchar_t * _SubStr);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl wcstok( wchar_t * _Str, const wchar_t * _Delim);
+ wchar_t * __cdecl wcstok_s( wchar_t * _Str, const wchar_t * _Delim, wchar_t ** _Context);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcserror( int _ErrNum);
+ errno_t __cdecl _wcserror_s( wchar_t * _Buf, size_t _SizeInWords, int _ErrNum);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcserror_s( wchar_t (&_Buffer)[_Size], int _Error) { return _wcserror_s(_Buffer, _Size, _Error); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "__wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl __wcserror( const wchar_t * _Str);
+ errno_t __cdecl __wcserror_s( wchar_t * _Buffer, size_t _SizeInWords, const wchar_t * _ErrMsg);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl __wcserror_s( wchar_t (&_Buffer)[_Size], const wchar_t * _ErrorMessage) { return __wcserror_s(_Buffer, _Size, _ErrorMessage); } }
+
+ int __cdecl _wcsicmp( const wchar_t * _Str1, const wchar_t * _Str2);
+ int __cdecl _wcsicmp_l( const wchar_t * _Str1, const wchar_t * _Str2, _locale_t _Locale);
+ int __cdecl _wcsnicmp( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount);
+ int __cdecl _wcsnicmp_l( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount, _locale_t _Locale);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcsnset( wchar_t * _Str, wchar_t _Val, size_t _MaxCount);
+ errno_t __cdecl _wcsnset_s( wchar_t * _Dst, size_t _DstSizeInWords, wchar_t _Val, size_t _MaxCount);
+ wchar_t * __cdecl _wcsrev( wchar_t * _Str);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcsset( wchar_t * _Str, wchar_t _Val);
+ errno_t __cdecl _wcsset_s( wchar_t * _Str, size_t _SizeInWords, wchar_t _Val);
+
+ errno_t __cdecl _wcslwr_s( wchar_t * _Str, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcslwr_s( wchar_t (&_String)[_Size]) { return _wcslwr_s(_String, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcslwr( wchar_t *_String);
+ errno_t __cdecl _wcslwr_s_l( wchar_t * _Str, size_t _SizeInWords, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcslwr_s_l( wchar_t (&_String)[_Size], _locale_t _Locale) { return _wcslwr_s_l(_String, _Size, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcslwr_l( wchar_t *_String, _locale_t _Locale);
+ errno_t __cdecl _wcsupr_s( wchar_t * _Str, size_t _Size);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsupr_s( wchar_t (&_String)[_Size]) { return _wcsupr_s(_String, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcsupr( wchar_t *_String);
+ errno_t __cdecl _wcsupr_s_l( wchar_t * _Str, size_t _Size, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsupr_s_l( wchar_t (&_String)[_Size], _locale_t _Locale) { return _wcsupr_s_l(_String, _Size, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wcsupr_l( wchar_t *_String, _locale_t _Locale);
+ size_t __cdecl wcsxfrm( wchar_t * _Dst, const wchar_t * _Src, size_t _MaxCount);
+ size_t __cdecl _wcsxfrm_l( wchar_t * _Dst, const wchar_t *_Src, size_t _MaxCount, _locale_t _Locale);
+ int __cdecl wcscoll( const wchar_t * _Str1, const wchar_t * _Str2);
+ int __cdecl _wcscoll_l( const wchar_t * _Str1, const wchar_t * _Str2, _locale_t _Locale);
+ int __cdecl _wcsicoll( const wchar_t * _Str1, const wchar_t * _Str2);
+ int __cdecl _wcsicoll_l( const wchar_t * _Str1, const wchar_t *_Str2, _locale_t _Locale);
+ int __cdecl _wcsncoll( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount);
+ int __cdecl _wcsncoll_l( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount, _locale_t _Locale);
+ int __cdecl _wcsnicoll( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount);
+ int __cdecl _wcsnicoll_l( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount, _locale_t _Locale);
+
+
+
+
+extern "C++" {
+inline wchar_t * __cdecl wcschr( wchar_t *_Str, wchar_t _Ch)
+ {return ((wchar_t *)wcschr((const wchar_t *)_Str, _Ch)); }
+inline wchar_t * __cdecl wcspbrk( wchar_t *_Str, const wchar_t *_Control)
+ {return ((wchar_t *)wcspbrk((const wchar_t *)_Str, _Control)); }
+inline wchar_t * __cdecl wcsrchr( wchar_t *_Str, wchar_t _Ch)
+ {return ((wchar_t *)wcsrchr((const wchar_t *)_Str, _Ch)); }
+inline wchar_t * __cdecl wcsstr( wchar_t *_Str, const wchar_t *_SubStr)
+ {return ((wchar_t *)wcsstr((const wchar_t *)_Str, _SubStr)); }
+}
+
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsdup" ". See online help for details.")) wchar_t * __cdecl wcsdup( const wchar_t * _Str);
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsicmp" ". See online help for details.")) int __cdecl wcsicmp( const wchar_t * _Str1, const wchar_t * _Str2);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsnicmp" ". See online help for details.")) int __cdecl wcsnicmp( const wchar_t * _Str1, const wchar_t * _Str2, size_t _MaxCount);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsnset" ". See online help for details.")) wchar_t * __cdecl wcsnset( wchar_t * _Str, wchar_t _Val, size_t _MaxCount);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsrev" ". See online help for details.")) wchar_t * __cdecl wcsrev( wchar_t * _Str);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsset" ". See online help for details.")) wchar_t * __cdecl wcsset( wchar_t * _Str, wchar_t _Val);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcslwr" ". See online help for details.")) wchar_t * __cdecl wcslwr( wchar_t * _Str);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsupr" ". See online help for details.")) wchar_t * __cdecl wcsupr( wchar_t * _Str);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_wcsicoll" ". See online help for details.")) int __cdecl wcsicoll( const wchar_t * _Str1, const wchar_t * _Str2);
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+namespace std {
+using ::size_t; using ::memchr; using ::memcmp;
+using ::memcpy; using ::memmove; using ::memset;
+using ::strcat; using ::strchr; using ::strcmp;
+using ::strcoll; using ::strcpy; using ::strcspn;
+using ::strerror; using ::strlen; using ::strncat;
+using ::strncmp; using ::strncpy; using ::strpbrk;
+using ::strrchr; using ::strspn; using ::strstr;
+using ::strtok; using ::strxfrm;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef unsigned long _fsize_t;
+
+
+
+
+
+struct _wfinddata32_t {
+ unsigned attrib;
+ __time32_t time_create;
+ __time32_t time_access;
+ __time32_t time_write;
+ _fsize_t size;
+ wchar_t name[260];
+};
+
+
+
+struct _wfinddata32i64_t {
+ unsigned attrib;
+ __time32_t time_create;
+ __time32_t time_access;
+ __time32_t time_write;
+ __int64 size;
+ wchar_t name[260];
+};
+
+struct _wfinddata64i32_t {
+ unsigned attrib;
+ __time64_t time_create;
+ __time64_t time_access;
+ __time64_t time_write;
+ _fsize_t size;
+ wchar_t name[260];
+};
+
+struct _wfinddata64_t {
+ unsigned attrib;
+ __time64_t time_create;
+ __time64_t time_access;
+ __time64_t time_write;
+ __int64 size;
+ wchar_t name[260];
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const unsigned short * __cdecl __pctype_func(void);
+
+ extern const unsigned short *_pctype;
+
+
+
+
+
+
+
+
+
+
+ extern const unsigned short _wctype[];
+
+
+ const wctype_t * __cdecl __pwctype_func(void);
+
+ extern const wctype_t *_pwctype;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl iswalpha( wint_t _C);
+ int __cdecl _iswalpha_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswupper( wint_t _C);
+ int __cdecl _iswupper_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswlower( wint_t _C);
+ int __cdecl _iswlower_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswdigit( wint_t _C);
+ int __cdecl _iswdigit_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswxdigit( wint_t _C);
+ int __cdecl _iswxdigit_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswspace( wint_t _C);
+ int __cdecl _iswspace_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswpunct( wint_t _C);
+ int __cdecl _iswpunct_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswalnum( wint_t _C);
+ int __cdecl _iswalnum_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswprint( wint_t _C);
+ int __cdecl _iswprint_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswgraph( wint_t _C);
+ int __cdecl _iswgraph_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswcntrl( wint_t _C);
+ int __cdecl _iswcntrl_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswascii( wint_t _C);
+ int __cdecl isleadbyte( int _C);
+ int __cdecl _isleadbyte_l( int _C, _locale_t _Locale);
+
+ wint_t __cdecl towupper( wint_t _C);
+ wint_t __cdecl _towupper_l( wint_t _C, _locale_t _Locale);
+ wint_t __cdecl towlower( wint_t _C);
+ wint_t __cdecl _towlower_l( wint_t _C, _locale_t _Locale);
+ int __cdecl iswctype( wint_t _C, wctype_t _Type);
+ int __cdecl _iswctype_l( wint_t _C, wctype_t _Type, _locale_t _Locale);
+
+ int __cdecl __iswcsymf( wint_t _C);
+ int __cdecl _iswcsymf_l( wint_t _C, _locale_t _Locale);
+ int __cdecl __iswcsym( wint_t _C);
+ int __cdecl _iswcsym_l( wint_t _C, _locale_t _Locale);
+
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "iswctype" "instead. See online help for details.")) int __cdecl is_wctype( wint_t _C, wctype_t _Type);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ wchar_t * __cdecl _wgetcwd( wchar_t * _DstBuf, int _SizeInWords);
+ wchar_t * __cdecl _wgetdcwd( int _Drive, wchar_t * _DstBuf, int _SizeInWords);
+ wchar_t * __cdecl _wgetdcwd_nolock( int _Drive, wchar_t * _DstBuf, int _SizeInWords);
+
+
+
+
+
+
+
+ int __cdecl _wchdir( const wchar_t * _Path);
+ int __cdecl _wmkdir( const wchar_t * _Path);
+ int __cdecl _wrmdir( const wchar_t * _Path);
+
+
+
+
+
+
+ int __cdecl _waccess( const wchar_t * _Filename, int _AccessMode);
+ errno_t __cdecl _waccess_s( const wchar_t * _Filename, int _AccessMode);
+ int __cdecl _wchmod( const wchar_t * _Filename, int _Mode);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _wcreat( const wchar_t * _Filename, int _PermissionMode);
+ intptr_t __cdecl _wfindfirst32( const wchar_t * _Filename, struct _wfinddata32_t * _FindData);
+ int __cdecl _wfindnext32( intptr_t _FindHandle, struct _wfinddata32_t * _FindData);
+ int __cdecl _wunlink( const wchar_t * _Filename);
+ int __cdecl _wrename( const wchar_t * _NewFilename, const wchar_t * _OldFilename);
+ errno_t __cdecl _wmktemp_s( wchar_t * _TemplateName, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wmktemp_s( wchar_t (&_TemplateName)[_Size]) { return _wmktemp_s(_TemplateName, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wmktemp_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wmktemp( wchar_t *_TemplateName);
+
+
+ intptr_t __cdecl _wfindfirst32i64( const wchar_t * _Filename, struct _wfinddata32i64_t * _FindData);
+ intptr_t __cdecl _wfindfirst64i32( const wchar_t * _Filename, struct _wfinddata64i32_t * _FindData);
+ intptr_t __cdecl _wfindfirst64( const wchar_t * _Filename, struct _wfinddata64_t * _FindData);
+ int __cdecl _wfindnext32i64( intptr_t _FindHandle, struct _wfinddata32i64_t * _FindData);
+ int __cdecl _wfindnext64i32( intptr_t _FindHandle, struct _wfinddata64i32_t * _FindData);
+ int __cdecl _wfindnext64( intptr_t _FindHandle, struct _wfinddata64_t * _FindData);
+
+
+ errno_t __cdecl _wsopen_s( int * _FileHandle, const wchar_t * _Filename, int _OpenFlag, int _ShareFlag, int _PermissionFlag);
+
+
+
+
+
+
+
+
+
+extern "C++" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _wopen( const wchar_t * _Filename, int _OpenFlag, int _PermissionMode = 0);
+extern "C++" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _wsopen( const wchar_t * _Filename, int _OpenFlag, int _ShareFlag, int _PermissionMode = 0);
+
+
+
+
+
+
+
+
+
+
+ wchar_t * __cdecl _wsetlocale( int _Category, const wchar_t * _Locale);
+
+
+
+
+
+
+
+
+ intptr_t __cdecl _wexecl( const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wexecle( const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wexeclp( const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wexeclpe( const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wexecv( const wchar_t * _Filename, const wchar_t * const * _ArgList);
+ intptr_t __cdecl _wexecve( const wchar_t * _Filename, const wchar_t * const * _ArgList,
+ const wchar_t * const * _Env);
+ intptr_t __cdecl _wexecvp( const wchar_t * _Filename, const wchar_t * const * _ArgList);
+ intptr_t __cdecl _wexecvpe( const wchar_t * _Filename, const wchar_t * const * _ArgList,
+ const wchar_t * const * _Env);
+ intptr_t __cdecl _wspawnl( int _Mode, const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wspawnle( int _Mode, const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wspawnlp( int _Mode, const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wspawnlpe( int _Mode, const wchar_t * _Filename, const wchar_t * _ArgList, ...);
+ intptr_t __cdecl _wspawnv( int _Mode, const wchar_t * _Filename, const wchar_t * const * _ArgList);
+ intptr_t __cdecl _wspawnve( int _Mode, const wchar_t * _Filename, const wchar_t * const * _ArgList,
+ const wchar_t * const * _Env);
+ intptr_t __cdecl _wspawnvp( int _Mode, const wchar_t * _Filename, const wchar_t * const * _ArgList);
+ intptr_t __cdecl _wspawnvpe( int _Mode, const wchar_t * _Filename, const wchar_t * const * _ArgList,
+ const wchar_t * const * _Env);
+
+
+ int __cdecl _wsystem( const wchar_t * _Command);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef unsigned short _ino_t;
+
+
+typedef unsigned short ino_t;
+
+
+
+
+
+typedef unsigned int _dev_t;
+
+
+typedef unsigned int dev_t;
+
+
+
+
+
+typedef long _off_t;
+
+
+typedef long off_t;
+
+
+
+
+
+
+struct _stat32 {
+ _dev_t st_dev;
+ _ino_t st_ino;
+ unsigned short st_mode;
+ short st_nlink;
+ short st_uid;
+ short st_gid;
+ _dev_t st_rdev;
+ _off_t st_size;
+ __time32_t st_atime;
+ __time32_t st_mtime;
+ __time32_t st_ctime;
+ };
+
+
+
+struct stat {
+ _dev_t st_dev;
+ _ino_t st_ino;
+ unsigned short st_mode;
+ short st_nlink;
+ short st_uid;
+ short st_gid;
+ _dev_t st_rdev;
+ _off_t st_size;
+ time_t st_atime;
+ time_t st_mtime;
+ time_t st_ctime;
+ };
+
+
+
+
+
+struct _stat32i64 {
+ _dev_t st_dev;
+ _ino_t st_ino;
+ unsigned short st_mode;
+ short st_nlink;
+ short st_uid;
+ short st_gid;
+ _dev_t st_rdev;
+ __int64 st_size;
+ __time32_t st_atime;
+ __time32_t st_mtime;
+ __time32_t st_ctime;
+ };
+
+struct _stat64i32 {
+ _dev_t st_dev;
+ _ino_t st_ino;
+ unsigned short st_mode;
+ short st_nlink;
+ short st_uid;
+ short st_gid;
+ _dev_t st_rdev;
+ _off_t st_size;
+ __time64_t st_atime;
+ __time64_t st_mtime;
+ __time64_t st_ctime;
+ };
+
+struct _stat64 {
+ _dev_t st_dev;
+ _ino_t st_ino;
+ unsigned short st_mode;
+ short st_nlink;
+ short st_uid;
+ short st_gid;
+ _dev_t st_rdev;
+ __int64 st_size;
+ __time64_t st_atime;
+ __time64_t st_mtime;
+ __time64_t st_ctime;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl _wstat32( const wchar_t * _Name, struct _stat32 * _Stat);
+
+
+ int __cdecl _wstat32i64( const wchar_t * _Name, struct _stat32i64 * _Stat);
+ int __cdecl _wstat64i32( const wchar_t * _Name, struct _stat64i32 * _Stat);
+ int __cdecl _wstat64( const wchar_t * _Name, struct _stat64 * _Stat);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ errno_t __cdecl _cgetws_s( wchar_t * _Buffer, size_t _SizeInWords, size_t * _SizeRead);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _cgetws_s( wchar_t (&_Buffer)[_Size], size_t * _Size) { return _cgetws_s(_Buffer, _Size, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_cgetws_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _cgetws( wchar_t *_Buffer);
+ wint_t __cdecl _getwch(void);
+ wint_t __cdecl _getwche(void);
+ wint_t __cdecl _putwch(wchar_t _WCh);
+ wint_t __cdecl _ungetwch(wint_t _WCh);
+ int __cdecl _cputws( const wchar_t * _String);
+ int __cdecl _cwprintf( const wchar_t * _Format, ...);
+ int __cdecl _cwprintf_s( const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_cwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _cwscanf( const wchar_t * _Format, ...);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_cwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _cwscanf_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _cwscanf_s( const wchar_t * _Format, ...);
+ int __cdecl _cwscanf_s_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vcwprintf( const wchar_t *_Format, va_list _ArgList);
+ int __cdecl _vcwprintf_s( const wchar_t *_Format, va_list _ArgList);
+
+ int __cdecl _cwprintf_p( const wchar_t * _Format, ...);
+ int __cdecl _vcwprintf_p( const wchar_t* _Format, va_list _ArgList);
+
+ int __cdecl _cwprintf_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _cwprintf_s_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vcwprintf_l( const wchar_t *_Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _vcwprintf_s_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+ int __cdecl _cwprintf_p_l( const wchar_t * _Format, _locale_t _Locale, ...);
+ int __cdecl _vcwprintf_p_l( const wchar_t * _Format, _locale_t _Locale, va_list _ArgList);
+
+ wint_t __cdecl _putwch_nolock(wchar_t _WCh);
+ wint_t __cdecl _getwch_nolock(void);
+ wint_t __cdecl _getwche_nolock(void);
+ wint_t __cdecl _ungetwch_nolock(wint_t _WCh);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ errno_t __cdecl _itow_s ( int _Val, wchar_t * _DstBuf, size_t _SizeInWords, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _itow_s( int _Value, wchar_t (&_Dest)[_Size], int _Radix) { return _itow_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_itow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _itow( int _Value, wchar_t *_Dest, int _Radix);
+ errno_t __cdecl _ltow_s ( long _Val, wchar_t * _DstBuf, size_t _SizeInWords, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _ltow_s( long _Value, wchar_t (&_Dest)[_Size], int _Radix) { return _ltow_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _ltow( long _Value, wchar_t *_Dest, int _Radix);
+ errno_t __cdecl _ultow_s ( unsigned long _Val, wchar_t * _DstBuf, size_t _SizeInWords, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _ultow_s( unsigned long _Value, wchar_t (&_Dest)[_Size], int _Radix) { return _ultow_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _ultow( unsigned long _Value, wchar_t *_Dest, int _Radix);
+ double __cdecl wcstod( const wchar_t * _Str, wchar_t ** _EndPtr);
+ double __cdecl _wcstod_l( const wchar_t *_Str, wchar_t ** _EndPtr, _locale_t _Locale);
+ long __cdecl wcstol( const wchar_t *_Str, wchar_t ** _EndPtr, int _Radix);
+ long __cdecl _wcstol_l( const wchar_t *_Str, wchar_t **_EndPtr, int _Radix, _locale_t _Locale);
+ unsigned long __cdecl wcstoul( const wchar_t *_Str, wchar_t ** _EndPtr, int _Radix);
+ unsigned long __cdecl _wcstoul_l( const wchar_t *_Str, wchar_t **_EndPtr, int _Radix, _locale_t _Locale);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wdupenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wgetenv( const wchar_t * _VarName);
+ errno_t __cdecl _wgetenv_s( size_t * _ReturnSize, wchar_t * _DstBuf, size_t _DstSizeInWords, const wchar_t * _VarName);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wgetenv_s( size_t * _ReturnSize, wchar_t (&_Dest)[_Size], const wchar_t * _VarName) { return _wgetenv_s(_ReturnSize, _Dest, _Size, _VarName); } }
+ errno_t __cdecl _wdupenv_s( wchar_t **_Buffer, size_t *_BufferSizeInWords, const wchar_t *_VarName);
+
+
+
+
+ double __cdecl _wtof( const wchar_t *_Str);
+ double __cdecl _wtof_l( const wchar_t *_Str, _locale_t _Locale);
+ int __cdecl _wtoi( const wchar_t *_Str);
+ int __cdecl _wtoi_l( const wchar_t *_Str, _locale_t _Locale);
+ long __cdecl _wtol( const wchar_t *_Str);
+ long __cdecl _wtol_l( const wchar_t *_Str, _locale_t _Locale);
+
+
+ errno_t __cdecl _i64tow_s( __int64 _Val, wchar_t * _DstBuf, size_t _SizeInWords, int _Radix);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_i65tow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _i64tow( __int64 _Val, wchar_t * _DstBuf, int _Radix);
+ errno_t __cdecl _ui64tow_s( unsigned __int64 _Val, wchar_t * _DstBuf, size_t _SizeInWords, int _Radix);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ui64tow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _ui64tow( unsigned __int64 _Val, wchar_t * _DstBuf, int _Radix);
+ __int64 __cdecl _wtoi64( const wchar_t *_Str);
+ __int64 __cdecl _wtoi64_l( const wchar_t *_Str, _locale_t _Locale);
+ __int64 __cdecl _wcstoi64( const wchar_t * _Str, wchar_t ** _EndPtr, int _Radix);
+ __int64 __cdecl _wcstoi64_l( const wchar_t * _Str, wchar_t ** _EndPtr, int _Radix, _locale_t _Locale);
+ unsigned __int64 __cdecl _wcstoui64( const wchar_t * _Str, wchar_t ** _EndPtr, int _Radix);
+ unsigned __int64 __cdecl _wcstoui64_l( const wchar_t *_Str , wchar_t ** _EndPtr, int _Radix, _locale_t _Locale);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ wchar_t * __cdecl _wfullpath( wchar_t * _FullPath, const wchar_t * _Path, size_t _SizeInWords);
+
+
+
+
+
+ errno_t __cdecl _wmakepath_s( wchar_t * _PathResult, size_t _SizeInWords, const wchar_t * _Drive, const wchar_t * _Dir, const wchar_t * _Filename,
+ const wchar_t * _Ext);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wmakepath_s( wchar_t (&_ResultPath)[_Size], const wchar_t * _Drive, const wchar_t * _Dir, const wchar_t * _Filename, const wchar_t * _Ext) { return _wmakepath_s(_ResultPath, _Size, _Drive, _Dir, _Filename, _Ext); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wmakepath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _wmakepath( wchar_t *_ResultPath, const wchar_t * _Drive, const wchar_t * _Dir, const wchar_t * _Filename, const wchar_t * _Ext);
+
+
+
+
+ int __cdecl _wputenv( const wchar_t * _EnvString);
+ errno_t __cdecl _wputenv_s( const wchar_t * _Name, const wchar_t * _Value);
+ errno_t __cdecl _wsearchenv_s( const wchar_t * _Filename, const wchar_t * _EnvVar, wchar_t * _ResultPath, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wsearchenv_s( const wchar_t * _Filename, const wchar_t * _EnvVar, wchar_t (&_ResultPath)[_Size]) { return _wsearchenv_s(_Filename, _EnvVar, _ResultPath, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsearchenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _wsearchenv( const wchar_t * _Filename, const wchar_t * _EnvVar, wchar_t *_ResultPath);
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsplitpath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _wsplitpath( const wchar_t * _FullPath, wchar_t * _Drive, wchar_t * _Dir, wchar_t * _Filename, wchar_t * _Ext);
+ errno_t __cdecl _wsplitpath_s( const wchar_t * _FullPath,
+ wchar_t * _Drive, size_t _DriveSizeInWords,
+ wchar_t * _Dir, size_t _DirSizeInWords,
+ wchar_t * _Filename, size_t _FilenameSizeInWords,
+ wchar_t * _Ext, size_t _ExtSizeInWords);
+extern "C++" { template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t _ExtSize> inline errno_t __cdecl _wsplitpath_s( const wchar_t *_Path, wchar_t (&_Drive)[_DriveSize], wchar_t (&_Dir)[_DirSize], wchar_t (&_Name)[_NameSize], wchar_t (&_Ext)[_ExtSize]) { return _wsplitpath_s(_Path, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct tm {
+ int tm_sec;
+ int tm_min;
+ int tm_hour;
+ int tm_mday;
+ int tm_mon;
+ int tm_year;
+ int tm_wday;
+ int tm_yday;
+ int tm_isdst;
+ };
+
+
+
+
+
+
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wasctime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wasctime( const struct tm * _Tm);
+ errno_t __cdecl _wasctime_s( wchar_t *_Buf, size_t _SizeInWords, const struct tm * _Tm);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wasctime_s( wchar_t (&_Buffer)[_Size], const struct tm * _Time) { return _wasctime_s(_Buffer, _Size, _Time); } }
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctime32_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wctime32( const __time32_t *_Time);
+ errno_t __cdecl _wctime32_s( wchar_t* _Buf, size_t _SizeInWords, const __time32_t * _Time);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wctime32_s( wchar_t (&_Buffer)[_Size], const __time32_t * _Time) { return _wctime32_s(_Buffer, _Size, _Time); } }
+
+ size_t __cdecl wcsftime( wchar_t * _Buf, size_t _SizeInWords, const wchar_t * _Format, const struct tm * _Tm);
+ size_t __cdecl _wcsftime_l( wchar_t * _Buf, size_t _SizeInWords, const wchar_t *_Format, const struct tm *_Tm, _locale_t _Locale);
+
+ errno_t __cdecl _wstrdate_s( wchar_t * _Buf, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wstrdate_s( wchar_t (&_Buffer)[_Size]) { return _wstrdate_s(_Buffer, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wstrdate_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wstrdate( wchar_t *_Buffer);
+
+ errno_t __cdecl _wstrtime_s( wchar_t * _Buf, size_t _SizeInWords);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wstrtime_s( wchar_t (&_Buffer)[_Size]) { return _wstrtime_s(_Buffer, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wstrtime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wstrtime( wchar_t *_Buffer);
+
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctime64_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) wchar_t * __cdecl _wctime64( const __time64_t * _Time);
+ errno_t __cdecl _wctime64_s( wchar_t* _Buf, size_t _SizeInWords, const __time64_t *_Time);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wctime64_s( wchar_t (&_Buffer)[_Size], const __time64_t * _Time) { return _wctime64_s(_Buffer, _Size, _Time); } }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static __inline wchar_t * __cdecl _wctime(const time_t * _Time)
+{
+#pragma warning( push )
+#pragma warning( disable : 4996 )
+ return _wctime64(_Time);
+#pragma warning( pop )
+}
+
+static __inline errno_t __cdecl _wctime_s(wchar_t *_Buffer, size_t _SizeInWords, const time_t * _Time)
+{
+ return _wctime64_s(_Buffer, _SizeInWords, _Time);
+}
+
+
+#pragma warning(pop)
+
+
+
+
+
+
+
+
+
+
+typedef int mbstate_t;
+typedef wchar_t _Wint_t;
+
+ wint_t __cdecl btowc(int);
+ size_t __cdecl mbrlen( const char * _Ch, size_t _SizeInBytes,
+ mbstate_t * _State);
+ size_t __cdecl mbrtowc( wchar_t * _DstCh, const char * _SrcCh,
+ size_t _SizeInBytes, mbstate_t * _State);
+ errno_t __cdecl mbsrtowcs_s( size_t* _Retval, wchar_t * _Dst, size_t _SizeInWords, const char ** _PSrc, size_t _N, mbstate_t * _State);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl mbsrtowcs_s( size_t * _Retval, wchar_t (&_Dest)[_Size], const char ** _PSource, size_t _Count, mbstate_t * _State) { return mbsrtowcs_s(_Retval, _Dest, _Size, _PSource, _Count, _State); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "mbsrtowcs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl mbsrtowcs( wchar_t *_Dest, const char ** _PSrc, size_t _Count, mbstate_t * _State);
+
+ errno_t __cdecl wcrtomb_s( size_t * _Retval, char * _Dst,
+ size_t _SizeInBytes, wchar_t _Ch, mbstate_t * _State);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcrtomb_s( size_t * _Retval, char (&_Dest)[_Size], wchar_t _Source, mbstate_t * _State) { return wcrtomb_s(_Retval, _Dest, _Size, _Source, _State); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcrtomb_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl wcrtomb( char *_Dest, wchar_t _Source, mbstate_t * _State);
+ errno_t __cdecl wcsrtombs_s( size_t * _Retval, char * _Dst,
+ size_t _SizeInBytes, const wchar_t ** _Src, size_t _Size, mbstate_t * _State);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcsrtombs_s( size_t * _Retval, char (&_Dest)[_Size], const wchar_t ** _PSrc, size_t _Count, mbstate_t * _State) { return wcsrtombs_s(_Retval, _Dest, _Size, _PSrc, _Count, _State); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsrtombs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl wcsrtombs( char *_Dest, const wchar_t ** _PSource, size_t _Count, mbstate_t * _State);
+ int __cdecl wctob( wint_t _WCh);
+
+
+
+
+
+
+
+ void * __cdecl memmove( void * _Dst, const void * _Src, size_t _MaxCount);
+
+ void * __cdecl memcpy( void * _Dst, const void * _Src, size_t _MaxCount);
+
+ errno_t __cdecl memcpy_s( void * _Dst, rsize_t _DstSize, const void * _Src, rsize_t _MaxCount);
+ errno_t __cdecl memmove_s( void * _Dst, rsize_t _DstSize, const void * _Src, rsize_t _MaxCount);
+
+__inline int __cdecl fwide( FILE * _F, int _M)
+ {(void)_F; return (_M); }
+__inline int __cdecl mbsinit( const mbstate_t *_P)
+ {return (_P == 0 || *_P == 0); }
+__inline const wchar_t * __cdecl wmemchr( const wchar_t *_S, wchar_t _C, size_t _N)
+ {for (; 0 < _N; ++_S, --_N)
+ if (*_S == _C)
+ return (const wchar_t *)(_S);
+ return (0); }
+__inline int __cdecl wmemcmp( const wchar_t *_S1, const wchar_t *_S2, size_t _N)
+ {for (; 0 < _N; ++_S1, ++_S2, --_N)
+ if (*_S1 != *_S2)
+ return (*_S1 < *_S2 ? -1 : +1);
+ return (0); }
+
+__inline wchar_t * __cdecl wmemcpy( wchar_t *_S1, const wchar_t *_S2, size_t _N)
+ {
+#pragma warning( push )
+#pragma warning( disable : 4996 6386 )
+ return (wchar_t *)memcpy(_S1, _S2, _N*sizeof(wchar_t));
+#pragma warning( pop )
+ }
+
+
+__inline errno_t __cdecl wmemcpy_s( wchar_t *_S1, rsize_t _N1, const wchar_t *_S2, rsize_t _N)
+ {
+#pragma warning( push )
+#pragma warning( disable : 6386 )
+ return memcpy_s(_S1, _N1*sizeof(wchar_t), _S2, _N*sizeof(wchar_t));
+ }
+#pragma warning( pop )
+
+
+__inline wchar_t * __cdecl wmemmove( wchar_t *_S1, const wchar_t *_S2, size_t _N)
+ {
+#pragma warning( push )
+#pragma warning( disable : 4996 6386 )
+#pragma warning( disable : 6387)
+
+ return (wchar_t *)memmove(_S1, _S2, _N*sizeof(wchar_t));
+#pragma warning( pop )
+ }
+
+
+__inline errno_t __cdecl wmemmove_s( wchar_t *_S1, rsize_t _N1, const wchar_t *_S2, rsize_t _N)
+ {
+#pragma warning( push )
+#pragma warning( disable : 6386 )
+ return memmove_s(_S1, _N1*sizeof(wchar_t), _S2, _N*sizeof(wchar_t));
+#pragma warning( pop )
+ }
+
+
+__inline wchar_t * __cdecl wmemset( wchar_t *_S, wchar_t _C, size_t _N)
+ {
+ wchar_t *_Su = _S;
+ for (; 0 < _N; ++_Su, --_N)
+ {
+ *_Su = _C;
+ }
+ return (_S);
+ }
+
+
+extern "C++" {
+inline wchar_t * __cdecl wmemchr( wchar_t *_S, wchar_t _C, size_t _N)
+ { return (wchar_t *)wmemchr((const wchar_t *)_S, _C, _N); }
+}
+
+
+
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+typedef mbstate_t _Mbstatet;
+
+
+namespace std {
+using ::mbstate_t; using ::size_t; using ::tm; using ::wint_t;
+
+using ::btowc; using ::fgetwc; using ::fgetws; using ::fputwc;
+using ::fputws; using ::fwide; using ::fwprintf;
+using ::fwscanf; using ::getwc; using ::getwchar;
+using ::mbrlen; using ::mbrtowc; using ::mbsrtowcs;
+using ::mbsinit; using ::putwc; using ::putwchar;
+using ::swprintf; using ::swscanf; using ::ungetwc;
+using ::vfwprintf; using ::vswprintf; using ::vwprintf;
+using ::wcrtomb; using ::wprintf; using ::wscanf;
+using ::wcsrtombs; using ::wcstol; using ::wcscat;
+using ::wcschr; using ::wcscmp; using ::wcscoll;
+using ::wcscpy; using ::wcscspn; using ::wcslen;
+using ::wcsncat; using ::wcsncmp; using ::wcsncpy;
+using ::wcspbrk; using ::wcsrchr; using ::wcsspn;
+using ::wcstod; using ::wcstoul; using ::wcsstr;
+using ::wcstok; using ::wcsxfrm; using ::wctob;
+using ::wmemchr; using ::wmemcmp; using ::wmemcpy;
+using ::wmemmove; using ::wmemset; using ::wcsftime;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum _Uninitialized
+ {
+ _Noinit};
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+typedef void *_HFILE;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int (__cdecl * _CRT_REPORT_HOOK)(int, char *, int *);
+typedef int (__cdecl * _CRT_REPORT_HOOKW)(int, wchar_t *, int *);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int (__cdecl * _CRT_ALLOC_HOOK)(int, void *, size_t, int, long, const unsigned char *, int);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef void (__cdecl * _CRT_DUMP_CLIENT)(void *, size_t);
+
+
+
+
+
+
+
+struct _CrtMemBlockHeader;
+typedef struct _CrtMemState
+{
+ struct _CrtMemBlockHeader * pBlockHeader;
+ size_t lCounts[5];
+ size_t lSizes[5];
+ size_t lHighWaterCount;
+ size_t lTotalCount;
+} _CrtMemState;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+extern "C++" {
+
+
+
+
+
+
+
+
+
+
+
+
+ void * __cdecl operator new[](size_t _Size);
+
+
+inline void * __cdecl operator new(size_t _Size, int, const char *, int)
+ { return ::operator new(_Size); }
+
+inline void* __cdecl operator new[](size_t _Size, int, const char *, int)
+ { return ::operator new[](_Size); }
+
+
+
+
+void __cdecl operator delete[](void *);
+
+inline void __cdecl operator delete(void * _P, int, const char *, int)
+ { ::operator delete(_P); }
+inline void __cdecl operator delete[](void * _P, int, const char *, int)
+ { ::operator delete[](_P); }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+
+
+
+
+
+
+typedef long streamoff;
+typedef int streamsize;
+
+
+
+
+
+
+extern fpos_t _Fpz;
+extern const streamoff _BADOFF;
+
+
+
+template<class _Statetype>
+ class fpos
+ {
+ typedef fpos<_Statetype> _Myt;
+
+public:
+ fpos(streamoff _Off = 0)
+ : _Myoff(_Off), _Fpos(0), _Mystate(_Stz)
+ {
+ }
+
+ fpos(_Statetype _State, fpos_t _Fileposition)
+ : _Myoff(0), _Fpos(_Fileposition), _Mystate(_State)
+ {
+ }
+
+ _Statetype state() const
+ {
+ return (_Mystate);
+ }
+
+ void state(_Statetype _State)
+ {
+ _Mystate = _State;
+ }
+
+ fpos_t seekpos() const
+ {
+ return (_Fpos);
+ }
+
+ operator streamoff() const
+ {
+ return (_Myoff + ((long)(_Fpos)));
+ }
+
+ streamoff operator-(const _Myt& _Right) const
+ {
+ return ((streamoff)*this - (streamoff)_Right);
+ }
+
+ _Myt& operator+=(streamoff _Off)
+ {
+ _Myoff += _Off;
+ return (*this);
+ }
+
+ _Myt& operator-=(streamoff _Off)
+ {
+ _Myoff -= _Off;
+ return (*this);
+ }
+
+ _Myt operator+(streamoff _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt operator-(streamoff _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+ return ((streamoff)*this == (streamoff)_Right);
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+private:
+ static const _Statetype _Stz;
+ streamoff _Myoff;
+ fpos_t _Fpos;
+ _Statetype _Mystate;
+ };
+
+
+template<class _Statetype>
+ const _Statetype fpos<_Statetype>::_Stz = _Statetype();
+
+
+
+
+
+
+typedef fpos<_Mbstatet> streampos;
+typedef streampos wstreampos;
+
+
+struct _Unsecure_char_traits_tag
+ {
+ };
+struct _Secure_char_traits_tag
+ {
+ };
+
+
+
+
+
+
+struct _Char_traits_base
+ {
+ typedef _Unsecure_char_traits_tag _Secure_char_traits;
+ };
+
+
+
+
+template<class _Elem>
+ struct char_traits:
+ public _Char_traits_base
+ {
+ typedef _Elem char_type;
+ typedef long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef _Mbstatet state_type;
+
+ static void __cdecl assign(_Elem& _Left, const _Elem& _Right)
+ {
+ _Left = _Right;
+ }
+
+ static bool __cdecl eq(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static bool __cdecl lt(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left < _Right);
+ }
+
+ static int __cdecl compare(const _Elem *_First1,
+ const _Elem *_First2, size_t _Count)
+ {
+
+
+ for (; 0 < _Count; --_Count, ++_First1, ++_First2)
+ if (!eq(*_First1, *_First2))
+ return (lt(*_First1, *_First2) ? -1 : +1);
+ return (0);
+ }
+
+ static size_t __cdecl length(const _Elem *_First)
+ {
+
+ size_t _Count;
+ for (_Count = 0; !eq(*_First, _Elem()); ++_First)
+ ++_Count;
+ return (_Count);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl copy(_Elem *_First1,
+ const _Elem *_First2, size_t _Count)
+ {
+
+ return _Copy_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Copy_s(_Elem *_First1, size_t _Dest_size,
+ const _Elem *_First2, size_t _Count)
+ {
+
+
+ { if (!(_Dest_size >= _Count)) { ((void)0); ::_invalid_parameter_noinfo(); return (0); } };
+ _Elem *_Next = _First1;
+ for (; 0 < _Count; --_Count, ++_Next, ++_First2)
+ assign(*_Next, *_First2);
+ return (_First1);
+ }
+
+ static const _Elem *__cdecl find(const _Elem *_First,
+ size_t _Count, const _Elem& _Ch)
+ {
+
+ for (; 0 < _Count; --_Count, ++_First)
+ if (eq(*_First, _Ch))
+ return (_First);
+ return (0);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl move(_Elem *_First1,
+ const _Elem *_First2, size_t _Count)
+ {
+
+ return _Move_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Move_s(_Elem *_First1, size_t _Dest_size,
+ const _Elem *_First2, size_t _Count)
+ {
+
+
+ { if (!(_Dest_size >= _Count)) { ((void)0); ::_invalid_parameter_noinfo(); return (0); } };
+ _Elem *_Next = _First1;
+ if (_First2 < _Next && _Next < _First2 + _Count)
+ for (_Next += _Count, _First2 += _Count; 0 < _Count; --_Count)
+ assign(*--_Next, *--_First2);
+ else
+ for (; 0 < _Count; --_Count, ++_Next, ++_First2)
+ assign(*_Next, *_First2);
+ return (_First1);
+ }
+
+ static _Elem *__cdecl assign(_Elem *_First,
+ size_t _Count, _Elem _Ch)
+ {
+
+ _Elem *_Next = _First;
+ for (; 0 < _Count; --_Count, ++_Next)
+ assign(*_Next, _Ch);
+ return (_First);
+ }
+
+ static _Elem __cdecl to_char_type(const int_type& _Meta)
+ {
+ return ((_Elem)_Meta);
+ }
+
+ static int_type __cdecl to_int_type(const _Elem& _Ch)
+ {
+ return ((int_type)_Ch);
+ }
+
+ static bool __cdecl eq_int_type(const int_type& _Left,
+ const int_type& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static int_type __cdecl eof()
+ {
+ return ((int_type)(-1));
+ }
+
+ static int_type __cdecl not_eof(const int_type& _Meta)
+ {
+ return (_Meta != eof() ? (int_type)_Meta : (int_type)!eof());
+ }
+ };
+
+
+template<> struct char_traits<wchar_t>:
+ public _Char_traits_base
+ {
+ typedef wchar_t _Elem;
+ typedef _Elem char_type;
+ typedef wint_t int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef _Mbstatet state_type;
+
+ static void __cdecl assign(_Elem& _Left, const _Elem& _Right)
+ {
+ _Left = _Right;
+ }
+
+ static bool __cdecl eq(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static bool __cdecl lt(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left < _Right);
+ }
+
+ static int __cdecl compare(const _Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ return (::wmemcmp(_First1, _First2, _Count));
+ }
+
+ static size_t __cdecl length(const _Elem *_First)
+ {
+
+ return (::wcslen(_First));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl copy(_Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+ return _Copy_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Copy_s(_Elem *_First1, size_t _Size_in_words, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ ::wmemcpy_s((_First1), (_Size_in_words), (_First2), (_Count));
+ return _First1;
+ }
+
+ static const _Elem *__cdecl find(const _Elem *_First, size_t _Count,
+ const _Elem& _Ch)
+ {
+
+ return ((const _Elem *)::wmemchr(_First, _Ch, _Count));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl move(_Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+ return _Move_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Move_s(_Elem *_First1, size_t _Size_in_words, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ ::wmemmove_s((_First1), (_Size_in_words), (_First2), (_Count));
+ return (_Elem *)_First1;
+ }
+
+ static _Elem *__cdecl assign(_Elem *_First, size_t _Count, _Elem _Ch)
+ {
+
+ return ((_Elem *)::wmemset(_First, _Ch, _Count));
+ }
+
+ static _Elem __cdecl to_char_type(const int_type& _Meta)
+ {
+ return (_Meta);
+ }
+
+ static int_type __cdecl to_int_type(const _Elem& _Ch)
+ {
+ return (_Ch);
+ }
+
+ static bool __cdecl eq_int_type(const int_type& _Left,
+ const int_type& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static int_type __cdecl eof()
+ {
+ return ((wint_t)(0xFFFF));
+ }
+
+ static int_type __cdecl not_eof(const int_type& _Meta)
+ {
+ return (_Meta != eof() ? _Meta : !eof());
+ }
+ };
+
+
+
+template<> struct char_traits<char>:
+ public _Char_traits_base
+ {
+ typedef char _Elem;
+ typedef _Elem char_type;
+ typedef int int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef _Mbstatet state_type;
+
+ static void __cdecl assign(_Elem& _Left, const _Elem& _Right)
+ {
+ _Left = _Right;
+ }
+
+ static bool __cdecl eq(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static bool __cdecl lt(const _Elem& _Left, const _Elem& _Right)
+ {
+ return (_Left < _Right);
+ }
+
+ static int __cdecl compare(const _Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ return (::memcmp(_First1, _First2, _Count));
+ }
+
+ static size_t __cdecl length(const _Elem *_First)
+ {
+
+ return (::strlen(_First));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl copy(_Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+ return _Copy_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Copy_s(_Elem *_First1, size_t _Size_in_bytes, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ ::memcpy_s((_First1), (_Size_in_bytes), (_First2), (_Count));
+ return _First1;
+ }
+
+ static const _Elem *__cdecl find(const _Elem *_First, size_t _Count,
+ const _Elem& _Ch)
+ {
+
+ return ((const _Elem *)::memchr(_First, _Ch, _Count));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ static _Elem *__cdecl move(_Elem *_First1, const _Elem *_First2,
+ size_t _Count)
+ {
+
+ return _Move_s(_First1, _Count, _First2, _Count);
+ }
+
+ static _Elem *__cdecl _Move_s(_Elem *_First1, size_t _Size_in_bytes, const _Elem *_First2,
+ size_t _Count)
+ {
+
+
+ ::memmove_s((_First1), (_Size_in_bytes), (_First2), (_Count));
+ return _First1;
+ }
+
+ static _Elem *__cdecl assign(_Elem *_First, size_t _Count, _Elem _Ch)
+ {
+
+ return ((_Elem *)::memset(_First, _Ch, _Count));
+ }
+
+ static _Elem __cdecl to_char_type(const int_type& _Meta)
+ {
+ return ((_Elem)_Meta);
+ }
+
+ static int_type __cdecl to_int_type(const _Elem& _Ch)
+ {
+ return ((unsigned char)_Ch);
+ }
+
+ static bool __cdecl eq_int_type(const int_type& _Left,
+ const int_type& _Right)
+ {
+ return (_Left == _Right);
+ }
+
+ static int_type __cdecl eof()
+ {
+ return ((-1));
+ }
+
+ static int_type __cdecl not_eof(const int_type& _Meta)
+ {
+ return (_Meta != eof() ? _Meta : !eof());
+ }
+ };
+
+
+ template <class _Traits>
+ class _Inherits_from_char_traits_base
+ {
+ typedef char _True;
+ class _False { char _Dummy[2]; };
+ static _True _Inherits(_Char_traits_base);
+ static _False _Inherits(...);
+ static _Traits _Make_traits();
+
+ public:
+ enum { _Exists = sizeof(_Inherits(_Make_traits())) == sizeof(_True) };
+ };
+
+ template <class _Traits, bool _Inherits_from_char_traits_base>
+ class _Char_traits_category_helper
+ {
+ public:
+ typedef _Unsecure_char_traits_tag _Secure_char_traits;
+ };
+
+
+
+ template <class _Elem>
+ class _Char_traits_category_helper< char_traits<_Elem> , true>
+ {
+ public:
+ typedef _Secure_char_traits_tag _Secure_char_traits;
+ };
+
+ template <class _Traits>
+ class _Char_traits_category_helper<_Traits, true>
+ {
+ public:
+ typedef typename _Traits::_Secure_char_traits _Secure_char_traits;
+ };
+
+ template <class _Traits>
+ class _Char_traits_category
+ {
+ public:
+ typedef typename _Char_traits_category_helper<_Traits, _Inherits_from_char_traits_base<_Traits>::_Exists>::_Secure_char_traits _Secure_char_traits;
+ };
+
+
+
+ template<class _Traits>
+ inline
+ typename _Char_traits_category<_Traits>::_Secure_char_traits _Char_traits_cat()
+ {
+ typename _Char_traits_category<_Traits>::_Secure_char_traits _Secure;
+ return (_Secure);
+ }
+
+ namespace _Traits_helper
+ {
+
+
+ template<class _Traits>
+ inline
+ typename _Traits::char_type *copy_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count)
+ {
+ return copy_s<_Traits>(_First1, _Size, _First2, _Count, _Char_traits_cat<_Traits>());
+ }
+
+ template<class _Traits>
+ inline
+ typename _Traits::char_type *copy_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count, _Secure_char_traits_tag)
+ {
+ return _Traits::_Copy_s(_First1, _Size, _First2, _Count);
+ }
+
+
+ template<class _Traits>
+ inline
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ typename _Traits::char_type *copy_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count, _Unsecure_char_traits_tag)
+ {
+ return _Traits::copy(_First1, _First2, _Count);
+ }
+
+
+ template<class _Traits>
+ inline
+ typename _Traits::char_type *move_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count)
+ {
+ return move_s<_Traits>(_First1, _Size, _First2, _Count, _Char_traits_cat<_Traits>());
+ }
+
+ template<class _Traits>
+ inline
+ typename _Traits::char_type *move_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count, _Secure_char_traits_tag)
+ {
+ return _Traits::_Move_s(_First1, _Size, _First2, _Count);
+ }
+
+
+ template<class _Traits>
+ inline
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ typename _Traits::char_type *move_s(typename _Traits::char_type *_First1, size_t _Size,
+ const typename _Traits::char_type *_First2, size_t _Count, _Unsecure_char_traits_tag)
+ {
+ return _Traits::move(_First1, _First2, _Count);
+ }
+
+ }
+
+
+template<class _Ty>
+ class allocator;
+class ios_base;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_ios;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class istreambuf_iterator;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class ostreambuf_iterator;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_streambuf;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_istream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_ostream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_iostream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem>,
+ class _Alloc = allocator<_Elem> >
+ class basic_stringbuf;
+template<class _Elem,
+ class _Traits = char_traits<_Elem>,
+ class _Alloc = allocator<_Elem> >
+ class basic_istringstream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem>,
+ class _Alloc = allocator<_Elem> >
+ class basic_ostringstream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem>,
+ class _Alloc = allocator<_Elem> >
+ class basic_stringstream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_filebuf;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_ifstream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_ofstream;
+template<class _Elem,
+ class _Traits = char_traits<_Elem> >
+ class basic_fstream;
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef basic_ios<char, char_traits<char> > ios;
+typedef basic_streambuf<char, char_traits<char> > streambuf;
+typedef basic_istream<char, char_traits<char> > istream;
+typedef basic_ostream<char, char_traits<char> > ostream;
+typedef basic_iostream<char, char_traits<char> > iostream;
+typedef basic_stringbuf<char, char_traits<char>,
+ allocator<char> > stringbuf;
+typedef basic_istringstream<char, char_traits<char>,
+ allocator<char> > istringstream;
+typedef basic_ostringstream<char, char_traits<char>,
+ allocator<char> > ostringstream;
+typedef basic_stringstream<char, char_traits<char>,
+ allocator<char> > stringstream;
+typedef basic_filebuf<char, char_traits<char> > filebuf;
+typedef basic_ifstream<char, char_traits<char> > ifstream;
+typedef basic_ofstream<char, char_traits<char> > ofstream;
+typedef basic_fstream<char, char_traits<char> > fstream;
+
+
+typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
+typedef basic_streambuf<wchar_t, char_traits<wchar_t> >
+ wstreambuf;
+typedef basic_istream<wchar_t, char_traits<wchar_t> > wistream;
+typedef basic_ostream<wchar_t, char_traits<wchar_t> > wostream;
+typedef basic_iostream<wchar_t, char_traits<wchar_t> > wiostream;
+typedef basic_stringbuf<wchar_t, char_traits<wchar_t>,
+ allocator<wchar_t> > wstringbuf;
+typedef basic_istringstream<wchar_t, char_traits<wchar_t>,
+ allocator<wchar_t> > wistringstream;
+typedef basic_ostringstream<wchar_t, char_traits<wchar_t>,
+ allocator<wchar_t> > wostringstream;
+typedef basic_stringstream<wchar_t, char_traits<wchar_t>,
+ allocator<wchar_t> > wstringstream;
+typedef basic_filebuf<wchar_t, char_traits<wchar_t> > wfilebuf;
+typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
+typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
+typedef basic_fstream<wchar_t, char_traits<wchar_t> > wfstream;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+template<class _Ty> inline
+ void swap(_Ty& _Left, _Ty& _Right)
+ {
+ _Ty _Tmp = _Left;
+ _Left = _Right, _Right = _Tmp;
+ }
+
+
+template<class _Ty1,
+ class _Ty2> struct pair
+ {
+ typedef pair<_Ty1, _Ty2> _Myt;
+ typedef _Ty1 first_type;
+ typedef _Ty2 second_type;
+
+ pair()
+ : first(_Ty1()), second(_Ty2())
+ {
+ }
+
+ pair(const _Ty1& _Val1, const _Ty2& _Val2)
+ : first(_Val1), second(_Val2)
+ {
+ }
+
+ template<class _Other1,
+ class _Other2>
+ pair(const pair<_Other1, _Other2>& _Right)
+ : first(_Right.first), second(_Right.second)
+ {
+ }
+
+ void swap(_Myt& _Right)
+ {
+ std::swap(first, _Right.first);
+ std::swap(second, _Right.second);
+ }
+
+ _Ty1 first;
+ _Ty2 second;
+ };
+
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator==(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (_Left.first == _Right.first && _Left.second == _Right.second);
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator!=(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator<(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (_Left.first < _Right.first ||
+ !(_Right.first < _Left.first) && _Left.second < _Right.second);
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator>(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator<=(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ bool operator>=(const pair<_Ty1, _Ty2>& _Left,
+ const pair<_Ty1, _Ty2>& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ pair<_Ty1, _Ty2> make_pair(_Ty1 _Val1, _Ty2 _Val2)
+ {
+ return (pair<_Ty1, _Ty2>(_Val1, _Val2));
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right)
+ {
+ _Left.swap(_Right);
+ }
+
+
+ namespace rel_ops
+ {
+template<class _Ty> inline
+ bool operator!=(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Ty> inline
+ bool operator>(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Ty> inline
+ bool operator<=(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Ty> inline
+ bool operator>=(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+ }
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+
+
+struct __type_info_node {
+ void *memPtr;
+ __type_info_node* next;
+};
+
+extern __type_info_node __type_info_root_node;
+
+class type_info {
+public:
+ virtual ~type_info();
+ bool operator==(const type_info& rhs) const;
+ bool operator!=(const type_info& rhs) const;
+ int before(const type_info& rhs) const;
+ const char* name(__type_info_node* __ptype_info_node = &__type_info_root_node) const;
+ const char* raw_name() const;
+private:
+ void *_m_data;
+ char _m_d_name[1];
+ type_info(const type_info& rhs);
+ type_info& operator=(const type_info& rhs);
+ static const char *__cdecl _Name_base(const type_info *,__type_info_node* __ptype_info_node);
+ static void __cdecl _Type_info_dtor(type_info *);
+};
+
+
+
+ namespace std {
+
+using ::type_info;
+
+ }
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+
+
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+typedef void (__cdecl *terminate_function)();
+typedef void (__cdecl *terminate_handler)();
+typedef void (__cdecl *unexpected_function)();
+typedef void (__cdecl *unexpected_handler)();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct _EXCEPTION_POINTERS;
+
+typedef void (__cdecl *_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS*);
+
+
+ __declspec(noreturn) void __cdecl terminate(void);
+ void __cdecl unexpected(void);
+
+ int __cdecl _is_exception_typeof( const type_info &_Type, struct _EXCEPTION_POINTERS * _ExceptionPtr);
+
+
+
+ terminate_function __cdecl set_terminate( terminate_function _NewPtFunc);
+extern "C" terminate_function __cdecl _get_terminate(void);
+ unexpected_function __cdecl set_unexpected( unexpected_function _NewPtFunc);
+extern "C" unexpected_function __cdecl _get_unexpected(void);
+
+
+
+
+ _se_translator_function __cdecl _set_se_translator( _se_translator_function _NewPtFunc);
+
+ bool __cdecl __uncaught_exception();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef struct _heapinfo {
+ int * _pentry;
+ size_t _size;
+ int _useflag;
+ } _HEAPINFO;
+
+
+
+
+
+
+extern __declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_amblksiz" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) unsigned int _amblksiz;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ __declspec(noalias) __declspec(restrict) void * __cdecl calloc( size_t _NumOfElements, size_t _SizeOfElements);
+ __declspec(noalias) void __cdecl free( void * _Memory);
+ __declspec(noalias) __declspec(restrict) void * __cdecl malloc( size_t _Size);
+ __declspec(noalias) __declspec(restrict) void * __cdecl realloc( void * _Memory, size_t _NewSize);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _recalloc( void * _Memory, size_t _Count, size_t _Size);
+ __declspec(noalias) void __cdecl _aligned_free( void * _Memory);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_malloc( size_t _Size, size_t _Alignment);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_offset_malloc( size_t _Size, size_t _Alignment, size_t _Offset);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_realloc( void * _Memory, size_t _Size, size_t _Alignment);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_recalloc( void * _Memory, size_t _Count, size_t _Size, size_t _Alignment);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_offset_realloc( void * _Memory, size_t _Size, size_t _Alignment, size_t _Offset);
+ __declspec(noalias) __declspec(restrict) void * __cdecl _aligned_offset_recalloc( void * _Memory, size_t _Count, size_t _Size, size_t _Alignment, size_t _Offset);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl _resetstkoflw (void);
+
+
+
+ unsigned long __cdecl _set_malloc_crt_max_wait( unsigned long _NewValue);
+
+
+
+
+
+
+
+
+
+
+ void * __cdecl _expand( void * _Memory, size_t _NewSize);
+ size_t __cdecl _msize( void * _Memory);
+
+
+
+
+
+
+ void * __cdecl _alloca( size_t _Size);
+ size_t __cdecl _get_sbh_threshold(void);
+ int __cdecl _set_sbh_threshold( size_t _NewValue);
+ errno_t __cdecl _set_amblksiz( size_t _Value);
+ errno_t __cdecl _get_amblksiz( size_t * _Value);
+ int __cdecl _heapadd( void * _Memory, size_t _Size);
+ int __cdecl _heapchk(void);
+ int __cdecl _heapmin(void);
+ int __cdecl _heapset( unsigned int _Fill);
+ int __cdecl _heapwalk( _HEAPINFO * _EntryInfo);
+ size_t __cdecl _heapused(size_t * _Used, size_t * _Commit);
+
+ intptr_t __cdecl _get_heap_handle(void);
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef char __static_assert_t[ (sizeof(unsigned int) <= 8) ];
+
+
+__inline void *_MarkAllocaS( void *_Ptr, unsigned int _Marker)
+{
+ if (_Ptr)
+ {
+ *((unsigned int*)_Ptr) = _Marker;
+ _Ptr = (char*)_Ptr + 8;
+ }
+ return _Ptr;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+__declspec(noalias) __inline void __cdecl _freea( void * _Memory)
+{
+ unsigned int _Marker;
+ if (_Memory)
+ {
+ _Memory = (char*)_Memory - 8;
+ _Marker = *(unsigned int *)_Memory;
+ if (_Marker == 0xDDDD)
+ {
+ free(_Memory);
+ }
+
+ else if (_Marker != 0xCCCC)
+ {
+ ((void)0);
+ }
+
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef const char *__exString;
+extern "C" size_t __cdecl strlen(const char *);
+
+extern "C" errno_t __cdecl strcpy_s( char * _Dst, size_t _DstSize, const char * _Src);
+
+
+
+
+
+
+ namespace std {
+
+class exception
+ {
+public:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ exception();
+ exception(const char *const&);
+ exception(const char *const&, int);
+ exception(const exception&);
+ exception& operator=(const exception&);
+ virtual ~exception();
+ virtual const char * what() const;
+
+private:
+ const char *_m_what;
+ int _m_doFree;
+ };
+
+using ::set_terminate; using ::terminate_handler; using ::terminate; using ::set_unexpected; using ::unexpected_handler; using ::unexpected;
+
+typedef void (__cdecl *_Prhand)(const exception&);
+
+
+
+
+
+ bool __cdecl uncaught_exception();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class bad_exception : public exception
+ {
+public:
+ bad_exception(const char *_Message = "bad exception")
+ throw ()
+ : exception(_Message)
+ {
+ }
+
+ virtual ~bad_exception() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+static const char * _bad_alloc_Message = "bad allocation";
+
+
+class bad_alloc : public exception
+ {
+public:
+ bad_alloc(const char *_Message) throw ()
+ : exception(_Message)
+ {
+ }
+
+ bad_alloc() throw ()
+ : exception(_bad_alloc_Message, 1)
+ {
+ }
+
+ virtual ~bad_alloc() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ namespace std {
+
+class bad_cast : public exception {
+public:
+
+
+
+
+
+
+
+
+
+
+ bad_cast(const char * _Message = "bad cast");
+ bad_cast(const bad_cast &);
+ virtual ~bad_cast();
+
+};
+
+class bad_typeid : public exception {
+public:
+
+
+
+
+
+
+
+
+
+
+ bad_typeid(const char * _Message = "bad typeid");
+ bad_typeid(const bad_typeid &);
+ virtual ~bad_typeid();
+
+
+};
+
+class __non_rtti_object : public bad_typeid {
+public:
+
+
+
+
+
+
+
+
+
+
+ __non_rtti_object(const char * _Message);
+ __non_rtti_object(const __non_rtti_object &);
+ virtual ~__non_rtti_object();
+
+};
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost{
+
+
+
+
+ typedef long long long_long_type;
+ typedef unsigned long long ulong_long_type;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< int N > struct int_;
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+struct integral_c_tag { static const int value = 0; };
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< int N >
+struct int_
+{
+ static const int value = N;
+
+
+
+
+
+ typedef int_ type;
+
+ typedef int value_type;
+ typedef integral_c_tag tag;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ typedef boost::mpl::int_< static_cast<int>((value + 1)) > next;
+ typedef boost::mpl::int_< static_cast<int>((value - 1)) > prior;
+
+
+
+
+
+
+ operator int() const { return static_cast<int>(this->value); }
+};
+
+
+template< int N >
+int const boost::mpl::int_< N >::value;
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F > struct template_arity;
+
+}}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< bool C_ > struct bool_;
+
+
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< bool C_ > struct bool_
+{
+ static const bool value = C_;
+ typedef integral_c_tag tag;
+ typedef bool_ type;
+ typedef bool value_type;
+ operator bool() const { return this->value; }
+};
+
+
+template< bool C_ >
+bool const bool_<C_>::value;
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+
+template< typename T, T N > struct integral_c;
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< typename T, T N >
+struct integral_c
+{
+ static const T value = N;
+
+
+
+
+
+ typedef integral_c type;
+
+ typedef T value_type;
+ typedef integral_c_tag tag;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ typedef integral_c< T, static_cast<T>((value + 1)) > next;
+ typedef integral_c< T, static_cast<T>((value - 1)) > prior;
+
+
+
+
+
+
+ operator T() const { return static_cast<T>(this->value); }
+};
+
+
+template< typename T, T N >
+T const integral_c< T, N >::value;
+
+
+}}
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< bool C >
+struct integral_c<bool, C>
+{
+ static const bool value = C;
+ typedef integral_c_tag tag;
+ typedef integral_c type;
+ typedef bool value_type;
+ operator bool() const { return this->value; }
+};
+}}
+
+
+
+
+
+namespace boost{
+
+
+
+
+template <class T, T val>
+
+struct integral_constant : public mpl::integral_c<T, val>
+{
+ typedef integral_constant<T,val> type;
+};
+
+template<> struct integral_constant<bool,true> : public mpl::true_
+{
+
+
+
+
+
+
+
+ typedef integral_constant<bool,true> type;
+};
+template<> struct integral_constant<bool,false> : public mpl::false_
+{
+
+
+
+
+
+
+
+ typedef integral_constant<bool,false> type;
+};
+
+typedef integral_constant<bool,true> true_type;
+typedef integral_constant<bool,false> false_type;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+template< typename T > struct is_lvalue_reference : ::boost::integral_constant<bool,false> { };
+template< typename T > struct is_lvalue_reference< T& > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct is_rvalue_reference : ::boost::integral_constant<bool,false> { };
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+typedef char yes_type;
+struct no_type
+{
+ char padding[8];
+};
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
+struct ice_or;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_or
+{
+ static const bool value = true;
+};
+
+template <>
+struct ice_or<false, false, false, false, false, false, false>
+{
+ static const bool value = false;
+};
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
+struct ice_and;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_and
+{
+ static const bool value = false;
+};
+
+template <>
+struct ice_and<true, true, true, true, true, true, true>
+{
+ static const bool value = true;
+};
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+template <bool b>
+struct ice_not
+{
+ static const bool value = true;
+};
+
+template <>
+struct ice_not<true>
+{
+ static const bool value = false;
+};
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+template <int b1, int b2>
+struct ice_eq
+{
+ static const bool value = (b1 == b2);
+};
+
+template <int b1, int b2>
+struct ice_ne
+{
+ static const bool value = (b1 != b2);
+};
+
+
+template <int b1, int b2> bool const ice_eq<b1,b2>::value;
+template <int b1, int b2> bool const ice_ne<b1,b2>::value;
+
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_reference_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value);
+};
+
+}
+
+template< typename T > struct is_reference : ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+
+struct false_result
+{
+ template <typename T> struct result_
+ {
+ static const bool value = false;
+ };
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+
+
+no_type __cdecl is_function_ptr_tester(...);
+
+
+
+
+
+template <class R >
+yes_type is_function_ptr_tester(R (*)());
+
+template <class R >
+yes_type is_function_ptr_tester(R (*)( ...));
+
+
+template <class R >
+yes_type is_function_ptr_tester(R (__stdcall*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__stdcall*)( ...));
+
+template <class R >
+yes_type is_function_ptr_tester(R (__fastcall*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__fastcall*)( ...));
+
+template <class R >
+yes_type is_function_ptr_tester(R (__cdecl*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__cdecl*)( ...));
+
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (*)( T0));
+
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (*)( T0 ...));
+
+
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 ...));
+
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 ...));
+
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 ...));
+
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1));
+
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 ...));
+
+
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 ...));
+
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 ...));
+
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 ...));
+
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2));
+
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...));
+
+
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 ...));
+
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 ...));
+
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3));
+
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+
+
+
+
+
+
+
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct is_function_impl
+{
+
+#pragma warning(push)
+#pragma warning(disable:6334)
+
+ static T* t;
+ static const bool value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type);
+
+#pragma warning(pop)
+
+};
+
+
+template <typename T>
+struct is_function_impl<T&> : public false_type
+{};
+
+
+
+
+}
+
+
+
+
+
+
+template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { };
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost
+{
+
+ template <bool B, class T = void>
+ struct enable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct enable_if_c<false, T> {};
+
+ template <class Cond, class T = void>
+ struct enable_if : public enable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_enable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_enable_if_c<false, T> {};
+
+ template <class Cond, class T>
+ struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+ template <bool B, class T = void>
+ struct disable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct disable_if_c<true, T> {};
+
+ template <class Cond, class T = void>
+ struct disable_if : public disable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_disable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_disable_if_c<true, T> {};
+
+ template <class Cond, class T>
+ struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost
+{
+ namespace type_of
+ {
+
+
+
+ template<int N> struct the_counter;
+
+ template<typename T,int N = 5>
+ struct encode_counter
+ {
+ __if_exists(the_counter<N + 256>)
+ {
+ static const unsigned count=(encode_counter<T,N + 257>::count);
+ }
+ __if_not_exists(the_counter<N + 256>)
+ {
+ __if_exists(the_counter<N + 64>)
+ {
+ static const unsigned count=(encode_counter<T,N + 65>::count);
+ }
+ __if_not_exists(the_counter<N + 64>)
+ {
+ __if_exists(the_counter<N + 16>)
+ {
+ static const unsigned count=(encode_counter<T,N + 17>::count);
+ }
+ __if_not_exists(the_counter<N + 16>)
+ {
+ __if_exists(the_counter<N + 4>)
+ {
+ static const unsigned count=(encode_counter<T,N + 5>::count);
+ }
+ __if_not_exists(the_counter<N + 4>)
+ {
+ __if_exists(the_counter<N>)
+ {
+ static const unsigned count=(encode_counter<T,N + 1>::count);
+ }
+ __if_not_exists(the_counter<N>)
+ {
+ static const unsigned count=N;
+ typedef the_counter<N> type;
+ }
+ }
+ }
+ }
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ struct msvc_extract_type_default_param {};
+
+ template<typename ID, typename T = msvc_extract_type_default_param>
+ struct msvc_extract_type;
+
+ template<typename ID>
+ struct msvc_extract_type<ID, msvc_extract_type_default_param> {
+ template<bool>
+ struct id2type_impl;
+
+ typedef id2type_impl<true> id2type;
+ };
+
+ template<typename ID, typename T>
+ struct msvc_extract_type : msvc_extract_type<ID,msvc_extract_type_default_param>
+ {
+ template<>
+ struct id2type_impl<true>
+ {
+ typedef T type;
+ };
+ template<bool>
+ struct id2type_impl;
+
+ typedef id2type_impl<true> id2type;
+ };
+
+ template<typename T, typename ID>
+ struct msvc_register_type : msvc_extract_type<ID, T>
+ {
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<int ID>
+ struct msvc_typeid_wrapper {
+ typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
+ typedef typename id2type::type type;
+ };
+
+ template<>
+ struct msvc_typeid_wrapper<1> {
+ typedef msvc_typeid_wrapper<1> type;
+ };
+
+ template<>
+ struct msvc_typeid_wrapper<4> {
+ typedef msvc_typeid_wrapper<4> type;
+ };
+
+
+ template<typename T>
+ struct encode_type
+ {
+
+ static const unsigned value=(boost::type_of::encode_counter<T>::count);
+
+ typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
+
+ static const unsigned next=value+1;
+
+ ;
+ };
+
+ template<class T>
+ struct sizer
+ {
+ typedef char(*type)[encode_type<T>::value];
+ };
+
+ template<typename T> typename disable_if<
+ typename is_function<T>::type,
+ typename sizer<T>::type>::type encode_start(T const&);
+
+ template<typename T> typename enable_if<
+ typename is_function<T>::type,
+ typename sizer<T>::type>::type encode_start(T&);
+
+
+
+
+ template<typename Organizer, typename T>
+ msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace scope_exit { namespace aux {
+
+
+
+
+
+ template<int Dummy = 0>
+ struct declared
+ {
+ void* value;
+ static int const cmp2 = 0;
+ friend void operator>(int, declared const&) {}
+ };
+
+ struct undeclared { declared<> dummy[2]; };
+
+ template<int> struct resolve;
+
+ template<>
+ struct resolve<sizeof(declared<>)>
+ {
+ static const int cmp1 = 0;
+ };
+
+ template<>
+ struct resolve<sizeof(undeclared)>
+ {
+ template<int>
+ struct cmp1
+ {
+ static int const cmp2 = 0;
+ };
+ };
+} } }
+
+extern boost::scope_exit::aux::undeclared boost_scope_exit_args;
+
+
+namespace boost { namespace scope_exit { namespace aux {
+
+typedef void (*ref_tag)(int&);
+typedef void (*val_tag)(int );
+
+template<class T, class Tag> struct member;
+
+template<class T>
+struct member<T,ref_tag>
+{
+ T& value;
+
+ member(T& ref) : value(ref) {}
+
+};
+
+template<class T>
+struct member<T,val_tag>
+{
+ T value;
+
+ member(T& val) : value(val) {}
+
+};
+
+template<class T> inline T& deref(T* p, ref_tag) { return *p; }
+template<class T> inline T& deref(T& r, val_tag) { return r; }
+
+template<class T>
+struct wrapper
+{
+ typedef T type;
+};
+
+template<class T> wrapper<T> wrap(T&);
+
+} } }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ namespace boost { namespace scope_exit { namespace msvc_typeof_this
+ {
+ template<int ID>
+ struct msvc_typeid_wrapper {
+ typedef typename boost::type_of::msvc_extract_type<mpl::int_<ID> >::id2type id2type;
+ typedef typename id2type::type type;
+ };
+ template<>
+ struct msvc_typeid_wrapper<4> {
+ typedef msvc_typeid_wrapper<4> type;
+ };
+ template<typename T>
+ struct encode_type
+ {
+ static const unsigned value=(boost::type_of::encode_counter<T>::count);
+ typedef typename boost::type_of::msvc_register_type<T,mpl::int_<value> >::id2type type;
+ static const unsigned next=value+1;
+ ;
+ };
+ template<class T>
+ struct sizer
+ {
+ typedef char(*type)[encode_type<T>::value];
+ };
+ template<typename T> typename disable_if<
+ typename is_function<T>::type,
+ typename sizer<T>::type>::type encode_start(T const&);
+ template<typename T> typename enable_if<
+ typename is_function<T>::type,
+ typename sizer<T>::type>::type encode_start(T&);
+ template<typename Organizer, typename T>
+ boost::type_of::msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
+
+ }}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(disable:4003)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace contract { namespace detail {
+
+
+
+
+
+
+template<typename T> struct add_pointed_const { typedef T type; };
+
+template<typename T> struct add_pointed_const<T*> { typedef T const* type; };
+
+template<typename T> struct add_pointed_const<T const*>
+ { typedef T const* type; };
+
+template<typename T> struct add_pointed_const<T* const>
+ { typedef T const* const type; };
+
+template<typename T> struct add_pointed_const<T const* const>
+ { typedef T const* const type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4181)
+
+
+template< typename T > struct add_const { typedef T const type; };
+
+
+#pragma warning(pop)
+
+
+
+template< typename T > struct add_const<T&> { typedef T& type; };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4181)
+
+
+template< typename T > struct add_cv { typedef T const volatile type; };
+
+
+#pragma warning(pop)
+
+
+
+template< typename T > struct add_cv<T&> { typedef T& type; };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct add_reference_rvalue_layer
+{
+ typedef T& type;
+};
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct add_reference_impl
+{
+ typedef typename add_reference_rvalue_layer<T>::type type;
+};
+
+
+template< typename T > struct add_reference_impl<T&> { typedef T& type; };
+
+
+
+
+
+template<> struct add_reference_impl<void> { typedef void type; };
+
+template<> struct add_reference_impl<void const> { typedef void const type; };
+template<> struct add_reference_impl<void volatile> { typedef void volatile type; };
+template<> struct add_reference_impl<void const volatile> { typedef void const volatile type; };
+
+
+}
+
+template< typename T > struct add_reference { typedef typename boost::detail::add_reference_impl<T>::type type; };
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost{
+
+template< typename T > struct add_lvalue_reference { typedef typename boost::add_reference<T>::type type; };
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail{
+
+
+
+
+template <class T>
+struct remove_rvalue_ref
+{
+ typedef T type;
+};
+
+
+
+
+
+
+
+
+}
+
+template< typename T > struct remove_reference { typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
+template< typename T > struct remove_reference<T&> { typedef T type; };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct add_pointer_impl
+{
+ typedef typename remove_reference<T>::type no_ref_type;
+ typedef no_ref_type* type;
+};
+
+
+
+}
+
+template< typename T > struct add_pointer { typedef typename boost::detail::add_pointer_impl<T>::type type; };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+template< typename T > struct is_void : ::boost::integral_constant<bool,false> { };
+template<> struct is_void< void > : ::boost::integral_constant<bool,true> { };
+
+
+template<> struct is_void< void const > : ::boost::integral_constant<bool,true> { };
+template<> struct is_void< void volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_void< void const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace type_traits_detail {
+
+ template <typename T, bool b>
+ struct add_rvalue_reference_helper
+ { typedef T type; };
+
+ template <typename T>
+ struct add_rvalue_reference_helper<T, true>
+ {
+
+
+
+ typedef T type;
+
+ };
+
+ template <typename T>
+ struct add_rvalue_reference_imp
+ {
+ typedef typename boost::type_traits_detail::add_rvalue_reference_helper
+ <T, (!is_void<T>::value && !is_reference<T>::value) >::type type;
+ };
+
+}
+
+template< typename T > struct add_rvalue_reference { typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4181)
+
+
+template< typename T > struct add_volatile { typedef T volatile type; };
+
+
+#pragma warning(pop)
+
+
+
+template< typename T > struct add_volatile<T&> { typedef T& type; };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> { };
+template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< std::size_t N > struct size_t;
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< std::size_t N >
+struct size_t
+{
+ static const std::size_t value = N;
+
+
+
+
+
+ typedef size_t type;
+
+ typedef std::size_t value_type;
+ typedef integral_c_tag tag;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ typedef boost::mpl::size_t< static_cast<std::size_t>((value + 1)) > next;
+ typedef boost::mpl::size_t< static_cast<std::size_t>((value - 1)) > prior;
+
+
+
+
+
+
+ operator std::size_t() const { return static_cast<std::size_t>(this->value); }
+};
+
+
+template< std::size_t N >
+std::size_t const boost::mpl::size_t< N >::value;
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable: 4121 4512)
+
+
+
+
+
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+
+namespace detail {
+
+
+#pragma warning(push)
+#pragma warning(disable:4324)
+
+template <typename T>
+struct alignment_of_hack
+{
+ char c;
+ T t;
+ alignment_of_hack();
+};
+
+#pragma warning(pop)
+
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+ static const std::size_t value = A < S ? A : S;
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+
+
+
+
+
+
+ static const std::size_t value = (::boost::detail::alignment_logic< sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T), __alignof(T) >::value);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+};
+
+}
+
+template< typename T > struct alignment_of : ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { };
+
+
+
+
+template <typename T>
+struct alignment_of<T&>
+ : alignment_of<T*>
+{
+};
+
+
+
+
+
+
+
+
+
+
+template<> struct alignment_of<void> : ::boost::integral_constant<std::size_t,0> { };
+
+template<> struct alignment_of<void const> : ::boost::integral_constant<std::size_t,0> { };
+template<> struct alignment_of<void volatile> : ::boost::integral_constant<std::size_t,0> { };
+template<> struct alignment_of<void const volatile> : ::boost::integral_constant<std::size_t,0> { };
+
+
+}
+
+
+
+
+
+#pragma warning(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct value_type_wknd
+{
+ typedef typename T::value_type type;
+};
+
+
+
+
+
+
+
+
+}}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+struct void_;
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+struct na
+{
+ typedef na type;
+ enum { value = 0 };
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template< typename T >
+struct is_na
+ : false_
+{
+
+
+
+};
+
+template<>
+struct is_na<na>
+ : true_
+{
+
+
+
+};
+
+template< typename T >
+struct is_not_na
+ : true_
+{
+
+
+
+};
+
+template<>
+struct is_not_na<na>
+ : false_
+{
+
+
+
+};
+
+
+template< typename T, typename U > struct if_na
+{
+ typedef T type;
+};
+
+template< typename U > struct if_na<na,U>
+{
+ typedef U type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+ typename T = na
+ , typename Tag = void_
+
+ >
+struct lambda;
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<
+ bool C
+ , typename T1
+ , typename T2
+ >
+struct if_c
+{
+ typedef T1 type;
+};
+
+template<
+ typename T1
+ , typename T2
+ >
+struct if_c<false,T1,T2>
+{
+ typedef T2 type;
+};
+
+
+
+template<
+ typename T1 = na
+ , typename T2 = na
+ , typename T3 = na
+ >
+struct if_
+{
+ private:
+
+ typedef if_c<
+
+
+
+ static_cast<bool>(T1::value)
+
+ , T2
+ , T3
+ > almost_type_;
+
+ public:
+ typedef typename almost_type_::type type;
+
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+template< typename T > struct is_integral : ::boost::integral_constant<bool,false> { };
+
+template<> struct is_integral< unsigned char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const volatile > : ::boost::integral_constant<bool,true> { };
+
+template<> struct is_integral< signed char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const volatile > : ::boost::integral_constant<bool,true> { };
+
+template<> struct is_integral< bool > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+template<> struct is_integral< wchar_t > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct is_integral< ::boost::ulong_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< ::boost::long_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+template< typename T > struct is_float : ::boost::integral_constant<bool,false> { };
+template<> struct is_float< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_float< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_float< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const volatile > : ::boost::integral_constant<bool,true> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+namespace detail {
+
+template< typename T >
+struct is_arithmetic_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);
+};
+
+}
+
+
+
+
+
+
+template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template< typename T > struct is_enum : ::boost::integral_constant<bool,__is_enum(T)> { };
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+template< typename T > struct is_array : ::boost::integral_constant<bool,false> { };
+
+template< typename T, std::size_t N > struct is_array< T[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T const[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T volatile[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T const volatile[N] > : ::boost::integral_constant<bool,true> { };
+
+template< typename T > struct is_array< T[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T const[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T volatile[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T const volatile[] > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace type_traits {
+
+no_type __cdecl is_mem_fun_pointer_tester(...);
+
+
+
+
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)());
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const volatile);
+
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...));
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const volatile);
+
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)());
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...));
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const volatile);
+
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)());
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...));
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const volatile);
+
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)());
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...));
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) volatile);
+
+template <class R, class T >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const volatile);
+
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const volatile);
+
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const volatile);
+
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const volatile);
+
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...));
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) volatile);
+
+template <class R, class T , class T0 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const volatile);
+
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...));
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) volatile);
+
+template <class R, class T , class T0 , class T1 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+
+
+
+
+
+
+
+
+
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace detail {
+
+
+
+template <bool>
+struct is_mem_fun_pointer_select
+ : ::boost::type_traits::false_result
+{
+};
+
+template <>
+struct is_mem_fun_pointer_select<false>
+{
+ template <typename T> struct result_
+ {
+
+#pragma warning(push)
+#pragma warning(disable:6334)
+
+ static T* make_t;
+ typedef result_<T> self_type;
+
+ static const bool value = ( 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) );
+
+#pragma warning(pop)
+
+ };
+};
+
+template <typename T>
+struct is_member_function_pointer_impl
+ : is_mem_fun_pointer_select<
+ ::boost::type_traits::ice_or<
+ ::boost::is_reference<T>::value
+ , ::boost::is_array<T>::value
+ >::value
+ >::template result_<T>
+{
+};
+
+
+template <typename T>
+struct is_member_function_pointer_impl<T&> : public false_type{};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct is_member_function_pointer_impl< void > { static const bool value = (false); };
+
+template<> struct is_member_function_pointer_impl< void const > { static const bool value = (false); };
+template<> struct is_member_function_pointer_impl< void volatile > { static const bool value = (false); };
+template<> struct is_member_function_pointer_impl< void const volatile > { static const bool value = (false); };
+
+
+}
+
+template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::detail::is_member_function_pointer_impl<T>::value> { };
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { };
+template< typename T, typename U > struct is_member_pointer : ::boost::integral_constant<bool,true> { };
+
+
+template< typename T, typename U > struct is_member_pointer : ::boost::integral_constant<bool,true> { };
+template< typename T, typename U > struct is_member_pointer : ::boost::integral_constant<bool,true> { };
+template< typename T, typename U > struct is_member_pointer : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace detail {
+
+
+
+
+
+
+
+template <typename T> struct cv_traits_imp {};
+
+template <typename T>
+struct cv_traits_imp<T*>
+{
+ static const bool is_const = false;
+ static const bool is_volatile = false;
+ typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const T*>
+{
+ static const bool is_const = true;
+ static const bool is_volatile = false;
+ typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<volatile T*>
+{
+ static const bool is_const = false;
+ static const bool is_volatile = true;
+ typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const volatile T*>
+{
+ static const bool is_const = true;
+ static const bool is_volatile = true;
+ typedef T unqualified_type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct rvalue_ref_filter_rem_cv
+{
+ typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+template< typename T > struct remove_cv { typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
+template< typename T > struct remove_cv<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+namespace detail {
+
+template< typename T > struct is_pointer_helper
+{
+ static const bool value = false;
+};
+
+
+
+
+
+
+
+
+template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
+
+
+
+template< typename T >
+struct is_pointer_impl
+{
+
+
+
+
+
+
+
+
+
+
+ static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
+
+};
+
+}
+
+template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_scalar_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value);
+};
+
+
+
+template <> struct is_scalar_impl<void>{ static const bool value = false; };
+
+template <> struct is_scalar_impl<void const>{ static const bool value = false; };
+template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
+template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };
+
+
+}
+
+template< typename T > struct is_scalar : ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+template< typename T > struct is_POD;
+
+namespace detail {
+
+
+
+template <typename T> struct is_pod_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, (__is_pod(T) && __has_trivial_constructor(T)) >::value);
+};
+
+
+template <typename T, std::size_t sz>
+struct is_pod_impl<T[sz]>
+ : is_pod_impl<T>
+{
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct is_pod_impl< void > { static const bool value = (true); };
+
+
+template<> struct is_pod_impl< void const > { static const bool value = (true); };
+template<> struct is_pod_impl< void volatile > { static const bool value = (true); };
+template<> struct is_pod_impl< void const volatile > { static const bool value = (true); };
+
+
+}
+
+template< typename T > struct is_POD : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
+template< typename T > struct is_pod : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost{
+
+
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+
+
+template<int x> struct static_assert_test{};
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable: 4121)
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+class alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <bool found, std::size_t target, class TestType>
+struct lower_alignment_helper
+{
+ typedef char type;
+ enum { value = true };
+};
+
+template <std::size_t target, class TestType>
+struct lower_alignment_helper<false,target,TestType>
+{
+ enum { value = (alignment_of<TestType>::value == target) };
+ typedef typename mpl::if_c<value, TestType, char>::type type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct has_one_T
+{
+ T data;
+};
+
+template <std::size_t target>
+union lower_alignment
+{
+ enum { found0 = false };
+
+ typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< fou
nd7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 =
lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignm
ent_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lowe
r_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };
+};
+
+union max_align
+{
+ char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;
+};
+
+
+
+
+
+
+
+
+template<std::size_t TAlign, std::size_t Align>
+struct is_aligned
+{
+ static const bool value = (TAlign >= Align) & (TAlign % Align == 0);
+};
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+template<std::size_t Align>
+struct is_pod< ::boost::detail::lower_alignment<Align> >
+{
+ static const std::size_t value = true;
+};
+
+
+
+
+namespace detail{
+
+template <std::size_t Align>
+class type_with_alignment_imp
+{
+ typedef ::boost::detail::lower_alignment<Align> t1;
+ typedef typename mpl::if_c<
+ ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
+ , t1
+ , ::boost::detail::max_align
+ >::type align_t;
+
+ static const std::size_t found = alignment_of<align_t>::value;
+
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)(found >= Align) >)> boost_static_assert_typedef_0;
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)(found % Align == 0) >)> boost_static_assert_typedef_1;
+
+ public:
+ typedef align_t type;
+};
+
+}
+
+template <std::size_t Align>
+class type_with_alignment
+ : public ::boost::detail::type_with_alignment_imp<Align>
+{
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace align {
+struct __declspec(align(8)) a8 {
+ char m[8];
+ typedef a8 type;
+};
+struct __declspec(align(16)) a16 {
+ char m[16];
+ typedef a16 type;
+};
+struct __declspec(align(32)) a32 {
+ char m[32];
+ typedef a32 type;
+};
+struct __declspec(align(64)) a64
+{
+ char m[64];
+ typedef a64 type;
+};
+struct __declspec(align(128)) a128 {
+ char m[128];
+ typedef a128 type;
+};
+}
+
+template<> class type_with_alignment<8>
+{
+ typedef mpl::if_c<
+ ::boost::alignment_of<boost::detail::max_align>::value < 8,
+ align::a8,
+ boost::detail::type_with_alignment_imp<8> >::type t1;
+public:
+ typedef t1::type type;
+};
+template<> class type_with_alignment<16>
+{
+ typedef mpl::if_c<
+ ::boost::alignment_of<boost::detail::max_align>::value < 16,
+ align::a16,
+ boost::detail::type_with_alignment_imp<16> >::type t1;
+public:
+ typedef t1::type type;
+};
+template<> class type_with_alignment<32>
+{
+ typedef mpl::if_c<
+ ::boost::alignment_of<boost::detail::max_align>::value < 32,
+ align::a32,
+ boost::detail::type_with_alignment_imp<32> >::type t1;
+public:
+ typedef t1::type type;
+};
+template<> class type_with_alignment<64> {
+ typedef mpl::if_c<
+ ::boost::alignment_of<boost::detail::max_align>::value < 64,
+ align::a64,
+ boost::detail::type_with_alignment_imp<64> >::type t1;
+public:
+ typedef t1::type type;
+};
+template<> class type_with_alignment<128> {
+ typedef mpl::if_c<
+ ::boost::alignment_of<boost::detail::max_align>::value < 128,
+ align::a128,
+ boost::detail::type_with_alignment_imp<128> >::type t1;
+public:
+ typedef t1::type type;
+};
+
+namespace detail {
+template<> struct is_pod_impl< ::boost::align::a8 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a16 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a32 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a64 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a128 > { static const bool value = (true); };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+ typename C = na
+ , typename F1 = na
+ , typename F2 = na
+ >
+struct eval_if
+
+
+
+
+
+ : if_<C,F1,F2>::type
+{
+
+
+};
+
+
+
+template<
+ bool C
+ , typename F1
+ , typename F2
+ >
+struct eval_if_c
+
+
+
+
+
+ : if_c<C,F1,F2>::type
+{
+
+};
+
+template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+ typename T = na
+ >
+struct identity
+{
+ typedef T type;
+
+};
+
+template<
+ typename T = na
+ >
+struct make_identity
+{
+ typedef identity<T> type;
+
+};
+
+template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; };
+template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail { namespace aligned_storage {
+
+static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value;
+
+
+
+
+template <
+ std::size_t size_
+ , std::size_t alignment_
+>
+struct aligned_storage_imp
+{
+ union data_t
+ {
+ char buf[size_];
+
+ typename mpl::eval_if_c<
+ alignment_ == std::size_t(-1)
+ , mpl::identity<detail::max_align>
+ , type_with_alignment<alignment_>
+ >::type align_;
+ } data_;
+ void* address() const { return const_cast<aligned_storage_imp*>(this); }
+};
+
+template< std::size_t alignment_ >
+struct aligned_storage_imp<0u,alignment_>
+{
+
+ void* address() const { return 0; }
+};
+
+}}
+
+template <
+ std::size_t size_
+ , std::size_t alignment_ = std::size_t(-1)
+>
+class aligned_storage :
+
+ private
+
+
+
+ detail::aligned_storage::aligned_storage_imp<size_, alignment_>
+{
+
+public:
+
+ typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+
+ static const std::size_t size = size_;
+ static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ );
+
+
+
+
+
+
+
+
+
+
+public:
+
+ aligned_storage(const aligned_storage&);
+ aligned_storage& operator=(const aligned_storage&);
+
+
+
+public:
+
+ aligned_storage()
+ {
+ }
+
+ ~aligned_storage()
+ {
+ }
+
+public:
+
+ void* address()
+ {
+ return static_cast<type*>(this)->address();
+ }
+
+
+
+ const void* address() const
+ {
+ return static_cast<const type*>(this)->address();
+ }
+
+
+
+
+
+
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <std::size_t size_, std::size_t alignment_>
+struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
+ : ::boost::integral_constant<bool,true>
+{
+
+};
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+ template <typename T>
+ typename add_rvalue_reference<T>::type declval();
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+ template <class T, class U = void, class V = void>
+ struct common_type
+ {
+ public:
+ typedef typename common_type<typename common_type<T, U>::type, V>::type type;
+ };
+
+
+
+
+ template<typename T>
+
+
+
+ struct common_type<T, void, void>
+
+
+ {
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)(sizeof(T) > 0) >)> boost_static_assert_typedef_2;
+ public:
+ typedef T type;
+ };
+
+
+namespace type_traits_detail {
+
+ template <class T, class U>
+ struct common_type_2
+ {
+ private:
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)(sizeof(T) > 0) >)> boost_static_assert_typedef_3;
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)(sizeof(U) > 0) >)> boost_static_assert_typedef_4;
+ static bool declval_bool();
+ static typename add_rvalue_reference<T>::type declval_T();
+ static typename add_rvalue_reference::type declval_U();
+ static typename add_rvalue_reference<bool>::type declval_b();
+
+
+
+
+
+
+
+
+
+
+
+ public:
+ typedef typename boost::type_of::msvc_typeid_wrapper<sizeof(*boost::type_of::encode_start(declval_b() ? declval_T() : declval_U()))>::type type;
+
+ };
+
+ template <class T>
+ struct common_type_2<T, T>
+ {
+ typedef T type;
+ };
+ }
+
+
+
+
+
+ template <class T, class U>
+ struct common_type<T, U, void>
+
+ : type_traits_detail::common_type_2<T,U>
+ { };
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template <bool b, class T, class U>
+struct conditional : public mpl::if_c<b, T, U>
+{
+};
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct remove_bounds { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_bounds<T[N]> { typedef T type; };
+template< typename T, std::size_t N > struct remove_bounds<T const[N]> { typedef T const type; };
+template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { typedef T volatile type; };
+template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { typedef T const volatile type; };
+
+template< typename T > struct remove_bounds<T[]> { typedef T type; };
+template< typename T > struct remove_bounds<T const[]> { typedef T const type; };
+template< typename T > struct remove_bounds<T volatile[]> { typedef T volatile type; };
+template< typename T > struct remove_bounds<T const volatile[]> { typedef T const volatile type; };
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost
+{
+
+ template< class T >
+ struct decay
+ {
+ private:
+ typedef typename remove_reference<T>::type Ty;
+ public:
+ typedef typename mpl::eval_if<
+ is_array<Ty>,
+ mpl::identity<typename remove_bounds<Ty>::type*>,
+ typename mpl::eval_if<
+ is_function<Ty>,
+ add_pointer<Ty>,
+ mpl::identity<Ty>
+ >
+ >::type type;
+ };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+
+
+
+
+
+
+
+
+
+template <class T, std::size_t N>
+struct extent_imp
+{
+ static const std::size_t value = 0;
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T[R], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const[R], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T volatile[R], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const volatile[R], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T[R],0>
+{
+ static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const[R], 0>
+{
+ static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T volatile[R], 0>
+{
+ static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const volatile[R], 0>
+{
+ static const std::size_t value = R;
+};
+
+
+template <class T, std::size_t N>
+struct extent_imp<T[], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const[], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T volatile[], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const volatile[], N>
+{
+ static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T>
+struct extent_imp<T[], 0>
+{
+ static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const[], 0>
+{
+ static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T volatile[], 0>
+{
+ static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const volatile[], 0>
+{
+ static const std::size_t value = 0;
+};
+
+
+
+
+}
+
+template <class T, std::size_t N = 0>
+struct extent
+ : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
+{
+
+
+
+
+
+};
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace type_traits { namespace detail {
+
+
+
+template<class T>
+struct floating_point_promotion
+{
+ typedef T type;
+};
+
+template<>
+struct floating_point_promotion<float>
+{
+ typedef double type;
+};
+
+template<>
+struct floating_point_promotion<float const>
+{
+ typedef double const type;
+};
+
+template<>
+struct floating_point_promotion<float volatile>
+{
+ typedef double volatile type;
+};
+
+template<>
+struct floating_point_promotion<float const volatile>
+{
+ typedef double const volatile type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+} }
+
+template< typename T > struct floating_point_promotion { typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+namespace detail {
+
+template<typename Function> struct function_traits_helper;
+
+template<typename R>
+struct function_traits_helper<R (*)(void)>
+{
+ static const unsigned arity = 0;
+ typedef R result_type;
+};
+
+template<typename R, typename T1>
+struct function_traits_helper<R (*)(T1)>
+{
+ static const unsigned arity = 1;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T1 argument_type;
+};
+
+template<typename R, typename T1, typename T2>
+struct function_traits_helper<R (*)(T1, T2)>
+{
+ static const unsigned arity = 2;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T1 first_argument_type;
+ typedef T2 second_argument_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3>
+struct function_traits_helper<R (*)(T1, T2, T3)>
+{
+ static const unsigned arity = 3;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+struct function_traits_helper<R (*)(T1, T2, T3, T4)>
+{
+ static const unsigned arity = 4;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
+{
+ static const unsigned arity = 5;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
+{
+ static const unsigned arity = 6;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+ typedef T6 arg6_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
+{
+ static const unsigned arity = 7;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+ typedef T6 arg6_type;
+ typedef T7 arg7_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
+{
+ static const unsigned arity = 8;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+ typedef T6 arg6_type;
+ typedef T7 arg7_type;
+ typedef T8 arg8_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8, typename T9>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
+{
+ static const unsigned arity = 9;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+ typedef T6 arg6_type;
+ typedef T7 arg7_type;
+ typedef T8 arg8_type;
+ typedef T9 arg9_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8, typename T9,
+ typename T10>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
+{
+ static const unsigned arity = 10;
+ typedef R result_type;
+ typedef T1 arg1_type;
+ typedef T2 arg2_type;
+ typedef T3 arg3_type;
+ typedef T4 arg4_type;
+ typedef T5 arg5_type;
+ typedef T6 arg6_type;
+ typedef T7 arg7_type;
+ typedef T8 arg8_type;
+ typedef T9 arg9_type;
+ typedef T10 arg10_type;
+};
+
+}
+
+template<typename Function>
+struct function_traits :
+ public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
+{
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+
+
+
+
+
+
+
+typedef void (__cdecl * new_handler) ();
+
+
+
+
+struct nothrow_t
+ {
+ };
+
+extern const nothrow_t nothrow;
+
+
+
+ new_handler __cdecl set_new_handler(new_handler)
+ throw ();
+}
+
+
+void __cdecl operator delete(void *) throw ();
+ void *__cdecl operator new(size_t _Size) throw (...);
+
+
+
+inline void *__cdecl operator new(size_t, void *_Where) throw ()
+ {
+ return (_Where);
+ }
+
+inline void __cdecl operator delete(void *, void *) throw ()
+ {
+ }
+
+
+
+
+inline void *__cdecl operator new[](size_t, void *_Where) throw ()
+ {
+ return (_Where);
+ }
+
+inline void __cdecl operator delete[](void *, void *) throw ()
+ {
+ }
+
+
+void __cdecl operator delete[](void *) throw ();
+
+ void *__cdecl operator new[](size_t _Size)
+ throw (...);
+
+
+
+ void *__cdecl operator new(size_t _Size, const std::nothrow_t&)
+ throw ();
+
+ void *__cdecl operator new[](size_t _Size, const std::nothrow_t&)
+ throw ();
+
+void __cdecl operator delete(void *, const std::nothrow_t&)
+ throw ();
+
+void __cdecl operator delete[](void *, const std::nothrow_t&)
+ throw ();
+
+
+
+
+
+using std::new_handler;
+
+
+
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace detail {
+ template <class U, U x>
+ struct test;
+
+ template <typename T>
+ struct has_new_operator_impl {
+ template<class U>
+ static type_traits::yes_type check_sig1(
+ U*,
+ test<
+ void *(*)(std::size_t),
+ &U::operator new
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig1(...);
+
+ template<class U>
+ static type_traits::yes_type check_sig2(
+ U*,
+ test<
+ void *(*)(std::size_t, const std::nothrow_t&),
+ &U::operator new
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig2(...);
+
+ template<class U>
+ static type_traits::yes_type check_sig3(
+ U*,
+ test<
+ void *(*)(std::size_t, void*),
+ &U::operator new
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig3(...);
+
+
+ template<class U>
+ static type_traits::yes_type check_sig4(
+ U*,
+ test<
+ void *(*)(std::size_t),
+ &U::operator new[]
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig4(...);
+
+ template<class U>
+ static type_traits::yes_type check_sig5(
+ U*,
+ test<
+ void *(*)(std::size_t, const std::nothrow_t&),
+ &U::operator new[]
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig5(...);
+
+ template<class U>
+ static type_traits::yes_type check_sig6(
+ U*,
+ test<
+ void *(*)(std::size_t, void*),
+ &U::operator new[]
+ >* = 0
+ );
+ template<class U>
+ static type_traits::no_type check_sig6(...);
+
+
+
+
+
+
+
+
+
+
+
+
+ #pragma warning(push)
+ #pragma warning(disable:6334)
+
+
+ static const unsigned s1 = sizeof(check_sig1<T>(0));
+ static const unsigned s2 = sizeof(check_sig2<T>(0));
+ static const unsigned s3 = sizeof(check_sig3<T>(0));
+ static const unsigned s4 = sizeof(check_sig4<T>(0));
+ static const unsigned s5 = sizeof(check_sig5<T>(0));
+ static const unsigned s6 = sizeof(check_sig6<T>(0));
+
+
+ #pragma warning(pop)
+
+
+ static const bool value = (::boost::type_traits::ice_or< (s1 == sizeof(type_traits::yes_type)), (s2 == sizeof(type_traits::yes_type)), (s3 == sizeof(type_traits::yes_type)), (s4 == sizeof(type_traits::yes_type)), (s5 == sizeof(type_traits::yes_type)), (s6 == sizeof(type_traits::yes_type)) >::value);
+ };
+}
+
+template< typename T > struct has_new_operator : ::boost::integral_constant<bool,::boost::detail::has_new_operator_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+namespace detail{
+
+
+
+
+template <class T>
+struct is_const_rvalue_filter
+{
+
+
+
+ static const bool value = ::boost::detail::cv_traits_imp<T*>::is_const;
+
+};
+
+
+
+
+
+
+
+}
+
+
+template< typename T > struct is_const : ::boost::integral_constant<bool,::boost::detail::is_const_rvalue_filter<T>::value> { };
+template< typename T > struct is_const< T& > : ::boost::integral_constant<bool,false> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+template <class T>
+struct is_volatile_rval_filter
+{
+
+
+
+ static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
+
+};
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+template< typename T > struct is_volatile : ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { };
+template< typename T > struct is_volatile< T& > : ::boost::integral_constant<bool,false> { };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_assign_impl
+{
+ static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_assign(T) >::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);
+};
+
+}
+
+template< typename T > struct has_trivial_assign : ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_assign_imp{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_assign<T>::value, __has_nothrow_assign(T) >::value);
+};
+
+}
+
+template< typename T > struct has_nothrow_assign : ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_ctor_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_constructor(T) >::value);
+};
+
+}
+
+template< typename T > struct has_trivial_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
+template< typename T > struct has_trivial_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_constructor_imp{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_constructor<T>::value, __has_nothrow_constructor(T) >::value);
+};
+
+}
+
+template< typename T > struct has_nothrow_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
+template< typename T > struct has_nothrow_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_copy_impl
+{
+ static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_copy(T) >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);
+};
+
+}
+
+template< typename T > struct has_trivial_copy : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
+template< typename T > struct has_trivial_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_copy_imp{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_copy<T>::value, __has_nothrow_copy(T) >::value);
+};
+
+}
+
+template< typename T > struct has_nothrow_copy : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
+template< typename T > struct has_nothrow_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_dtor_impl
+{
+ static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_destructor(T) >::value);
+};
+
+}
+
+template< typename T > struct has_trivial_destructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct has_nothrow_destructor : ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct has_virtual_destructor : ::boost::integral_constant<bool,__has_virtual_destructor(T)> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace detail{
+
+
+template <class T>
+struct is_abstract_imp
+{
+ static const bool value = __is_abstract(T);
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename B, typename D>
+struct is_base_and_derived_impl
+{
+ typedef typename remove_cv::type ncvB;
+ typedef typename remove_cv<D>::type ncvD;
+
+ static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
+};
+
+}
+
+template< typename Base, typename Derived > struct is_base_and_derived : ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { };
+
+
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : ::boost::integral_constant<bool,false> { };
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename T>
+struct is_class_impl
+{
+ static const bool value = __is_class(T);
+};
+
+
+}
+
+
+
+
+
+template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+ namespace detail{
+ template <class B, class D>
+ struct is_base_of_imp
+ {
+ typedef typename remove_cv::type ncvB;
+ typedef typename remove_cv<D>::type ncvD;
+ static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value);
+ };
+ }
+
+template< typename Base, typename Derived > struct is_base_of : ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { };
+
+
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : ::boost::integral_constant<bool,false> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace detail {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+ static ::boost::type_traits::no_type __cdecl _m_check(...);
+ static ::boost::type_traits::yes_type __cdecl _m_check(To);
+ static From _m_from;
+
+#pragma warning(push)
+#pragma warning(disable:4244)
+
+#pragma warning(disable:6334)
+
+
+ static const bool value = sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type);
+
+#pragma warning(pop)
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template <typename From, typename To>
+struct is_convertible_impl
+{
+ typedef typename add_reference<From>::type ref_type;
+ static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value);
+};
+
+
+template <bool trivial1, bool trivial2, bool abstract_target>
+struct is_convertible_impl_select
+{
+ template <class From, class To>
+ struct rebind
+ {
+ typedef is_convertible_impl<From, To> type;
+ };
+};
+
+template <>
+struct is_convertible_impl_select<true, true, false>
+{
+ template <class From, class To>
+ struct rebind
+ {
+ typedef true_type type;
+ };
+};
+
+template <>
+struct is_convertible_impl_select<false, false, true>
+{
+ template <class From, class To>
+ struct rebind
+ {
+ typedef false_type type;
+ };
+};
+
+template <>
+struct is_convertible_impl_select<true, false, true>
+{
+ template <class From, class To>
+ struct rebind
+ {
+ typedef false_type type;
+ };
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch_base
+{
+
+ typedef is_convertible_impl_select<
+ ::boost::is_arithmetic<From>::value,
+ ::boost::is_arithmetic<To>::value,
+
+ ::boost::is_abstract<To>::value
+
+
+
+ > selector;
+
+
+
+ typedef typename selector::template rebind<From, To> isc_binder;
+ typedef typename isc_binder::type type;
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch
+ : public is_convertible_impl_dispatch_base<From, To>::type
+{};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<>
struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
+
+
+
+
+
+
+
+
+
+template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void > { static const bool value = (true); };
+
+template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (true); };
+template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (true); };
+template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (true); };
+
+
+
+}
+
+template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { };
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+extern "C" {
+
+
+
+#pragma pack(push,8)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef union
+ {
+ unsigned short _Word[8];
+ float _Float;
+ double _Double;
+ long double _Long_double;
+ } _Dconst;
+
+
+void __cdecl _Feraise(int);
+
+
+ double __cdecl _Cosh(double, double);
+ short __cdecl _Dtest(double *);
+ short __cdecl _Exp(double *, double, short);
+ double __cdecl _Sinh(double, double);
+extern _Dconst _Denorm, _Hugeval, _Inf,
+ _Nan, _Snan;
+
+
+ float __cdecl _FCosh(float, float);
+ short __cdecl _FDtest(float *);
+ short __cdecl _FExp(float *, float, short);
+ float __cdecl _FSinh(float, float);
+extern _Dconst _FDenorm, _FInf, _FNan, _FSnan;
+
+
+ long double __cdecl _LCosh(long double, long double);
+ short __cdecl _LDtest(long double *);
+ short __cdecl _LExp(long double *, long double, short);
+ long double __cdecl _LSinh(long double, long double);
+extern _Dconst _LDenorm, _LInf, _LNan, _LSnan;
+
+}
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+struct _exception {
+ int type;
+ char *name;
+ double arg1;
+ double arg2;
+ double retval;
+ } ;
+
+
+
+
+
+
+
+
+
+
+struct _complex {
+ double x,y;
+ } ;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern double _HUGE;
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl abs( int _X);
+ long __cdecl labs( long _X);
+
+
+ double __cdecl acos( double _X);
+ double __cdecl asin( double _X);
+ double __cdecl atan( double _X);
+ double __cdecl atan2( double _Y, double _X);
+
+ double __cdecl _copysign ( double _Number, double _Sign);
+ double __cdecl _chgsign ( double _X);
+
+
+ double __cdecl cos( double _X);
+ double __cdecl cosh( double _X);
+ double __cdecl exp( double _X);
+ double __cdecl fabs( double _X);
+ double __cdecl fmod( double _X, double _Y);
+ double __cdecl log( double _X);
+ double __cdecl log10( double _X);
+ double __cdecl pow( double _X, double _Y);
+ double __cdecl sin( double _X);
+ double __cdecl sinh( double _X);
+ double __cdecl tan( double _X);
+ double __cdecl tanh( double _X);
+ double __cdecl sqrt( double _X);
+
+
+ double __cdecl atof( const char *_String);
+ double __cdecl _atof_l( const char *_String, _locale_t _Locale);
+
+
+ double __cdecl _cabs( struct _complex _Complex);
+ double __cdecl ceil( double _X);
+ double __cdecl floor( double _X);
+ double __cdecl frexp( double _X, int * _Y);
+ double __cdecl _hypot( double _X, double _Y);
+ double __cdecl _j0( double _X );
+ double __cdecl _j1( double _X );
+ double __cdecl _jn(int _X, double _Y);
+ double __cdecl ldexp( double _X, int _Y);
+
+
+
+
+
+ int __cdecl _matherr( struct _exception * _Except);
+
+
+ double __cdecl modf( double _X, double * _Y);
+
+ double __cdecl _y0( double _X);
+ double __cdecl _y1( double _X);
+ double __cdecl _yn( int _X, double _Y);
+
+
+
+
+ int __cdecl _set_SSE2_enable( int _Flag);
+ float __cdecl _hypotf( float _X, float _Y);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+inline long double acosl( long double _X)
+ {return (acos((double)_X)); }
+inline long double asinl( long double _X)
+ {return (asin((double)_X)); }
+inline long double atanl( long double _X)
+ {return (atan((double)_X)); }
+inline long double atan2l( long double _X, long double _Y)
+ {return (atan2((double)_X, (double)_Y)); }
+inline long double ceill( long double _X)
+ {return (ceil((double)_X)); }
+inline long double cosl( long double _X)
+ {return (cos((double)_X)); }
+inline long double coshl( long double _X)
+ {return (cosh((double)_X)); }
+inline long double expl( long double _X)
+ {return (exp((double)_X)); }
+inline long double fabsl( long double _X)
+ {return (fabs((double)_X)); }
+inline long double floorl( long double _X)
+ {return (floor((double)_X)); }
+inline long double fmodl( long double _X, long double _Y)
+ {return (fmod((double)_X, (double)_Y)); }
+inline long double frexpl( long double _X, int *_Y)
+ {return (frexp((double)_X, _Y)); }
+inline long double ldexpl( long double _X, int _Y)
+ {return (ldexp((double)_X, _Y)); }
+inline long double logl( long double _X)
+ {return (log((double)_X)); }
+inline long double log10l( long double _X)
+ {return (log10((double)_X)); }
+inline long double modfl( long double _X, long double *_Y)
+ {double _Di, _Df = modf((double)_X, &_Di);
+ *_Y = (long double)_Di;
+ return (_Df); }
+inline long double powl( long double _X, long double _Y)
+ {return (pow((double)_X, (double)_Y)); }
+inline long double sinl( long double _X)
+ {return (sin((double)_X)); }
+inline long double sinhl( long double _X)
+ {return (sinh((double)_X)); }
+inline long double sqrtl( long double _X)
+ {return (sqrt((double)_X)); }
+
+inline long double tanl( long double _X)
+ {return (tan((double)_X)); }
+
+
+
+
+inline long double tanhl( long double _X)
+ {return (tanh((double)_X)); }
+
+inline long double _chgsignl( long double _Number)
+{
+ return _chgsign(static_cast<double>(_Number));
+}
+
+inline long double _copysignl( long double _Number, long double _Sign)
+{
+ return _copysign(static_cast<double>(_Number), static_cast<double>(_Sign));
+}
+
+inline float frexpf( float _X, int *_Y)
+ {return ((float)frexp((double)_X, _Y)); }
+
+
+inline float fabsf( float _X)
+ {return ((float)fabs((double)_X)); }
+inline float ldexpf( float _X, int _Y)
+ {return ((float)ldexp((double)_X, _Y)); }
+
+inline float acosf( float _X)
+ {return ((float)acos((double)_X)); }
+inline float asinf( float _X)
+ {return ((float)asin((double)_X)); }
+inline float atanf( float _X)
+ {return ((float)atan((double)_X)); }
+inline float atan2f( float _X, float _Y)
+ {return ((float)atan2((double)_X, (double)_Y)); }
+inline float ceilf( float _X)
+ {return ((float)ceil((double)_X)); }
+inline float cosf( float _X)
+ {return ((float)cos((double)_X)); }
+inline float coshf( float _X)
+ {return ((float)cosh((double)_X)); }
+inline float expf( float _X)
+ {return ((float)exp((double)_X)); }
+inline float floorf( float _X)
+ {return ((float)floor((double)_X)); }
+inline float fmodf( float _X, float _Y)
+ {return ((float)fmod((double)_X, (double)_Y)); }
+inline float logf( float _X)
+ {return ((float)log((double)_X)); }
+inline float log10f( float _X)
+ {return ((float)log10((double)_X)); }
+inline float modff( float _X, float *_Y)
+ { double _Di, _Df = modf((double)_X, &_Di);
+ *_Y = (float)_Di;
+ return ((float)_Df); }
+inline float powf( float _X, float _Y)
+ {return ((float)pow((double)_X, (double)_Y)); }
+inline float sinf( float _X)
+ {return ((float)sin((double)_X)); }
+inline float sinhf( float _X)
+ {return ((float)sinh((double)_X)); }
+inline float sqrtf( float _X)
+ {return ((float)sqrt((double)_X)); }
+inline float tanf( float _X)
+ {return ((float)tan((double)_X)); }
+inline float tanhf( float _X)
+ {return ((float)tanh((double)_X)); }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern double HUGE;
+
+
+
+
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_cabs" ". See online help for details.")) double __cdecl cabs( struct _complex _X);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_hypot" ". See online help for details.")) double __cdecl hypot( double _X, double _Y);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_j0" ". See online help for details.")) double __cdecl j0( double _X);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_j1" ". See online help for details.")) double __cdecl j1( double _X);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_jn" ". See online help for details.")) double __cdecl jn( int _X, double _Y);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_y0" ". See online help for details.")) double __cdecl y0( double _X);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_y1" ". See online help for details.")) double __cdecl y1( double _X);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_yn" ". See online help for details.")) double __cdecl yn( int _X, double _Y);
+
+
+
+
+
+
+}
+
+extern "C++" {
+
+template<class _Ty> inline
+ _Ty _Pow_int(_Ty _X, int _Y)
+ {unsigned int _N;
+ if (_Y >= 0)
+ _N = (unsigned int)_Y;
+ else
+ _N = (unsigned int)(-_Y);
+ for (_Ty _Z = _Ty(1); ; _X *= _X)
+ {if ((_N & 1) != 0)
+ _Z *= _X;
+ if ((_N >>= 1) == 0)
+ return (_Y < 0 ? _Ty(1) / _Z : _Z); }}
+
+inline long __cdecl abs( long _X)
+ {return (labs(_X)); }
+inline double __cdecl abs( double _X)
+ {return (fabs(_X)); }
+inline double __cdecl pow( double _X, int _Y)
+ {return (_Pow_int(_X, _Y)); }
+inline float __cdecl abs( float _X)
+ {return (fabsf(_X)); }
+inline float __cdecl acos( float _X)
+ {return (acosf(_X)); }
+inline float __cdecl asin( float _X)
+ {return (asinf(_X)); }
+inline float __cdecl atan( float _X)
+ {return (atanf(_X)); }
+inline float __cdecl atan2( float _Y, float _X)
+ {return (atan2f(_Y, _X)); }
+inline float __cdecl ceil( float _X)
+ {return (ceilf(_X)); }
+inline float __cdecl cos( float _X)
+ {return (cosf(_X)); }
+inline float __cdecl cosh( float _X)
+ {return (coshf(_X)); }
+inline float __cdecl exp( float _X)
+ {return (expf(_X)); }
+inline float __cdecl fabs( float _X)
+ {return (fabsf(_X)); }
+inline float __cdecl floor( float _X)
+ {return (floorf(_X)); }
+inline float __cdecl fmod( float _X, float _Y)
+ {return (fmodf(_X, _Y)); }
+inline float __cdecl frexp( float _X, int * _Y)
+ {return (frexpf(_X, _Y)); }
+inline float __cdecl ldexp( float _X, int _Y)
+ {return (ldexpf(_X, _Y)); }
+inline float __cdecl log( float _X)
+ {return (logf(_X)); }
+inline float __cdecl log10( float _X)
+ {return (log10f(_X)); }
+inline float __cdecl modf( float _X, float * _Y)
+ {return (modff(_X, _Y)); }
+inline float __cdecl pow( float _X, float _Y)
+ {return (powf(_X, _Y)); }
+inline float __cdecl pow( float _X, int _Y)
+ {return (_Pow_int(_X, _Y)); }
+inline float __cdecl sin( float _X)
+ {return (sinf(_X)); }
+inline float __cdecl sinh( float _X)
+ {return (sinhf(_X)); }
+inline float __cdecl sqrt( float _X)
+ {return (sqrtf(_X)); }
+inline float __cdecl tan( float _X)
+ {return (tanf(_X)); }
+inline float __cdecl tanh( float _X)
+ {return (tanhf(_X)); }
+inline long double __cdecl abs( long double _X)
+ {return (fabsl(_X)); }
+inline long double __cdecl acos( long double _X)
+ {return (acosl(_X)); }
+inline long double __cdecl asin( long double _X)
+ {return (asinl(_X)); }
+inline long double __cdecl atan( long double _X)
+ {return (atanl(_X)); }
+inline long double __cdecl atan2( long double _Y, long double _X)
+ {return (atan2l(_Y, _X)); }
+inline long double __cdecl ceil( long double _X)
+ {return (ceill(_X)); }
+inline long double __cdecl cos( long double _X)
+ {return (cosl(_X)); }
+inline long double __cdecl cosh( long double _X)
+ {return (coshl(_X)); }
+inline long double __cdecl exp( long double _X)
+ {return (expl(_X)); }
+inline long double __cdecl fabs( long double _X)
+ {return (fabsl(_X)); }
+inline long double __cdecl floor( long double _X)
+ {return (floorl(_X)); }
+inline long double __cdecl fmod( long double _X, long double _Y)
+ {return (fmodl(_X, _Y)); }
+inline long double __cdecl frexp( long double _X, int * _Y)
+ {return (frexpl(_X, _Y)); }
+inline long double __cdecl ldexp( long double _X, int _Y)
+ {return (ldexpl(_X, _Y)); }
+inline long double __cdecl log( long double _X)
+ {return (logl(_X)); }
+inline long double __cdecl log10( long double _X)
+ {return (log10l(_X)); }
+inline long double __cdecl modf( long double _X, long double * _Y)
+ {return (modfl(_X, _Y)); }
+inline long double __cdecl pow( long double _X, long double _Y)
+ {return (powl(_X, _Y)); }
+inline long double __cdecl pow( long double _X, int _Y)
+ {return (_Pow_int(_X, _Y)); }
+inline long double __cdecl sin( long double _X)
+ {return (sinl(_X)); }
+inline long double __cdecl sinh( long double _X)
+ {return (sinhl(_X)); }
+inline long double __cdecl sqrt( long double _X)
+ {return (sqrtl(_X)); }
+inline long double __cdecl tan( long double _X)
+ {return (tanl(_X)); }
+inline long double __cdecl tanh( long double _X)
+ {return (tanhl(_X)); }
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+using ::acosf; using ::asinf;
+using ::atanf; using ::atan2f; using ::ceilf;
+using ::cosf; using ::coshf; using ::expf;
+using ::fabsf; using ::floorf; using ::fmodf;
+using ::frexpf; using ::ldexpf; using ::logf;
+using ::log10f; using ::modff; using ::powf;
+using ::sinf; using ::sinhf; using ::sqrtf;
+using ::tanf; using ::tanhf;
+
+using ::acosl; using ::asinl;
+using ::atanl; using ::atan2l; using ::ceill;
+using ::cosl; using ::coshl; using ::expl;
+using ::fabsl; using ::floorl; using ::fmodl;
+using ::frexpl; using ::ldexpl; using ::logl;
+using ::log10l; using ::modfl; using ::powl;
+using ::sinl; using ::sinhl; using ::sqrtl;
+using ::tanl; using ::tanhl;
+
+using ::abs;
+using ::acos; using ::asin;
+using ::atan; using ::atan2; using ::ceil;
+using ::cos; using ::cosh; using ::exp;
+using ::fabs; using ::floor; using ::fmod;
+using ::frexp; using ::ldexp; using ::log;
+using ::log10; using ::modf; using ::pow;
+using ::sin; using ::sinh; using ::sqrt;
+using ::tan; using ::tanh;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+ #pragma warning(disable: 4514)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int (__cdecl * _onexit_t)(void);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef struct _div_t {
+ int quot;
+ int rem;
+} div_t;
+
+typedef struct _ldiv_t {
+ long quot;
+ long rem;
+} ldiv_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(4)
+typedef struct {
+ unsigned char ld[10];
+} _LDOUBLE;
+#pragma pack()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef struct {
+ double x;
+} _CRT_DOUBLE;
+
+typedef struct {
+ float f;
+} _CRT_FLOAT;
+
+
+
+
+
+typedef struct {
+
+
+
+ long double x;
+} _LONGDOUBLE;
+
+
+
+#pragma pack(4)
+typedef struct {
+ unsigned char ld12[12];
+} _LDBL12;
+#pragma pack()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern int __mb_cur_max;
+
+
+
+
+ int __cdecl ___mb_cur_max_func(void);
+ int __cdecl ___mb_cur_max_l_func(_locale_t);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef void (__cdecl *_purecall_handler)(void);
+
+
+ _purecall_handler __cdecl _set_purecall_handler( _purecall_handler _Handler);
+ _purecall_handler __cdecl _get_purecall_handler();
+
+
+
+extern "C++"
+{
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+typedef void (__cdecl *_invalid_parameter_handler)(const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, uintptr_t);
+
+
+ _invalid_parameter_handler __cdecl _set_invalid_parameter_handler( _invalid_parameter_handler _Handler);
+ _invalid_parameter_handler __cdecl _get_invalid_parameter_handler(void);
+
+
+
+extern "C++"
+{
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+ unsigned long * __cdecl __doserrno(void);
+
+
+errno_t __cdecl _set_doserrno( unsigned long _Value);
+errno_t __cdecl _get_doserrno( unsigned long * _Value);
+
+
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char ** __cdecl __sys_errlist(void);
+
+
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int * __cdecl __sys_nerr(void);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern int __argc;
+ extern char ** __argv;
+ extern wchar_t ** __wargv;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern char ** _environ;
+ extern wchar_t ** _wenviron;
+
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_pgmptr" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) extern char * _pgmptr;
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_wpgmptr" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) extern wchar_t * _wpgmptr;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+errno_t __cdecl _get_pgmptr( char ** _Value);
+errno_t __cdecl _get_wpgmptr( wchar_t ** _Value);
+
+
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_fmode" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) extern int _fmode;
+
+
+
+
+
+ errno_t __cdecl _set_fmode( int _Mode);
+ errno_t __cdecl _get_fmode( int * _PMode);
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4141)
+
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_osplatform" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) extern unsigned int _osplatform;
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_osver" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) extern unsigned int _osver;
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_winver" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) extern unsigned int _winver;
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_winmajor" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) extern unsigned int _winmajor;
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_winminor" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) __declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) extern unsigned int _winminor;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(pop)
+
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) errno_t __cdecl _get_osplatform( unsigned int * _Value);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) errno_t __cdecl _get_osver( unsigned int * _Value);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) errno_t __cdecl _get_winver( unsigned int * _Value);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) errno_t __cdecl _get_winmajor( unsigned int * _Value);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "GetVersionEx" "instead. See online help for details.")) errno_t __cdecl _get_winminor( unsigned int * _Value);
+
+
+
+
+
+
+extern "C++"
+{
+template <typename _CountofType, size_t _SizeOfArray>
+char (*__countof_helper( _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+
+}
+
+
+
+
+
+
+
+ __declspec(noreturn) void __cdecl exit( int _Code);
+ __declspec(noreturn) void __cdecl _exit( int _Code);
+ void __cdecl abort(void);
+
+
+ unsigned int __cdecl _set_abort_behavior( unsigned int _Flags, unsigned int _Mask);
+
+
+
+
+
+
+
+
+ __int64 __cdecl _abs64(__int64);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl atexit(void (__cdecl *)(void));
+
+
+
+
+
+
+ int __cdecl atoi( const char *_Str);
+ int __cdecl _atoi_l( const char *_Str, _locale_t _Locale);
+ long __cdecl atol( const char *_Str);
+ long __cdecl _atol_l( const char *_Str, _locale_t _Locale);
+
+
+
+ void * __cdecl bsearch_s( const void * _Key, const void * _Base,
+ rsize_t _NumOfElements, rsize_t _SizeOfElements,
+ int (__cdecl * _PtFuncCompare)(void *, const void *, const void *), void * _Context);
+
+ void * __cdecl bsearch( const void * _Key, const void * _Base,
+ size_t _NumOfElements, size_t _SizeOfElements,
+ int (__cdecl * _PtFuncCompare)(const void *, const void *));
+
+
+ void __cdecl qsort_s( void * _Base,
+ rsize_t _NumOfElements, rsize_t _SizeOfElements,
+ int (__cdecl * _PtFuncCompare)(void *, const void *, const void *), void *_Context);
+
+ void __cdecl qsort( void * _Base,
+ size_t _NumOfElements, size_t _SizeOfElements,
+ int (__cdecl * _PtFuncCompare)(const void *, const void *));
+
+ unsigned short __cdecl _byteswap_ushort( unsigned short _Short);
+ unsigned long __cdecl _byteswap_ulong ( unsigned long _Long);
+
+ unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64 _Int64);
+
+ div_t __cdecl div( int _Numerator, int _Denominator);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_dupenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl getenv( const char * _VarName);
+
+ errno_t __cdecl getenv_s( size_t * _ReturnSize, char * _DstBuf, rsize_t _DstSize, const char * _VarName);
+
+extern "C++" { template <size_t _Size> inline errno_t __cdecl getenv_s( size_t * _ReturnSize, char (&_Dest)[_Size], const char * _VarName) { return getenv_s(_ReturnSize, _Dest, _Size, _VarName); } }
+ errno_t __cdecl _dupenv_s( char **_PBuffer, size_t * _PBufferSizeInBytes, const char * _VarName);
+ errno_t __cdecl _itoa_s( int _Value, char * _DstBuf, size_t _Size, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _itoa_s( int _Value, char (&_Dest)[_Size], int _Radix) { return _itoa_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_itoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _itoa( int _Value, char *_Dest, int _Radix);
+
+ errno_t __cdecl _i64toa_s( __int64 _Val, char * _DstBuf, size_t _Size, int _Radix);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_i64toa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _i64toa( __int64 _Val, char * _DstBuf, int _Radix);
+ errno_t __cdecl _ui64toa_s( unsigned __int64 _Val, char * _DstBuf, size_t _Size, int _Radix);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ui64toa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _ui64toa( unsigned __int64 _Val, char * _DstBuf, int _Radix);
+ __int64 __cdecl _atoi64( const char * _String);
+ __int64 __cdecl _atoi64_l( const char * _String, _locale_t _Locale);
+ __int64 __cdecl _strtoi64( const char * _String, char ** _EndPtr, int _Radix);
+ __int64 __cdecl _strtoi64_l( const char * _String, char ** _EndPtr, int _Radix, _locale_t _Locale);
+ unsigned __int64 __cdecl _strtoui64( const char * _String, char ** _EndPtr, int _Radix);
+ unsigned __int64 __cdecl _strtoui64_l( const char * _String, char ** _EndPtr, int _Radix, _locale_t _Locale);
+
+ ldiv_t __cdecl ldiv( long _Numerator, long _Denominator);
+
+extern "C++"
+{
+ inline ldiv_t div( long _A1, long _A2)
+ {
+ return ldiv(_A1, _A2);
+ }
+}
+
+ errno_t __cdecl _ltoa_s( long _Val, char * _DstBuf, size_t _Size, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _ltoa_s( long _Value, char (&_Dest)[_Size], int _Radix) { return _ltoa_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _ltoa( long _Value, char *_Dest, int _Radix);
+ int __cdecl mblen( const char * _Ch, size_t _MaxCount);
+ int __cdecl _mblen_l( const char * _Ch, size_t _MaxCount, _locale_t _Locale);
+ size_t __cdecl _mbstrlen( const char * _Str);
+ size_t __cdecl _mbstrlen_l( const char *_Str, _locale_t _Locale);
+ size_t __cdecl _mbstrnlen( const char *_Str, size_t _MaxCount);
+ size_t __cdecl _mbstrnlen_l( const char *_Str, size_t _MaxCount, _locale_t _Locale);
+ int __cdecl mbtowc( wchar_t * _DstCh, const char * _SrcCh, size_t _SrcSizeInBytes);
+ int __cdecl _mbtowc_l( wchar_t * _DstCh, const char * _SrcCh, size_t _SrcSizeInBytes, _locale_t _Locale);
+ errno_t __cdecl mbstowcs_s( size_t * _PtNumOfCharConverted, wchar_t * _DstBuf, size_t _SizeInWords, const char * _SrcBuf, size_t _MaxCount );
+extern "C++" { template <size_t _Size> inline errno_t __cdecl mbstowcs_s( size_t * _PtNumOfCharConverted, wchar_t (&_Dest)[_Size], const char * _Source, size_t _MaxCount) { return mbstowcs_s(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "mbstowcs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl mbstowcs( wchar_t *_Dest, const char * _Source, size_t _MaxCount);
+
+ errno_t __cdecl _mbstowcs_s_l( size_t * _PtNumOfCharConverted, wchar_t * _DstBuf, size_t _SizeInWords, const char * _SrcBuf, size_t _MaxCount, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _mbstowcs_s_l( size_t * _PtNumOfCharConverted, wchar_t (&_Dest)[_Size], const char * _Source, size_t _MaxCount, _locale_t _Locale) { return _mbstowcs_s_l(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_mbstowcs_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl _mbstowcs_l( wchar_t *_Dest, const char * _Source, size_t _MaxCount, _locale_t _Locale);
+
+ int __cdecl rand(void);
+
+
+
+
+ int __cdecl _set_error_mode( int _Mode);
+
+ void __cdecl srand( unsigned int _Seed);
+ double __cdecl strtod( const char * _Str, char ** _EndPtr);
+ double __cdecl _strtod_l( const char * _Str, char ** _EndPtr, _locale_t _Locale);
+ long __cdecl strtol( const char * _Str, char ** _EndPtr, int _Radix );
+ long __cdecl _strtol_l( const char *_Str, char **_EndPtr, int _Radix, _locale_t _Locale);
+ unsigned long __cdecl strtoul( const char * _Str, char ** _EndPtr, int _Radix);
+ unsigned long __cdecl _strtoul_l(const char * _Str, char **_EndPtr, int _Radix, _locale_t _Locale);
+
+
+ int __cdecl system( const char * _Command);
+
+ errno_t __cdecl _ultoa_s( unsigned long _Val, char * _DstBuf, size_t _Size, int _Radix);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _ultoa_s( unsigned long _Value, char (&_Dest)[_Size], int _Radix) { return _ultoa_s(_Value, _Dest, _Size, _Radix); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _ultoa( unsigned long _Value, char *_Dest, int _Radix);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "wctomb_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl wctomb( char * _MbCh, wchar_t _WCh);
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctomb_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) int __cdecl _wctomb_l( char * _MbCh, wchar_t _WCh, _locale_t _Locale);
+
+ errno_t __cdecl wctomb_s( int * _SizeConverted, char * _MbCh, rsize_t _SizeInBytes, wchar_t _WCh);
+
+ errno_t __cdecl _wctomb_s_l( int * _SizeConverted, char * _MbCh, size_t _SizeInBytes, wchar_t _WCh, _locale_t _Locale);
+ errno_t __cdecl wcstombs_s( size_t * _PtNumOfCharConverted, char * _Dst, size_t _DstSizeInBytes, const wchar_t * _Src, size_t _MaxCountInBytes);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl wcstombs_s( size_t * _PtNumOfCharConverted, char (&_Dest)[_Size], const wchar_t * _Source, size_t _MaxCount) { return wcstombs_s(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstombs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl wcstombs( char *_Dest, const wchar_t * _Source, size_t _MaxCount);
+ errno_t __cdecl _wcstombs_s_l( size_t * _PtNumOfCharConverted, char * _Dst, size_t _DstSizeInBytes, const wchar_t * _Src, size_t _MaxCountInBytes, _locale_t _Locale);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcstombs_s_l( size_t * _PtNumOfCharConverted, char (&_Dest)[_Size], const wchar_t * _Source, size_t _MaxCount, _locale_t _Locale) { return _wcstombs_s_l(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount, _Locale); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcstombs_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) size_t __cdecl _wcstombs_l( char *_Dest, const wchar_t * _Source, size_t _MaxCount, _locale_t _Locale);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ char * __cdecl _fullpath( char * _FullPath, const char * _Path, size_t _SizeInBytes);
+
+
+
+
+
+ errno_t __cdecl _ecvt_s( char * _DstBuf, size_t _Size, double _Val, int _NumOfDights, int * _PtDec, int * _PtSign);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _ecvt_s( char (&_Dest)[_Size], double _Value, int _NumOfDigits, int * _PtDec, int * _PtSign) { return _ecvt_s(_Dest, _Size, _Value, _NumOfDigits, _PtDec, _PtSign); } }
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ecvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _ecvt( double _Val, int _NumOfDigits, int * _PtDec, int * _PtSign);
+ errno_t __cdecl _fcvt_s( char * _DstBuf, size_t _Size, double _Val, int _NumOfDec, int * _PtDec, int * _PtSign);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _fcvt_s( char (&_Dest)[_Size], double _Value, int _NumOfDigits, int * _PtDec, int * _PtSign) { return _fcvt_s(_Dest, _Size, _Value, _NumOfDigits, _PtDec, _PtSign); } }
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _fcvt( double _Val, int _NumOfDec, int * _PtDec, int * _PtSign);
+ errno_t __cdecl _gcvt_s( char * _DstBuf, size_t _Size, double _Val, int _NumOfDigits);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _gcvt_s( char (&_Dest)[_Size], double _Value, int _NumOfDigits) { return _gcvt_s(_Dest, _Size, _Value, _NumOfDigits); } }
+ __declspec(deprecated("This function or variable may be unsafe. Consider using " "_gcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl _gcvt( double _Val, int _NumOfDigits, char * _DstBuf);
+
+ int __cdecl _atodbl( _CRT_DOUBLE * _Result, char * _Str);
+ int __cdecl _atoldbl( _LDOUBLE * _Result, char * _Str);
+ int __cdecl _atoflt( _CRT_FLOAT * _Result, char * _Str);
+ int __cdecl _atodbl_l( _CRT_DOUBLE * _Result, char * _Str, _locale_t _Locale);
+ int __cdecl _atoldbl_l( _LDOUBLE * _Result, char * _Str, _locale_t _Locale);
+ int __cdecl _atoflt_l( _CRT_FLOAT * _Result, char * _Str, _locale_t _Locale);
+ unsigned long __cdecl _lrotl( unsigned long _Val, int _Shift);
+ unsigned long __cdecl _lrotr( unsigned long _Val, int _Shift);
+ errno_t __cdecl _makepath_s( char * _PathResult, size_t _Size, const char * _Drive, const char * _Dir, const char * _Filename,
+ const char * _Ext);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _makepath_s( char (&_Path)[_Size], const char * _Drive, const char * _Dir, const char * _Filename, const char * _Ext) { return _makepath_s(_Path, _Size, _Drive, _Dir, _Filename, _Ext); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_makepath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _makepath( char *_Path, const char * _Drive, const char * _Dir, const char * _Filename, const char * _Ext);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _onexit_t __cdecl _onexit( _onexit_t _Func);
+
+
+
+
+
+
+ int __cdecl _putenv( const char * _EnvString);
+ errno_t __cdecl _putenv_s( const char * _Name, const char * _Value);
+ unsigned int __cdecl _rotl( unsigned int _Val, int _Shift);
+
+ unsigned __int64 __cdecl _rotl64( unsigned __int64 _Val, int _Shift);
+
+ unsigned int __cdecl _rotr( unsigned int _Val, int _Shift);
+
+ unsigned __int64 __cdecl _rotr64( unsigned __int64 _Val, int _Shift);
+
+ errno_t __cdecl _searchenv_s( const char * _Filename, const char * _EnvVar, char * _ResultPath, size_t _SizeInBytes);
+extern "C++" { template <size_t _Size> inline errno_t __cdecl _searchenv_s( const char * _Filename, const char * _EnvVar, char (&_ResultPath)[_Size]) { return _searchenv_s(_Filename, _EnvVar, _ResultPath, _Size); } }
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_searchenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _searchenv( const char * _Filename, const char * _EnvVar, char *_ResultPath);
+
+__declspec(deprecated("This function or variable may be unsafe. Consider using " "_splitpath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) void __cdecl _splitpath( const char * _FullPath, char * _Drive, char * _Dir, char * _Filename, char * _Ext);
+ errno_t __cdecl _splitpath_s( const char * _FullPath,
+ char * _Drive, size_t _DriveSize,
+ char * _Dir, size_t _DirSize,
+ char * _Filename, size_t _FilenameSize,
+ char * _Ext, size_t _ExtSize);
+extern "C++" { template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t _ExtSize> inline errno_t __cdecl _splitpath_s( const char *_Dest, char (&_Drive)[_DriveSize], char (&_Dir)[_DirSize], char (&_Name)[_NameSize], char (&_Ext)[_ExtSize]) { return _splitpath_s(_Dest, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }
+
+ void __cdecl _swab( char * _Buf1, char * _Buf2, int _SizeInBytes);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "SetErrorMode" "instead. See online help for details.")) void __cdecl _seterrormode( int _Mode);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "Beep" "instead. See online help for details.")) void __cdecl _beep( unsigned _Frequency, unsigned _Duration);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "Sleep" "instead. See online help for details.")) void __cdecl _sleep( unsigned long _Duration);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable: 4141)
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_ecvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ecvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl ecvt( double _Val, int _NumOfDigits, int * _PtDec, int * _PtSign);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_fcvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl fcvt( double _Val, int _NumOfDec, int * _PtDec, int * _PtSign);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_gcvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl gcvt( double _Val, int _NumOfDigits, char * _DstBuf);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_itoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_itoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl itoa( int _Val, char * _DstBuf, int _Radix);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_ltoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl ltoa( long _Val, char * _DstBuf, int _Radix);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_putenv" ". See online help for details.")) int __cdecl putenv( const char * _EnvString);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_swab" ". See online help for details.")) void __cdecl swab( char * _Buf1, char * _Buf2, int _SizeInBytes);
+__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: " "_ultoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")) char * __cdecl ultoa( unsigned long _Val, char * _Dstbuf, int _Radix);
+#pragma warning(pop)
+_onexit_t __cdecl onexit( _onexit_t _Func);
+
+
+
+
+
+
+}
+
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+namespace std {
+using ::size_t; using ::div_t; using ::ldiv_t;
+
+using ::abort; using ::abs; using ::atexit;
+using ::atof; using ::atoi; using ::atol;
+using ::bsearch; using ::calloc; using ::div;
+using ::exit; using ::free; using ::getenv;
+using ::labs; using ::ldiv; using ::malloc;
+using ::mblen; using ::mbstowcs; using ::mbtowc;
+using ::qsort; using ::rand; using ::realloc;
+using ::srand; using ::strtod; using ::strtol;
+using ::strtoul; using ::system;
+using ::wcstombs; using ::wctomb;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+struct _Unchecked_iterator_tag
+ {
+ };
+struct _Range_checked_iterator_tag
+ {
+ };
+
+
+struct _Unchanged_checked_iterator_base_type_tag
+ {
+ };
+
+struct _Different_checked_iterator_base_type_tag
+ {
+ };
+
+
+struct _Undefined_inner_type_tag
+ {
+ };
+
+
+struct _Undefined_move_tag
+ {
+ };
+
+struct _Swap_move_tag
+ {
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct _Container_base
+ {
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct _Iterator_base
+ {
+ typedef _Unchecked_iterator_tag _Checked_iterator_category;
+ typedef _Unchanged_checked_iterator_base_type_tag _Checked_iterator_base_type;
+ typedef _Undefined_inner_type_tag _Inner_type;
+
+
+ _Iterator_base()
+ : _Mycont(0)
+ {
+ }
+
+ const _Container_base *_Mycont;
+
+ };
+
+
+
+typedef _Iterator_base _Iterator_base_secure;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct input_iterator_tag
+ {
+ };
+
+struct output_iterator_tag
+ {
+ };
+
+struct forward_iterator_tag
+ : public input_iterator_tag
+ {
+ };
+
+struct bidirectional_iterator_tag
+ : public forward_iterator_tag
+ {
+ };
+
+struct random_access_iterator_tag
+ : public bidirectional_iterator_tag
+ {
+ };
+
+struct _Int_iterator_tag
+ {
+ };
+
+struct _Float_iterator_tag
+ {
+ };
+
+
+struct _Nonscalar_ptr_iterator_tag
+ {
+ };
+struct _Scalar_ptr_iterator_tag
+ {
+ };
+
+
+template<class _Category,
+ class _Ty,
+ class _Diff = ptrdiff_t,
+ class _Pointer = _Ty *,
+ class _Reference = _Ty&>
+ struct iterator
+ : public _Iterator_base
+
+ {
+ typedef _Category iterator_category;
+ typedef _Ty value_type;
+ typedef _Diff difference_type;
+ typedef _Diff distance_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+ };
+
+template<class _Category,
+ class _Ty,
+ class _Diff = ptrdiff_t,
+ class _Pointer = _Ty *,
+ class _Reference = _Ty&,
+ class _Base_class = _Iterator_base>
+ struct _Iterator_with_base
+ : public _Base_class
+
+ {
+ typedef _Category iterator_category;
+ typedef _Ty value_type;
+ typedef _Diff difference_type;
+ typedef _Diff distance_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+ };
+
+template<class _Ty,
+ class _Diff,
+ class _Pointer,
+ class _Reference>
+ struct _Bidit
+ : public _Iterator_base
+
+ {
+ typedef bidirectional_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef _Diff difference_type;
+ typedef _Diff distance_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+ };
+
+template<class _Ty,
+ class _Diff,
+ class _Pointer,
+ class _Reference>
+ struct _Ranit
+ : public _Iterator_base
+
+ {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef _Diff difference_type;
+ typedef _Diff distance_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+ };
+
+template<class _Ty,
+ class _Diff,
+ class _Pointer,
+ class _Reference,
+ class _Base_class>
+ struct _Ranit_base
+ : public _Base_class
+
+ {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef _Diff difference_type;
+ typedef _Diff distance_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+ };
+
+struct _Outit
+ : public iterator<output_iterator_tag, void, void,
+ void, void>
+ {
+ };
+
+template <class _Base_class>
+struct _Outit_with_base
+ : public _Iterator_with_base<output_iterator_tag, void, void,
+ void, void, _Base_class>
+ {
+ };
+
+
+template<class _Iter>
+ struct iterator_traits
+ {
+ typedef typename _Iter::iterator_category iterator_category;
+ typedef typename _Iter::value_type value_type;
+ typedef typename _Iter::difference_type difference_type;
+ typedef difference_type distance_type;
+ typedef typename _Iter::pointer pointer;
+ typedef typename _Iter::reference reference;
+ };
+
+template<class _Ty>
+ struct iterator_traits<_Ty *>
+ {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef ptrdiff_t difference_type;
+ typedef ptrdiff_t distance_type;
+ typedef _Ty *pointer;
+ typedef _Ty& reference;
+ };
+
+template<class _Ty>
+ struct iterator_traits<const _Ty *>
+ {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef ptrdiff_t difference_type;
+ typedef ptrdiff_t distance_type;
+ typedef const _Ty *pointer;
+ typedef const _Ty& reference;
+ };
+
+template<> struct iterator_traits<_Bool>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef _Bool value_type;
+ typedef _Bool difference_type;
+ typedef _Bool distance_type;
+ typedef _Bool * pointer;
+ typedef _Bool& reference;
+ };
+
+template<> struct iterator_traits<char>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef char value_type;
+ typedef char difference_type;
+ typedef char distance_type;
+ typedef char * pointer;
+ typedef char& reference;
+ };
+
+template<> struct iterator_traits<signed char>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef signed char value_type;
+ typedef signed char difference_type;
+ typedef signed char distance_type;
+ typedef signed char * pointer;
+ typedef signed char& reference;
+ };
+
+template<> struct iterator_traits<unsigned char>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef unsigned char value_type;
+ typedef unsigned char difference_type;
+ typedef unsigned char distance_type;
+ typedef unsigned char * pointer;
+ typedef unsigned char& reference;
+ };
+
+
+template<> struct iterator_traits<wchar_t>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef wchar_t value_type;
+ typedef wchar_t difference_type;
+ typedef wchar_t distance_type;
+ typedef wchar_t * pointer;
+ typedef wchar_t& reference;
+ };
+
+
+template<> struct iterator_traits<short>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef short value_type;
+ typedef short difference_type;
+ typedef short distance_type;
+ typedef short * pointer;
+ typedef short& reference;
+ };
+
+template<> struct iterator_traits<unsigned short>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef unsigned short value_type;
+ typedef unsigned short difference_type;
+ typedef unsigned short distance_type;
+ typedef unsigned short * pointer;
+ typedef unsigned short& reference;
+ };
+
+template<> struct iterator_traits<int>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef int value_type;
+ typedef int difference_type;
+ typedef int distance_type;
+ typedef int * pointer;
+ typedef int& reference;
+ };
+
+template<> struct iterator_traits<unsigned int>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef unsigned int value_type;
+ typedef unsigned int difference_type;
+ typedef unsigned int distance_type;
+ typedef unsigned int * pointer;
+ typedef unsigned int& reference;
+ };
+
+template<> struct iterator_traits<long>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef long value_type;
+ typedef long difference_type;
+ typedef long distance_type;
+ typedef long * pointer;
+ typedef long& reference;
+ };
+
+template<> struct iterator_traits<unsigned long>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef unsigned long value_type;
+ typedef unsigned long difference_type;
+ typedef unsigned long distance_type;
+ typedef unsigned long * pointer;
+ typedef unsigned long& reference;
+ };
+
+template<> struct iterator_traits<double>
+ {
+ typedef _Float_iterator_tag iterator_category;
+ typedef double value_type;
+ typedef double difference_type;
+ typedef double distance_type;
+ typedef double * pointer;
+ typedef double& reference;
+ };
+
+template<> struct iterator_traits<float>
+ {
+ typedef _Float_iterator_tag iterator_category;
+ typedef float value_type;
+ typedef float difference_type;
+ typedef float distance_type;
+ typedef float * pointer;
+ typedef float& reference;
+ };
+
+
+template<> struct iterator_traits<__int64>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef __int64 value_type;
+ typedef __int64 difference_type;
+ typedef __int64 distance_type;
+ typedef __int64 * pointer;
+ typedef __int64& reference;
+ };
+
+template<> struct iterator_traits<unsigned __int64>
+ {
+ typedef _Int_iterator_tag iterator_category;
+ typedef unsigned __int64 value_type;
+ typedef unsigned __int64 difference_type;
+ typedef unsigned __int64 distance_type;
+ typedef unsigned __int64 * pointer;
+ typedef unsigned __int64& reference;
+ };
+
+
+
+template<class _Iter> inline
+ typename iterator_traits<_Iter>::iterator_category
+ __cdecl _Iter_cat(const _Iter&)
+ {
+ typename iterator_traits<_Iter>::iterator_category _Cat;
+ return (_Cat);
+ }
+
+
+
+
+template<class _Cat1, class _Cat2>
+ class _Iter_random_helper
+ {
+ public:
+ typedef forward_iterator_tag _Iter_random_cat;
+ };
+
+template<>
+ class _Iter_random_helper<random_access_iterator_tag, random_access_iterator_tag>
+ {
+ public:
+ typedef random_access_iterator_tag _Iter_random_cat;
+ };
+
+template<class _Cat1, class _Cat2, class _Cat3>
+ class _Iter_random_helper3
+ {
+ public:
+ typedef forward_iterator_tag _Iter_random_cat;
+ };
+
+template<>
+ class _Iter_random_helper3<random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag>
+ {
+ public:
+ typedef random_access_iterator_tag _Iter_random_cat;
+ };
+
+template<class _Iter1, class _Iter2> inline
+ typename _Iter_random_helper<
+ typename iterator_traits<_Iter1>::iterator_category,
+ typename iterator_traits<_Iter2>::iterator_category>::_Iter_random_cat
+ __cdecl _Iter_random(const _Iter1&, const _Iter2&)
+ {
+ typename _Iter_random_helper<
+ iterator_traits<_Iter1>::iterator_category,
+ iterator_traits<_Iter2>::iterator_category>::_Iter_random_cat _Cat;
+ return (_Cat);
+ }
+
+template<class _Iter1, class _Iter2, class _Iter3> inline
+ typename _Iter_random_helper3<
+ typename iterator_traits<_Iter1>::iterator_category,
+ typename iterator_traits<_Iter2>::iterator_category,
+ typename iterator_traits<_Iter3>::iterator_category>::_Iter_random_cat
+ __cdecl _Iter_random(const _Iter1&, const _Iter2&, const _Iter3&)
+ {
+ typename _Iter_random_helper3<
+ iterator_traits<_Iter1>::iterator_category,
+ iterator_traits<_Iter2>::iterator_category,
+ iterator_traits<_Iter3>::iterator_category>::_Iter_random_cat _Cat;
+ return (_Cat);
+ }
+
+
+
+ template <bool _Cond, class _Ty1, class _Ty2>
+ class _If
+ {
+ public:
+ typedef _Ty2 _Result;
+ };
+
+ template <class _Ty1, class _Ty2>
+ class _If<true, _Ty1, _Ty2>
+ {
+ public:
+ typedef _Ty1 _Result;
+ };
+
+
+ template <bool _Secure_validation>
+ class _Secure_validation_helper
+ {
+ public:
+ typedef _Unchecked_iterator_tag _Checked_iterator_category;
+ };
+
+ template <>
+ class _Secure_validation_helper<true>
+ {
+ public:
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+ };
+
+
+
+ template <class _Iter, bool _Inherits_from_iterator_base>
+ class _Checked_iterator_category_helper
+ {
+ public:
+ typedef _Unchecked_iterator_tag _Checked_cat;
+ };
+
+ template <class _Iter>
+ class _Checked_iterator_category_helper<_Iter, true>
+ {
+ public:
+ typedef typename _Iter::_Checked_iterator_category _Checked_cat;
+ };
+
+ template <class _Iter>
+ class _Checked_iterator_category
+ {
+ public:
+ typedef typename _Checked_iterator_category_helper<_Iter, __is_base_of(_Iterator_base, _Iter)>::_Checked_cat _Checked_cat;
+ };
+
+ template<class _Iter>
+ inline
+ typename _Checked_iterator_category<_Iter>::_Checked_cat _Checked_cat(const _Iter&)
+ {
+ typename _Checked_iterator_category<_Iter>::_Checked_cat _Cat;
+ return (_Cat);
+ }
+
+
+ template <class _Iter, bool _Inherits_from_iterator_base>
+ class _Checked_iterator_base_helper2
+ {
+ public:
+ typedef _Unchanged_checked_iterator_base_type_tag _Checked_iterator_base_type;
+ };
+
+ template <class _Iter>
+ class _Checked_iterator_base_helper2<_Iter, true>
+ {
+ public:
+ typedef typename _Iter::_Checked_iterator_base_type _Checked_iterator_base_type;
+ };
+
+ template <class _Iter, class _Base_type>
+ class _Checked_iterator_base_helper1
+ {
+ public:
+ typedef _Different_checked_iterator_base_type_tag _Base_type_tag;
+ typedef _Base_type _Checked_iterator_base_type;
+ };
+
+ template <class _Iter>
+ class _Checked_iterator_base_helper1<_Iter, _Unchanged_checked_iterator_base_type_tag>
+ {
+ public:
+ typedef _Unchanged_checked_iterator_base_type_tag _Base_type_tag;
+ typedef _Iter _Checked_iterator_base_type;
+ };
+
+ template <class _Iter>
+ class _Checked_iterator_base_helper
+ {
+ public:
+ typedef _Checked_iterator_base_helper2<_Iter, __is_base_of(_Iterator_base, _Iter)> _Base_helper2;
+ typedef _Checked_iterator_base_helper1<_Iter, typename _Base_helper2::_Checked_iterator_base_type > _Base_helper1;
+
+ typedef typename _Base_helper1::_Base_type_tag _Checked_iterator_base_type_tag;
+ typedef typename _Base_helper1::_Checked_iterator_base_type _Checked_iterator_base_type;
+ };
+
+ template<class _Iter, class _Base_tag>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(const _Iter &_It, _Base_tag)
+ {
+ return _It._Checked_iterator_base();
+ }
+
+ template<class _Iter>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(const _Iter &_It, _Unchanged_checked_iterator_base_type_tag)
+ {
+ return _It;
+ }
+
+ template<class _Iter, class _Base_tag>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(_Iter &_It, _Base_tag)
+ {
+ return _It._Checked_iterator_base();
+ }
+
+ template<class _Iter>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(_Iter &_It, _Unchanged_checked_iterator_base_type_tag)
+ {
+ return _It;
+ }
+
+ template<class _Iter>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(const _Iter &_It)
+ {
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type_tag _Base_tag;
+ return _Checked_base(_It, _Base_tag);
+ }
+
+ template<class _Iter>
+ inline
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type
+ __cdecl _Checked_base(_Iter &_It)
+ {
+ typename _Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type_tag _Base_tag;
+ return _Checked_base(_It, _Base_tag);
+ }
+
+
+
+ template<class _DstIter, class _BaseIter>
+ inline
+ void __cdecl _Checked_assign_from_base(_DstIter &_Dest, const _BaseIter &_Src)
+ {
+ _Dest._Checked_iterator_assign_from_base(_Src);
+ }
+
+ template<class _Iter>
+ inline
+ void __cdecl _Checked_assign_from_base(_Iter &_Dest, const _Iter &_Src)
+ {
+ _Dest = _Src;
+ }
+
+
+
+
+
+
+
+ template <class _Value>
+ class _Move_operation_category
+ {
+ public:
+ typedef _Undefined_move_tag _Move_cat;
+ };
+
+ template<class _Iter>
+ inline
+ typename _Move_operation_category<typename iterator_traits<_Iter>::value_type>::_Move_cat _Move_cat(const _Iter&)
+ {
+ typename _Move_operation_category<typename iterator_traits<_Iter>::value_type>::_Move_cat _Cat;
+ return (_Cat);
+ }
+
+
+template<class _T1, class _T2, class _Checked_Cat1, class _Checked_Cat2>
+struct _Ptr_cat_with_checked_cat_helper
+ {
+ typedef _Nonscalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<class _T1, class _T2>
+struct _Ptr_cat_helper
+ {
+ typedef typename _Ptr_cat_with_checked_cat_helper<_T1, _T2,
+ typename _Checked_iterator_category<_T1>::_Checked_cat,
+ typename _Checked_iterator_category<_T2>::_Checked_cat>::_Ptr_cat _Ptr_cat;
+ };
+
+template<class _T1, class _T2, class _Checked_Cat1>
+struct _Ptr_cat_with_checked_cat_helper<_T1, _T2, _Checked_Cat1, _Range_checked_iterator_tag>
+ {
+ typedef typename _Ptr_cat_helper<_T1, typename _T2::_Inner_type>::_Ptr_cat _Ptr_cat;
+ };
+
+template<class _T1, class _T2, class _Checked_Cat2>
+struct _Ptr_cat_with_checked_cat_helper<_T1, _T2, _Range_checked_iterator_tag, _Checked_Cat2>
+ {
+ typedef typename _Ptr_cat_helper<typename _T1::_Inner_type, _T2>::_Ptr_cat _Ptr_cat;
+ };
+
+template<class _T1, class _T2>
+struct _Ptr_cat_with_checked_cat_helper<_T1, _T2, _Range_checked_iterator_tag, _Range_checked_iterator_tag>
+ {
+ typedef typename _Ptr_cat_helper<typename _T1::_Inner_type, typename _T2::_Inner_type>::_Ptr_cat _Ptr_cat;
+ };
+
+template<class _T1>
+struct _Ptr_cat_helper<_T1, _Undefined_inner_type_tag>
+ {
+ typedef _Nonscalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<class _T2>
+struct _Ptr_cat_helper<_Undefined_inner_type_tag, _T2>
+ {
+ typedef _Nonscalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<_Undefined_inner_type_tag, _Undefined_inner_type_tag>
+ {
+ typedef _Nonscalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+template<>
+struct _Ptr_cat_helper<_Bool *, _Bool *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const _Bool *, _Bool *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<char *, char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const char *, char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<signed char *, signed char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const signed char *, signed char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<unsigned char *, unsigned char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const unsigned char *, unsigned char *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+
+template<>
+struct _Ptr_cat_helper<wchar_t *, wchar_t *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const wchar_t *, wchar_t *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+template<>
+struct _Ptr_cat_helper<short *, short *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const short *, short *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<unsigned short *, unsigned short *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const unsigned short *, unsigned short *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<int *, int *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const int *, int *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<unsigned int *, unsigned int *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const unsigned int *, unsigned int *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<long *, long *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const long *, long *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<unsigned long *, unsigned long *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const unsigned long *, unsigned long *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<float *, float *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const float *, float *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<double *, double *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const double *, double *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<long double *, long double *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const long double *, long double *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+
+template<>
+struct _Ptr_cat_helper<__int64 *, __int64 *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const __int64 *, __int64 *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<unsigned __int64 *, unsigned __int64 *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<>
+struct _Ptr_cat_helper<const unsigned __int64 *, unsigned __int64 *>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+
+template<class _Ty>
+struct _Ptr_cat_helper<_Ty **, _Ty **>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<class _Ty>
+struct _Ptr_cat_helper<_Ty **, const _Ty **>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<class _Ty>
+struct _Ptr_cat_helper<_Ty *const *, _Ty **>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+template<class _Ty>
+struct _Ptr_cat_helper<_Ty *const *, const _Ty **>
+ {
+ typedef _Scalar_ptr_iterator_tag _Ptr_cat;
+ };
+
+
+template<class _T1, class _T2> inline
+typename _Ptr_cat_helper<_T1, _T2>::_Ptr_cat __cdecl _Ptr_cat(_T1&, _T2&)
+ {
+ typename _Ptr_cat_helper<_T1, _T2>::_Ptr_cat _Cat;
+ return (_Cat);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Iter> inline
+ typename iterator_traits<_Iter>::value_type *__cdecl _Val_type(_Iter)
+ {
+ return (0);
+ }
+
+
+template<class _InIt,
+ class _Diff> inline
+ void __cdecl advance(_InIt& _Where, _Diff _Off)
+ {
+ _Advance(_Where, _Off, _Iter_cat(_Where));
+ }
+
+template<class _InIt,
+ class _Diff> inline
+ void __cdecl _Advance(_InIt& _Where, _Diff _Off, input_iterator_tag)
+ {
+
+
+
+
+
+
+ for (; 0 < _Off; --_Off)
+ ++_Where;
+ }
+
+template<class _FI,
+ class _Diff> inline
+ void __cdecl _Advance(_FI& _Where, _Diff _Off, forward_iterator_tag)
+ {
+
+
+
+
+
+
+ for (; 0 < _Off; --_Off)
+ ++_Where;
+ }
+
+#pragma warning(push)
+#pragma warning(disable: 6295)
+template<class _BI,
+ class _Diff> inline
+ void __cdecl _Advance(_BI& _Where, _Diff _Off, bidirectional_iterator_tag)
+ {
+ for (; 0 < _Off; --_Off)
+ ++_Where;
+ for (; _Off < 0; ++_Off)
+ --_Where;
+ }
+#pragma warning(pop)
+
+template<class _RI,
+ class _Diff> inline
+ void __cdecl _Advance(_RI& _Where, _Diff _Off, random_access_iterator_tag)
+ {
+ _Where += _Off;
+ }
+
+
+
+template<class _Iter> inline
+ typename iterator_traits<_Iter>::difference_type
+ * __cdecl _Dist_type(_Iter)
+ {
+ return (0);
+ }
+
+
+template<class _InIt,
+ class _Diff> inline
+ void __cdecl _Distance2(_InIt _First, _InIt _Last, _Diff& _Off,
+ input_iterator_tag)
+ {
+ for (; _First != _Last; ++_First)
+ ++_Off;
+ }
+
+template<class _FwdIt,
+ class _Diff> inline
+ void __cdecl _Distance2(_FwdIt _First, _FwdIt _Last, _Diff& _Off,
+ forward_iterator_tag)
+ {
+ for (; _First != _Last; ++_First)
+ ++_Off;
+ }
+
+template<class _BidIt,
+ class _Diff> inline
+ void __cdecl _Distance2(_BidIt _First, _BidIt _Last, _Diff& _Off,
+ bidirectional_iterator_tag)
+ {
+ for (; _First != _Last; ++_First)
+ ++_Off;
+ }
+
+template<class _RanIt,
+ class _Diff> inline
+ void __cdecl _Distance2(_RanIt _First, _RanIt _Last, _Diff& _Off,
+ random_access_iterator_tag)
+ {
+
+
+
+
+
+
+
+
+
+ _Off += _Last - _First;
+ }
+
+template<class _InIt> inline
+ typename iterator_traits<_InIt>::difference_type
+ __cdecl distance(_InIt _First, _InIt _Last)
+ {
+ typename iterator_traits<_InIt>::difference_type _Off = 0;
+ _Distance2(_First, _Last, _Off, _Iter_cat(_First));
+ return (_Off);
+ }
+
+
+template<class _InIt,
+ class _Diff> inline
+ void __cdecl _Distance(_InIt _First, _InIt _Last, _Diff& _Off)
+ {
+ _Distance2(_First, _Last, _Off, _Iter_cat(_First));
+ }
+
+
+template<class _RanIt>
+ class reverse_iterator
+ : public _Iterator_base_secure
+ {
+public:
+ typedef reverse_iterator<_RanIt> _Myt;
+ typedef typename iterator_traits<_RanIt>::iterator_category iterator_category;
+ typedef typename iterator_traits<_RanIt>::value_type value_type;
+ typedef typename iterator_traits<_RanIt>::difference_type difference_type;
+ typedef typename iterator_traits<_RanIt>::difference_type distance_type;
+ typedef typename iterator_traits<_RanIt>::pointer pointer;
+ typedef typename iterator_traits<_RanIt>::reference reference;
+ typedef _RanIt iterator_type;
+
+ reverse_iterator()
+ {
+ }
+
+ explicit reverse_iterator(_RanIt _Right)
+ : current(_Right)
+ {
+ }
+
+ template<class _Other>
+ reverse_iterator(const reverse_iterator<_Other>& _Right)
+ : current(_Right.base())
+ {
+ }
+
+ _RanIt base() const
+ {
+ return (current);
+ }
+
+
+ typedef typename ::std:: _Checked_iterator_category<_RanIt>::_Checked_cat _Checked_iterator_category;
+ typedef reverse_iterator<typename _Checked_iterator_base_helper<_RanIt>::_Checked_iterator_base_type> _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ typename _Checked_iterator_base_type _Base(::std:: _Checked_base(current));
+ return _Base;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ ::std:: _Checked_assign_from_base(current, _Base.base());
+ }
+
+
+ reference operator*() const
+ {
+ _RanIt _Tmp = current;
+ return (*--_Tmp);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ --current;
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ --current;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ ++current;
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ ++current;
+ return (_Tmp);
+ }
+
+ template<class _Other>
+ bool _Equal(const reverse_iterator<_Other>& _Right) const
+ {
+ return (current == _Right.base());
+ }
+
+
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ current -= _Off;
+ return (*this);
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ return (_Myt(current - _Off));
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ current += _Off;
+ return (*this);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ return (_Myt(current + _Off));
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+
+ template<class _Other>
+ bool _Less(const reverse_iterator<_Other>& _Right) const
+ {
+ return (_Right.base() < current);
+ }
+
+ template<class _Other>
+ difference_type _Minus(const reverse_iterator<_Other>& _Right) const
+ {
+ return (_Right.base() - current);
+ }
+
+protected:
+ _RanIt current;
+ };
+
+
+template<class _RanIt,
+ class _Diff> inline
+ reverse_iterator<_RanIt> __cdecl operator+(_Diff _Off,
+ const reverse_iterator<_RanIt>& _Right)
+ {
+ return (_Right + _Off);
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ typename reverse_iterator<_RanIt1>::difference_type
+ __cdecl operator-(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (_Left._Minus(_Right));
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator==(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (_Left._Equal(_Right));
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator!=(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator<(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (_Left._Less(_Right));
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator>(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator<=(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _RanIt1,
+ class _RanIt2> inline
+ bool __cdecl operator>=(const reverse_iterator<_RanIt1>& _Left,
+ const reverse_iterator<_RanIt2>& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+
+template<class _BidIt,
+ class _Ty,
+ class _Reference = _Ty&,
+ class _Pointer = _Ty *,
+ class _Diff = ptrdiff_t>
+ class reverse_bidirectional_iterator
+ : public iterator<bidirectional_iterator_tag, _Ty, _Diff,
+ _Pointer, _Reference>
+ {
+public:
+ typedef reverse_bidirectional_iterator<_BidIt, _Ty, _Reference,
+ _Pointer, _Diff> _Myt;
+ typedef _BidIt iterator_type;
+
+ reverse_bidirectional_iterator()
+ {
+ }
+
+ explicit reverse_bidirectional_iterator(_BidIt _Right)
+ : current(_Right)
+ {
+ }
+
+ _BidIt base() const
+ {
+ return (current);
+ }
+
+ _Reference operator*() const
+ {
+ _BidIt _Tmp = current;
+ return (*--_Tmp);
+ }
+
+ _Pointer operator->() const
+ {
+ _Reference _Tmp = **this;
+ return (&_Tmp);
+ }
+
+ _Myt& operator++()
+ {
+ --current;
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ --current;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ ++current;
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ ++current;
+ return (_Tmp);
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+ return (current == _Right.current);
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+protected:
+ _BidIt current;
+ };
+
+
+template<class _BidIt,
+ class _BidIt2 = _BidIt>
+ class _Revbidit
+ : public iterator<
+ typename iterator_traits<_BidIt>::iterator_category,
+ typename iterator_traits<_BidIt>::value_type,
+ typename iterator_traits<_BidIt>::difference_type,
+ typename iterator_traits<_BidIt>::pointer,
+ typename iterator_traits<_BidIt>::reference>
+ {
+public:
+ typedef _Revbidit<_BidIt, _BidIt2> _Myt;
+ typedef typename iterator_traits<_BidIt>::difference_type _Diff;
+ typedef typename iterator_traits<_BidIt>::pointer _Pointer;
+ typedef typename iterator_traits<_BidIt>::reference _Reference;
+ typedef _BidIt iterator_type;
+
+ _Revbidit()
+ {
+ }
+
+ explicit _Revbidit(_BidIt _Right)
+ : current(_Right)
+ {
+ }
+
+ _Revbidit(const _Revbidit<_BidIt2>& _Other)
+ : current (_Other.base())
+ {
+ }
+
+ _BidIt base() const
+ {
+ return (current);
+ }
+
+ _Reference operator*() const
+ {
+ _BidIt _Tmp = current;
+ return (*--_Tmp);
+ }
+
+ _Pointer operator->() const
+ {
+ _Reference _Tmp = **this;
+ return (&_Tmp);
+ }
+
+ _Myt& operator++()
+ {
+ --current;
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ --current;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ ++current;
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ ++current;
+ return (_Tmp);
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+ return (current == _Right.current);
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+protected:
+ _BidIt current;
+ };
+
+
+template<class _Elem,
+ class _Traits>
+ class istreambuf_iterator
+ : public _Iterator_with_base<input_iterator_tag,
+ _Elem, typename _Traits::off_type, _Elem *, _Elem&, _Iterator_base_secure>
+ {
+ typedef istreambuf_iterator<_Elem, _Traits> _Myt;
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef basic_streambuf<_Elem, _Traits> streambuf_type;
+ typedef basic_istream<_Elem, _Traits> istream_type;
+ typedef typename traits_type::int_type int_type;
+
+ istreambuf_iterator(streambuf_type *_Sb = 0) throw ()
+ : _Strbuf(_Sb), _Got(_Sb == 0)
+ {
+ }
+
+ istreambuf_iterator(istream_type& _Istr) throw ()
+ : _Strbuf(_Istr.rdbuf()), _Got(_Istr.rdbuf() == 0)
+ {
+ }
+
+ _Elem operator*() const
+ {
+ if (!_Got)
+ ((_Myt *)this)->_Peek();
+
+
+
+
+
+
+ return (_Val);
+ }
+
+ _Myt& operator++()
+ {
+
+
+
+
+
+
+ _Inc();
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ if (!_Got)
+ _Peek();
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ bool equal(const _Myt& _Right) const
+ {
+ if (!_Got)
+ ((_Myt *)this)->_Peek();
+ if (!_Right._Got)
+ ((_Myt *)&_Right)->_Peek();
+ return (_Strbuf == 0 && _Right._Strbuf == 0
+ || _Strbuf != 0 && _Right._Strbuf != 0);
+ }
+
+private:
+ void _Inc()
+ {
+ if (_Strbuf == 0
+ || traits_type::eq_int_type(traits_type::eof(),
+ _Strbuf->sbumpc()))
+ _Strbuf = 0, _Got = true;
+ else
+ _Got = false;
+ }
+
+ _Elem _Peek()
+ {
+ int_type _Meta;
+ if (_Strbuf == 0
+ || traits_type::eq_int_type(traits_type::eof(),
+ _Meta = _Strbuf->sgetc()))
+ _Strbuf = 0;
+ else
+ _Val = traits_type::to_char_type(_Meta);
+ _Got = true;
+ return (_Val);
+ }
+
+ streambuf_type *_Strbuf;
+ bool _Got;
+ _Elem _Val;
+ };
+
+
+template<class _Elem,
+ class _Traits> inline
+ bool __cdecl operator==(
+ const istreambuf_iterator<_Elem, _Traits>& _Left,
+ const istreambuf_iterator<_Elem, _Traits>& _Right)
+ {
+ return (_Left.equal(_Right));
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ bool __cdecl operator!=(
+ const istreambuf_iterator<_Elem, _Traits>& _Left,
+ const istreambuf_iterator<_Elem, _Traits>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+
+template<class _Elem,
+ class _Traits>
+ class ostreambuf_iterator
+ : public _Outit_with_base<_Iterator_base_secure>
+ {
+ typedef ostreambuf_iterator<_Elem, _Traits> _Myt;
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef basic_streambuf<_Elem, _Traits> streambuf_type;
+ typedef basic_ostream<_Elem, _Traits> ostream_type;
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+ ostreambuf_iterator(streambuf_type *_Sb) throw ()
+ : _Failed(false), _Strbuf(_Sb)
+ {
+ }
+
+ ostreambuf_iterator(ostream_type& _Ostr) throw ()
+ : _Failed(false), _Strbuf(_Ostr.rdbuf())
+ {
+ }
+
+ _Myt& operator=(_Elem _Right)
+ {
+ if (_Strbuf == 0
+ || traits_type::eq_int_type(_Traits::eof(),
+ _Strbuf->sputc(_Right)))
+ _Failed = true;
+ return (*this);
+ }
+
+ _Myt& operator*()
+ {
+ return (*this);
+ }
+
+ _Myt& operator++()
+ {
+ return (*this);
+ }
+
+ _Myt& operator++(int)
+ {
+ return (*this);
+ }
+
+ bool failed() const throw ()
+ {
+ return (_Failed);
+ }
+
+private:
+ bool _Failed;
+ streambuf_type *_Strbuf;
+ };
+
+
+
+
+template<class _InIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt __cdecl _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ for (; _First != _Last; ++_Dest, ++_First)
+ *_Dest = *_First;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt>
+inline
+ _OutIt __cdecl _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ random_access_iterator_tag, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Copy_opt(_First, _Last, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Nonscalar_ptr_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+template<class _InIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt __cdecl _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+
+ ptrdiff_t _Off = _Last - _First;
+
+ _OutIt _Result = _Dest + _Off;
+ if (_Off > 0)
+ ::memmove_s((&*_Dest), (_Off * sizeof (*_First)), (&*_First), (_Off * sizeof (*_First)));
+ return _Result;
+ }
+
+
+template<class _InIt, class _OutIt, class _InOutItCat, class _Ty>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt __cdecl _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat _First_dest_cat, _Ty _PtrCat, _Unchecked_iterator_tag)
+ {
+ return _Copy_opt(_First, _Last, _Dest, _First_dest_cat, _PtrCat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt __cdecl copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (_Copy_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_random(_First, _Dest), _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _InIt, class _OutIt, class _InOutItCat, class _MoveCatTy>
+inline
+ _OutIt __cdecl _Move_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat _First_dest_cat, _MoveCatTy, _Range_checked_iterator_tag)
+ {
+ return _Copy_opt(_First, _Last, _Dest,
+ _First_dest_cat, _Ptr_cat(_First, _Dest), _Range_checked_iterator_tag());
+ }
+
+template<class _InIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt __cdecl _Move_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat, _Swap_move_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ for (; _First != _Last; ++_Dest, ++_First)
+ ::std:: swap(*_Dest, *_First);
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt __cdecl _Move_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ random_access_iterator_tag, _Swap_move_tag _Move_cat, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Move_opt(_First, _Last, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Move_cat, _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+
+template<class _InIt, class _OutIt, class _InOutItCat, class _MoveCatTy>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt __cdecl _Move_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat _First_dest_cat, _MoveCatTy _Move_cat, _Unchecked_iterator_tag)
+ {
+ return _Move_opt(_First, _Last, _Dest, _First_dest_cat, _Move_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt, class _OutIt>
+inline
+ _OutIt __cdecl _Move(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return _Move_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_random(_First, _Dest), _Move_cat(_Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _InOutItCat>
+inline
+ _BidIt2 __cdecl _Copy_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ _InOutItCat, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ while (_First != _Last)
+ *--_Dest = *--_Last;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt>
+inline
+ _OutIt __cdecl _Copy_backward_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ random_access_iterator_tag, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest - (_Last - _First);
+ _Copy_backward_opt(_First, _Last, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Nonscalar_ptr_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+template<class _InIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt __cdecl _Copy_backward_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _InOutItCat, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+
+ ptrdiff_t _Off = _Last - _First;
+
+
+
+ _OutIt _Result = _Dest - _Off;
+ if (_Off > 0)
+ ::memmove_s((&*_Result), (_Off * sizeof (*_First)), (&*_First), (_Off * sizeof (*_First)));
+ return _Result;
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _InOutItCat, class _Ty>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _BidIt2 __cdecl _Copy_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ _InOutItCat _First_dest_cat, _Ty _PtrCat, _Unchecked_iterator_tag)
+ {
+ return _Copy_backward_opt(_First, _Last, _Dest,
+ _First_dest_cat, _PtrCat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt1,
+ class _BidIt2> inline
+ _BidIt2 __cdecl copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return _Copy_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_random(_First, _Dest), _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _InOutItCat, class _MoveCatTy>
+inline
+ _BidIt2 __cdecl _Move_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ _InOutItCat _First_dest_cat, _MoveCatTy, _Range_checked_iterator_tag)
+ {
+ return _Copy_backward_opt(_First, _Last, _Dest,
+ _First_dest_cat, _Ptr_cat(_First, _Dest), _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt1, class _BidIt2, class _InOutItCat>
+inline
+ _BidIt2 __cdecl _Move_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ _InOutItCat, _Swap_move_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ while (_First != _Last)
+ ::std:: swap(*--_Dest, *--_Last);
+ return (_Dest);
+ }
+
+
+template<class _BidIt1, class _BidIt2>
+inline
+ _BidIt2 __cdecl _Move_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ random_access_iterator_tag, _Swap_move_tag _Move_cat, _Range_checked_iterator_tag)
+ {
+
+ _BidIt2 _Result = _Dest - (_Last - _First);
+ _Move_backward_opt(_First, _Last, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Move_cat, _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+
+template<class _BidIt1, class _BidIt2, class _InOutItCat, class _MoveCatTy>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _BidIt2 __cdecl _Move_backward_opt(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,
+ _InOutItCat _First_dest_cat, _MoveCatTy _Move_cat, _Unchecked_iterator_tag)
+ {
+ return _Move_backward_opt(_First, _Last, _Dest,
+ _First_dest_cat, _Move_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt1, class _BidIt2>
+inline
+ _BidIt2 __cdecl _Move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return _Move_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_random(_First, _Dest), _Move_cat(_Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _InItCats>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _InItCats, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+
+ for (; _First1 != _Last1 && *_First1 == *_First2; )
+ ++_First1, ++_First2;
+ return (pair<_InIt1, _InIt2>(_First1, _First2));
+ }
+
+
+template<class _InIt1, class _InIt2>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ pair<_InIt1, typename ::std:: _Checked_iterator_base_helper<_InIt2>::_Checked_iterator_base_type> _Result =
+ _Mismatch(_First1, _Last1, ::std:: _Checked_base(_First2),
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ ::std:: _Checked_assign_from_base(_First2, _Result.second);
+ return (pair<_InIt1, _InIt2>(_Result.first, _First2));
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _InItCats>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _InItCats _InIt_cats, _Unchecked_iterator_tag)
+ {
+ return _Mismatch(_First1, _Last1, _First2,
+ _InIt_cats, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1, class _InIt2>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+
+ pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr, class _InItCats>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ _InItCats, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+
+
+ for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
+ ++_First1, ++_First2;
+ return (pair<_InIt1, _InIt2>(_First1, _First2));
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ pair<_InIt1, typename ::std:: _Checked_iterator_base_helper<_InIt2>::_Checked_iterator_base_type> _Result =
+ _Mismatch(_First1, _Last1, ::std:: _Checked_base(_First2), _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ ::std:: _Checked_assign_from_base(_First2, _Result.second);
+ return (pair<_InIt1, _InIt2>(_Result.first, _First2));
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _Pr, class _InItCats>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ pair<_InIt1, _InIt2>
+ __cdecl _Mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ _InItCats _InIt_cats, _Unchecked_iterator_tag)
+ {
+ return _Mismatch(_First1, _Last1, _First2, _Pred,
+ _InIt_cats, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ pair<_InIt1, _InIt2>
+ __cdecl mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+
+ pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+
+template<class _InIt1, class _InIt2, class _InItCats>
+inline
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _InItCats, _Range_checked_iterator_tag)
+ {
+ return (_Mismatch(_First1, _Last1, _First2,
+ forward_iterator_tag(), _Range_checked_iterator_tag()).first == _Last1);
+ }
+
+inline bool __cdecl _Equal(const char *_First1,
+ const char *_Last1, const char *_First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ return (::memcmp(_First1, _First2, _Last1 - _First1) == 0);
+ }
+
+inline bool __cdecl _Equal(const signed char *_First1,
+ const signed char *_Last1, const signed char *_First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ return (::memcmp(_First1, _First2, _Last1 - _First1) == 0);
+ }
+
+inline bool __cdecl _Equal(const unsigned char *_First1,
+ const unsigned char *_Last1, const unsigned char *_First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ return (::memcmp(_First1, _First2, _Last1 - _First1) == 0);
+ }
+
+
+template<class _InIt1, class _InIt2>
+inline
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ return _Equal(_First1, _Last1, ::std:: _Checked_base(_First2),
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _InItCats>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _InItCats _InIt_cats,_Unchecked_iterator_tag)
+ {
+ return _Equal(_First1, _Last1, _First2,
+ _InIt_cats, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1, class _InIt2>
+inline
+ bool __cdecl equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+ return _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr, class _InItCats>
+inline
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ _InItCats, _Range_checked_iterator_tag)
+ {
+ return (_Mismatch(_First1, _Last1, _First2, _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag()).first == _Last1);
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ return _Equal(_First1, _Last1, ::std:: _Checked_base(_First2), _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _Pr, class _InItCats>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ bool __cdecl _Equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred,
+ _InItCats _InIt_cats,_Unchecked_iterator_tag)
+ {
+ return _Equal(_First1, _Last1, _First2, _Pred,
+ _InIt_cats, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ bool __cdecl equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+ return _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ }
+
+
+template<class _FwdIt, class _Ty> inline
+ void __cdecl _Fill(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Val;
+ }
+
+inline void __cdecl _Fill( char *_First,
+ char *_Last, int _Val)
+ {
+ ;
+ ::memset(_First, _Val, _Last - _First);
+ }
+
+inline void __cdecl _Fill( signed char *_First,
+ signed char *_Last, int _Val)
+ {
+ ;
+ ::memset(_First, _Val, _Last - _First);
+ }
+
+inline void __cdecl _Fill(
+ unsigned char *_First,
+ unsigned char *_Last, int _Val)
+ {
+ ;
+ ::memset(_First, _Val, _Last - _First);
+ }
+
+template<class _FwdIt, class _Ty> inline
+ void __cdecl fill(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ _Fill(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val);
+ }
+
+
+template<class _OutIt,
+ class _Diff,
+ class _Ty> inline
+ void __cdecl _Fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val,
+ _Range_checked_iterator_tag)
+ {
+ for (; 0 < _Count; --_Count, ++_First)
+ *_First = _Val;
+ }
+
+inline void __cdecl _Fill_n( char *_First,
+ size_t _Count, int _Val, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ ::memset(_First, _Val, _Count);
+ }
+
+inline void __cdecl _Fill_n( signed char *_First,
+ size_t _Count, int _Val, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ ::memset(_First, _Val, _Count);
+ }
+
+inline void __cdecl _Fill_n( unsigned char *_First,
+ size_t _Count, int _Val, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ ::memset(_First, _Val, _Count);
+ }
+
+template<class _OutIt, class _Diff, class _Ty, class _OutCat>
+inline
+ void __cdecl _Fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val,
+ _OutCat, _Range_checked_iterator_tag)
+ {
+ _Fill_n(_First, _Count, _Val, _Range_checked_iterator_tag());
+ }
+
+
+template<class _OutIt, class _Diff, class _Ty>
+inline
+ void __cdecl _Fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Last = _First + _Count; (_Last);
+ _Fill_n(::std:: _Checked_base(_First), _Count, _Val,
+ _Range_checked_iterator_tag());
+ }
+
+
+
+template<class _OutIt, class _Diff, class _Ty, class _OutCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void __cdecl _Fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val,
+ _OutCat _First_cat, _Unchecked_iterator_tag)
+ {
+ _Fill_n(_First, _Count, _Val, _First_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _OutIt,
+ class _Diff,
+ class _Ty> inline
+ void __cdecl fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val)
+ {
+ _Fill_n(_First, _Count, _Val, _Iter_cat(_First), ::std:: _Checked_cat(_First));
+ }
+
+
+template<class _InIt1, class _InIt2> inline
+ bool __cdecl _Lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2)
+ {
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
+ if (((*_First1) < (*_First2)))
+ return (true);
+ else if (*_First2 < *_First1)
+ return (false);
+ return (_First1 == _Last1 && _First2 != _Last2);
+ }
+
+template<class _InIt1, class _InIt2> inline
+ bool __cdecl lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2)
+ {
+ return _Lexicographical_compare(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2));
+ }
+
+inline bool __cdecl lexicographical_compare(
+ const unsigned char *_First1, const unsigned char *_Last1,
+ const unsigned char *_First2, const unsigned char *_Last2)
+ {
+ ;
+ ;
+ ptrdiff_t _Num1 = _Last1 - _First1;
+ ptrdiff_t _Num2 = _Last2 - _First2;
+ int _Ans = ::memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
+ return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _Pr> inline
+ bool __cdecl _Lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
+ if (_Pred(*_First1, *_First2))
+ return (true);
+ else if (_Pred(*_First2, *_First1))
+ return (false);
+ return (_First1 == _Last1 && _First2 != _Last2);
+ }
+
+template<class _InIt1, class _InIt2, class _Pr> inline
+ bool __cdecl lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
+ {
+ return _Lexicographical_compare(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Ty> inline
+ const _Ty& (__cdecl max)(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (((_Left) < (_Right)) ? _Right : _Left);
+ }
+
+
+template<class _Ty,
+ class _Pr> inline
+ const _Ty& (__cdecl max)(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
+ {
+ return (_Pred(_Left, _Right) ? _Right : _Left);
+ }
+
+
+template<class _Ty> inline
+ const _Ty& (__cdecl min)(const _Ty& _Left, const _Ty& _Right)
+ {
+ return (((_Right) < (_Left)) ? _Right : _Left);
+ }
+
+
+template<class _Ty,
+ class _Pr> inline
+ const _Ty& (__cdecl min)(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
+ {
+ return (_Pred(_Right, _Left) ? _Right : _Left);
+ }
+
+
+
+
+}
+
+namespace stdext {
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt __cdecl unchecked_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (::std:: _Copy_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Ptr_cat(_First, _Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt __cdecl checked_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (::std:: _Copy_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _BidIt1,
+ class _BidIt2> inline
+ _BidIt2 __cdecl unchecked_copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return (::std:: _Copy_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Ptr_cat(_First, _Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _BidIt1,
+ class _BidIt2> inline
+ _BidIt2 __cdecl checked_copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return (::std:: _Copy_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt __cdecl _Unchecked_move(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (::std:: _Move_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Move_cat(_Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt __cdecl _Checked_move(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (::std:: _Move_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Move_cat(_Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _BidIt1,
+ class _BidIt2> inline
+ _BidIt2 __cdecl _Unchecked_move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return (::std:: _Move_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Move_cat(_Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _BidIt1,
+ class _BidIt2> inline
+ _BidIt2 __cdecl _Checked_move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
+ {
+ return (::std:: _Move_backward_opt(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Move_cat(_Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _OutIt,
+ class _Diff,
+ class _Ty> inline
+ void __cdecl unchecked_fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val)
+ {
+ ::std:: _Fill_n(_First, _Count, _Val, ::std:: _Iter_cat(_First), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _OutIt,
+ class _Diff,
+ class _Ty> inline
+ void __cdecl checked_fill_n(_OutIt _First, _Diff _Count, const _Ty& _Val)
+ {
+ ::std:: _Fill_n(_First, _Count, _Val, ::std:: _Iter_cat(_First), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1, class _InIt2>
+inline
+ ::std:: pair<_InIt1, _InIt2>
+ __cdecl unchecked_mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+
+ ::std:: pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ ::std:: _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Range_checked_iterator_tag());
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (::std:: pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+template<class _InIt1, class _InIt2>
+inline
+ ::std:: pair<_InIt1, _InIt2>
+ __cdecl checked_mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+
+ ::std:: pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ ::std:: _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (::std:: pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ ::std:: pair<_InIt1, _InIt2>
+ __cdecl unchecked_mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+
+ ::std:: pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ ::std:: _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Range_checked_iterator_tag());
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (::std:: pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ ::std:: pair<_InIt1, _InIt2>
+ __cdecl checked_mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+
+ ::std:: pair<typename ::std:: _Checked_iterator_base_helper<_InIt1>::_Checked_iterator_base_type, _InIt2> _Result =
+ ::std:: _Mismatch(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ ::std:: _Checked_assign_from_base(_First1, _Result.first);
+ return (::std:: pair<_InIt1, _InIt2>(_First1, _Result.second));
+
+
+
+
+ }
+
+template<class _InIt1, class _InIt2>
+inline
+ bool __cdecl unchecked_equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+ return ::std:: _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2>
+inline
+ bool __cdecl checked_equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
+ {
+ return ::std:: _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ }
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ bool __cdecl unchecked_equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+ return ::std:: _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2, class _Pr>
+inline
+ bool __cdecl checked_equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
+ {
+ return ::std:: _Equal(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Pred,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C"
+ void __cdecl _invalid_parameter_noinfo(void);
+
+
+
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4100)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace std {
+
+template<class _Ty> inline
+ _Ty *_Allocate(size_t _Count, _Ty *)
+ {
+ if (_Count <= 0)
+ _Count = 0;
+ else if (((size_t)(-1) / _Count) < sizeof (_Ty))
+ throw std::bad_alloc(0);
+
+
+ return ((_Ty *)::operator new(_Count * sizeof (_Ty)));
+ }
+
+
+template<class _T1,
+ class _T2> inline
+ void _Construct(_T1 *_Ptr, const _T2& _Val)
+ {
+ void *_Vptr = _Ptr;
+ ::new (_Vptr) _T1(_Val);
+ }
+
+
+template<class _Ty> inline
+ void _Destroy(_Ty *_Ptr)
+ {
+ (_Ptr)->~_Ty();
+ }
+
+template<> inline
+ void _Destroy(char *)
+ {
+ }
+
+template<> inline
+ void _Destroy(wchar_t *)
+ {
+ }
+
+
+
+template<class _Ty>
+ struct _Allocator_base
+ {
+ typedef _Ty value_type;
+ };
+
+
+template<class _Ty>
+ struct _Allocator_base<const _Ty>
+ {
+ typedef _Ty value_type;
+ };
+
+
+template<class _Ty>
+ class allocator
+ : public _Allocator_base<_Ty>
+ {
+public:
+ typedef _Allocator_base<_Ty> _Mybase;
+ typedef typename _Mybase::value_type value_type;
+ typedef value_type *pointer;
+ typedef value_type & reference;
+ typedef const value_type *const_pointer;
+ typedef const value_type & const_reference;
+
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+ template<class _Other>
+ struct rebind
+ {
+ typedef allocator<_Other> other;
+ };
+
+ pointer address(reference _Val) const
+ {
+ return (&_Val);
+ }
+
+ const_pointer address(const_reference _Val) const
+ {
+ return (&_Val);
+ }
+
+ allocator() throw ()
+ {
+ }
+
+ allocator(const allocator<_Ty>&) throw ()
+ {
+ }
+
+ template<class _Other>
+ allocator(const allocator<_Other>&) throw ()
+ {
+ }
+
+ template<class _Other>
+ allocator<_Ty>& operator=(const allocator<_Other>&)
+ {
+ return (*this);
+ }
+
+ void deallocate(pointer _Ptr, size_type)
+ {
+ ::operator delete(_Ptr);
+ }
+
+ pointer allocate(size_type _Count)
+ {
+ return (_Allocate(_Count, (pointer)0));
+ }
+
+ pointer allocate(size_type _Count, const void *)
+ {
+ return (allocate(_Count));
+ }
+
+ void construct(pointer _Ptr, const _Ty& _Val)
+ {
+ _Construct(_Ptr, _Val);
+ }
+
+ void destroy(pointer _Ptr)
+ {
+ _Destroy(_Ptr);
+ }
+
+ size_t max_size() const throw ()
+ {
+ size_t _Count = (size_t)(-1) / sizeof (_Ty);
+ return (0 < _Count ? _Count : 1);
+ }
+ };
+
+
+template<class _Ty,
+ class _Other> inline
+ bool operator==(const allocator<_Ty>&, const allocator<_Other>&) throw ()
+ {
+ return (true);
+ }
+
+template<class _Ty,
+ class _Other> inline
+ bool operator!=(const allocator<_Ty>&, const allocator<_Other>&) throw ()
+ {
+ return (false);
+ }
+
+
+template<> class allocator<void>
+ {
+public:
+ typedef void _Ty;
+ typedef _Ty *pointer;
+ typedef const _Ty *const_pointer;
+ typedef _Ty value_type;
+
+ template<class _Other>
+ struct rebind
+ {
+ typedef allocator<_Other> other;
+ };
+
+ allocator() throw ()
+ {
+ }
+
+ allocator(const allocator<_Ty>&) throw ()
+ {
+ }
+
+ template<class _Other>
+ allocator(const allocator<_Other>&) throw ()
+ {
+ }
+
+ template<class _Other>
+ allocator<_Ty>& operator=(const allocator<_Other>&)
+ {
+ return (*this);
+ }
+ };
+
+
+template<class _Ty,
+ class _Alloc> inline
+ void _Destroy_range(_Ty *_First, _Ty *_Last, _Alloc& _Al)
+ {
+ _Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ void _Destroy_range(_Ty *_First, _Ty *_Last, _Alloc& _Al,
+ _Nonscalar_ptr_iterator_tag)
+ {
+ for (; _First != _Last; ++_First)
+ _Al.destroy(_First);
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ void _Destroy_range(_Ty *_First, _Ty *_Last, _Alloc& _Al,
+ _Scalar_ptr_iterator_tag)
+ {
+ }
+}
+
+
+ #pragma warning(default: 4100)
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+#pragma warning(disable:4412)
+
+
+
+
+
+namespace std {
+
+ #pragma warning(disable:4251)
+
+template<class _Elem,
+ class _Traits = char_traits<_Elem>,
+ class _Ax = allocator<_Elem> >
+ class basic_string;
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class _String_const_iterator
+ : public _Ranit_base<_Elem, typename _Alloc::difference_type,
+ typename _Alloc::const_pointer, typename _Alloc::const_reference, _Iterator_base_secure>
+ {
+public:
+ typedef _String_const_iterator<_Elem, _Traits, _Alloc> _Myt;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystring;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Elem value_type;
+ typedef typename _Alloc::difference_type difference_type;
+ typedef typename _Alloc::const_pointer pointer;
+ typedef typename _Alloc::const_reference reference;
+
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+
+ typedef pointer _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return _Myptr;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ this->_Myptr = _Base;
+ }
+
+
+ _String_const_iterator()
+ {
+ _Myptr = 0;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _String_const_iterator(pointer _Ptr, const _Container_base *_Pstring)
+ {
+ { if (!(_Pstring != 0 && _Ptr != 0 && ((_Mystring *)_Pstring)->_Myptr() <= _Ptr && _Ptr <= (((_Mystring *)_Pstring)->_Myptr() + ((_Mystring *)_Pstring)->_Mysize))) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ this->_Mycont = _Pstring;
+ _Myptr = _Ptr;
+ }
+
+
+
+
+
+
+
+
+
+
+
+ reference operator*() const
+ {
+
+
+
+
+
+
+
+
+
+
+
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr < (((_Mystring *)this->_Mycont)->_Myptr() + ((_Mystring *)(this->_Mycont))->_Mysize))) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+
+
+ return (*_Myptr);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr < (((_Mystring *)this->_Mycont)->_Myptr() + ((_Mystring *)this->_Mycont)->_Mysize))) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+ ++_Myptr;
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr > ((_Mystring *)this->_Mycont)->_Myptr())) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+ --_Myptr;
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr + _Off <= (((_Mystring *)this->_Mycont)->_Myptr() + ((_Mystring *)this->_Mycont)->_Mysize) && _Myptr + _Off >= ((_Mystring *)this->_Mycont)->_Myptr())) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+ _Myptr += _Off;
+ return (*this);
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Myt& _Right) const
+ {
+
+
+
+
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+
+
+ return (_Myptr - _Right._Myptr);
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+
+
+
+
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+
+
+ return (_Myptr == _Right._Myptr);
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+ bool operator<(const _Myt& _Right) const
+ {
+
+
+
+
+ if (this->_Mycont != ((const _Container_base *)-2))
+ {
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+
+
+ return (_Myptr < _Right._Myptr);
+ }
+
+ bool operator>(const _Myt& _Right) const
+ {
+ return (_Right < *this);
+ }
+
+ bool operator<=(const _Myt& _Right) const
+ {
+ return (!(_Right < *this));
+ }
+
+ bool operator>=(const _Myt& _Right) const
+ {
+ return (!(*this < _Right));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+ static void __cdecl _Xlen()
+ {
+ _Mystring::_Xlen();
+ }
+
+ static void __cdecl _Xran()
+ {
+ _Mystring::_Xran();
+ }
+
+ static void __cdecl _Xinvarg()
+ {
+ _Mystring::_Xinvarg();
+ }
+
+ pointer _Myptr;
+ };
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ _String_const_iterator<_Elem, _Traits, _Alloc> __cdecl operator+(
+ typename _String_const_iterator<_Elem, _Traits, _Alloc>
+ ::difference_type _Off,
+ _String_const_iterator<_Elem, _Traits, _Alloc> _Next)
+ {
+ return (_Next += _Off);
+ }
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class _String_iterator
+ : public _String_const_iterator<_Elem, _Traits, _Alloc>
+ {
+public:
+ typedef _String_iterator<_Elem, _Traits, _Alloc> _Myt;
+ typedef _String_const_iterator<_Elem, _Traits, _Alloc> _Mybase;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Elem value_type;
+ typedef typename _Alloc::difference_type difference_type;
+ typedef typename _Alloc::pointer pointer;
+ typedef typename _Alloc::reference reference;
+
+ _String_iterator()
+ {
+ }
+
+
+
+
+
+
+
+
+
+
+
+ _String_iterator(pointer _Ptr, const _Container_base *_Pstring)
+ : _Mybase(_Ptr, _Pstring)
+ {
+ }
+
+
+
+
+
+
+
+
+
+
+
+ typedef pointer _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return const_cast<pointer>(this->_Myptr);
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ this->_Myptr = _Base;
+ }
+
+
+ reference operator*() const
+ {
+ return ((reference)**(_Mybase *)this);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ ++(*(_Mybase *)this);
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ --(*(_Mybase *)this);
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ (*(_Mybase *)this) += _Off;
+ return (*this);
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Mybase& _Right) const
+ {
+ return ((_Mybase)*this - _Right);
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+ };
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ _String_iterator<_Elem, _Traits, _Alloc> operator+(
+ typename _String_iterator<_Elem, _Traits, _Alloc>
+ ::difference_type _Off,
+ _String_iterator<_Elem, _Traits, _Alloc> _Next)
+ {
+ return (_Next += _Off);
+ }
+
+
+class _String_base
+ : public _Container_base
+ {
+public:
+ static void __cdecl _Xlen();
+
+ static void __cdecl _Xran();
+
+ static void __cdecl _Xinvarg();
+ };
+
+
+template<class _Ty,
+ class _Alloc>
+ class _String_val
+ : public _String_base
+ {
+protected:
+ typedef typename _Alloc::template
+ rebind<_Ty>::other _Alty;
+
+ _String_val(_Alty _Al = _Alty())
+ : _Alval(_Al)
+ {
+ }
+
+ _Alty _Alval;
+ };
+
+
+template<class _Elem,
+ class _Traits,
+ class _Ax>
+ class basic_string
+ : public _String_val<_Elem, _Ax>
+ {
+public:
+ typedef basic_string<_Elem, _Traits, _Ax> _Myt;
+ typedef _String_val<_Elem, _Ax> _Mybase;
+ typedef typename _Mybase::_Alty _Alloc;
+ typedef typename _Alloc::size_type size_type;
+ typedef typename _Alloc::difference_type _Dift;
+ typedef _Dift difference_type;
+ typedef typename _Alloc::pointer _Tptr;
+ typedef typename _Alloc::const_pointer _Ctptr;
+ typedef _Tptr pointer;
+ typedef _Ctptr const_pointer;
+ typedef typename _Alloc::reference _Reft;
+ typedef _Reft reference;
+ typedef typename _Alloc::const_reference const_reference;
+ typedef typename _Alloc::value_type value_type;
+
+
+
+ typedef _String_iterator<_Elem, _Traits, _Alloc> iterator;
+ typedef _String_const_iterator<_Elem, _Traits, _Alloc> const_iterator;
+
+
+ friend class _String_const_iterator<_Elem, _Traits, _Alloc>;
+
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ basic_string()
+ : _Mybase()
+ {
+ _Tidy();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ explicit basic_string(const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ }
+
+ basic_string(const _Myt& _Right)
+ : _Mybase(_Right._Alval)
+ {
+ _Tidy();
+ assign(_Right, 0, npos);
+ }
+
+ basic_string(const _Myt& _Right, size_type _Roff,
+ size_type _Count = npos)
+ : _Mybase()
+ {
+ _Tidy();
+ assign(_Right, _Roff, _Count);
+ }
+
+ basic_string(const _Myt& _Right, size_type _Roff, size_type _Count,
+ const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ assign(_Right, _Roff, _Count);
+ }
+
+ basic_string(const _Elem *_Ptr, size_type _Count)
+ : _Mybase()
+ {
+ _Tidy();
+ assign(_Ptr, _Count);
+ }
+
+ basic_string(const _Elem *_Ptr, size_type _Count, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ assign(_Ptr, _Count);
+ }
+
+ basic_string(const _Elem *_Ptr)
+ : _Mybase()
+ {
+ _Tidy();
+ assign(_Ptr);
+ }
+
+ basic_string(const _Elem *_Ptr, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ assign(_Ptr);
+ }
+
+ basic_string(size_type _Count, _Elem _Ch)
+ : _Mybase()
+ {
+ _Tidy();
+ assign(_Count, _Ch);
+ }
+
+ basic_string(size_type _Count, _Elem _Ch, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ assign(_Count, _Ch);
+ }
+
+ template<class _It>
+ basic_string(_It _First, _It _Last)
+ : _Mybase()
+ {
+ _Tidy();
+ _Construct(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _It>
+ basic_string(_It _First, _It _Last, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Tidy();
+ _Construct(_First, _Last, _Iter_cat(_First));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<class _It>
+ void _Construct(_It _Count,
+ _It _Ch, _Int_iterator_tag)
+ {
+ assign((size_type)_Count, (_Elem)_Ch);
+ }
+
+ template<class _It>
+ void _Construct(_It _First,
+ _It _Last, input_iterator_tag)
+ {
+ try {
+ for (; _First != _Last; ++_First)
+ append((size_type)1, (_Elem)*_First);
+ } catch (...) {
+ _Tidy(true);
+ throw;
+ }
+ }
+
+ template<class _It>
+ void _Construct(_It _First,
+ _It _Last, forward_iterator_tag)
+ {
+
+
+
+
+
+
+
+ size_type _Count = 0;
+ _Distance(_First, _Last, _Count);
+ reserve(_Count);
+
+ try {
+ for (; _First != _Last; ++_First)
+ append((size_type)1, (_Elem)*_First);
+ } catch (...) {
+ _Tidy(true);
+ throw;
+ }
+ }
+
+ basic_string(const_pointer _First, const_pointer _Last)
+ : _Mybase()
+ {
+
+
+
+
+
+
+
+ _Tidy();
+ if (_First != _Last)
+ assign(&*_First, _Last - _First);
+ }
+
+ basic_string(const_iterator _First, const_iterator _Last)
+ : _Mybase()
+ {
+
+
+
+
+
+
+
+ _Tidy();
+ if (_First != _Last)
+ assign(&*_First, _Last - _First);
+ }
+
+ ~basic_string()
+ {
+ _Tidy(true);
+ }
+
+ typedef _Traits traits_type;
+ typedef _Alloc allocator_type;
+
+ static const size_type npos;
+
+ _Myt& operator=(const _Myt& _Right)
+ {
+ return (assign(_Right));
+ }
+
+ _Myt& operator=(const _Elem *_Ptr)
+ {
+ return (assign(_Ptr));
+ }
+
+ _Myt& operator=(_Elem _Ch)
+ {
+ return (assign(1, _Ch));
+ }
+
+ _Myt& operator+=(const _Myt& _Right)
+ {
+ return (append(_Right));
+ }
+
+ _Myt& operator+=(const _Elem *_Ptr)
+ {
+ return (append(_Ptr));
+ }
+
+ _Myt& operator+=(_Elem _Ch)
+ {
+ return (append((size_type)1, _Ch));
+ }
+
+ _Myt& append(const _Myt& _Right)
+ {
+ return (append(_Right, 0, npos));
+ }
+
+ _Myt& append(const _Myt& _Right,
+ size_type _Roff, size_type _Count)
+ {
+ if (_Right.size() < _Roff)
+ _String_base::_Xran();
+ size_type _Num = _Right.size() - _Roff;
+ if (_Num < _Count)
+ _Count = _Num;
+ if (npos - _Mysize <= _Count || _Mysize + _Count < _Mysize)
+ _String_base::_Xlen();
+
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Mysize, _Myres - _Mysize,
+ _Right._Myptr() + _Roff, _Count);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& append(const _Elem *_Ptr, size_type _Count)
+ {
+ if (_Inside(_Ptr))
+ return (append(*this, _Ptr - _Myptr(), _Count));
+ if (npos - _Mysize <= _Count || _Mysize + _Count < _Mysize)
+ _String_base::_Xlen();
+
+ size_type _Num;
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Mysize, _Myres - _Mysize, _Ptr, _Count);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& append(const _Elem *_Ptr)
+ {
+ return (append(_Ptr, _Traits::length(_Ptr)));
+ }
+
+ _Myt& append(size_type _Count, _Elem _Ch)
+ {
+ if (npos - _Mysize <= _Count)
+ _String_base::_Xlen();
+
+ size_type _Num;
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Chassign(_Mysize, _Count, _Ch);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ template<class _It>
+ _Myt& append(_It _First, _It _Last)
+ {
+ return (_Append(_First, _Last, _Iter_cat(_First)));
+ }
+
+ template<class _It>
+ _Myt& _Append(_It _Count, _It _Ch, _Int_iterator_tag)
+ {
+ return (append((size_type)_Count, (_Elem)_Ch));
+ }
+
+ template<class _It>
+ _Myt& _Append(_It _First, _It _Last, input_iterator_tag)
+ {
+ return (replace(end(), end(), _First, _Last));
+ }
+
+ _Myt& append(const_pointer _First, const_pointer _Last)
+ {
+ return (replace(end(), end(), _First, _Last));
+ }
+
+ _Myt& append(const_iterator _First, const_iterator _Last)
+ {
+ return (replace(end(), end(), _First, _Last));
+ }
+
+ _Myt& assign(const _Myt& _Right)
+ {
+ return (assign(_Right, 0, npos));
+ }
+
+ _Myt& assign(const _Myt& _Right,
+ size_type _Roff, size_type _Count)
+ {
+ if (_Right.size() < _Roff)
+ _String_base::_Xran();
+ size_type _Num = _Right.size() - _Roff;
+ if (_Count < _Num)
+ _Num = _Count;
+
+ if (this == &_Right)
+ erase((size_type)(_Roff + _Num)), erase(0, _Roff);
+ else if (_Grow(_Num))
+ {
+ _Traits_helper::copy_s<_Traits>(_Myptr(), _Myres, _Right._Myptr() + _Roff, _Num);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& assign(const _Elem *_Ptr, size_type _Num)
+ {
+ if (_Inside(_Ptr))
+ return (assign(*this, _Ptr - _Myptr(), _Num));
+
+ if (_Grow(_Num))
+ {
+ _Traits_helper::copy_s<_Traits>(_Myptr(), _Myres, _Ptr, _Num);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& assign(const _Elem *_Ptr)
+ {
+ return (assign(_Ptr, _Traits::length(_Ptr)));
+ }
+
+ _Myt& assign(size_type _Count, _Elem _Ch)
+ {
+ if (_Count == npos)
+ _String_base::_Xlen();
+
+ if (_Grow(_Count))
+ {
+ _Chassign(0, _Count, _Ch);
+ _Eos(_Count);
+ }
+ return (*this);
+ }
+
+ template<class _It>
+ _Myt& assign(_It _First, _It _Last)
+ {
+ return (_Assign(_First, _Last, _Iter_cat(_First)));
+ }
+
+ template<class _It>
+ _Myt& _Assign(_It _Count, _It _Ch, _Int_iterator_tag)
+ {
+ return (assign((size_type)_Count, (_Elem)_Ch));
+ }
+
+ template<class _It>
+ _Myt& _Assign(_It _First, _It _Last, input_iterator_tag)
+ {
+ return (replace(begin(), end(), _First, _Last));
+ }
+
+ _Myt& assign(const_pointer _First, const_pointer _Last)
+ {
+ return (replace(begin(), end(), _First, _Last));
+ }
+
+ _Myt& assign(const_iterator _First, const_iterator _Last)
+ {
+ return (replace(begin(), end(), _First, _Last));
+ }
+
+ _Myt& insert(size_type _Off, const _Myt& _Right)
+ {
+ return (insert(_Off, _Right, 0, npos));
+ }
+
+ _Myt& insert(size_type _Off,
+ const _Myt& _Right, size_type _Roff, size_type _Count)
+ {
+ if (_Mysize < _Off || _Right.size() < _Roff)
+ _String_base::_Xran();
+ size_type _Num = _Right.size() - _Roff;
+ if (_Num < _Count)
+ _Count = _Num;
+ if (npos - _Mysize <= _Count)
+ _String_base::_Xlen();
+
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off, _Mysize - _Off);
+ if (this == &_Right)
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Myptr() + (_Off < _Roff ? _Roff + _Count : _Roff),
+ _Count);
+ else
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Right._Myptr() + _Roff, _Count);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& insert(size_type _Off,
+ const _Elem *_Ptr, size_type _Count)
+ {
+ if (_Inside(_Ptr))
+ return (insert(_Off, *this,
+ _Ptr - _Myptr(), _Count));
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (npos - _Mysize <= _Count)
+ _String_base::_Xlen();
+ size_type _Num;
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off, _Mysize - _Off);
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Off, _Myres - _Off, _Ptr, _Count);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& insert(size_type _Off, const _Elem *_Ptr)
+ {
+ return (insert(_Off, _Ptr, _Traits::length(_Ptr)));
+ }
+
+ _Myt& insert(size_type _Off,
+ size_type _Count, _Elem _Ch)
+ {
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (npos - _Mysize <= _Count)
+ _String_base::_Xlen();
+ size_type _Num;
+ if (0 < _Count && _Grow(_Num = _Mysize + _Count))
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off, _Mysize - _Off);
+ _Chassign(_Off, _Count, _Ch);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ iterator insert(iterator _Where)
+ {
+ return (insert(_Where, _Elem()));
+ }
+
+ iterator insert(iterator _Where, _Elem _Ch)
+ {
+ size_type _Off = _Pdif(_Where, begin());
+ insert(_Off, 1, _Ch);
+ return (begin() + _Off);
+ }
+
+ void insert(iterator _Where, size_type _Count, _Elem _Ch)
+ {
+ size_type _Off = _Pdif(_Where, begin());
+ insert(_Off, _Count, _Ch);
+ }
+
+ template<class _It>
+ void insert(iterator _Where, _It _First, _It _Last)
+ {
+ _Insert(_Where, _First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _It>
+ void _Insert(iterator _Where, _It _Count, _It _Ch,
+ _Int_iterator_tag)
+ {
+ insert(_Where, (size_type)_Count, (_Elem)_Ch);
+ }
+
+ template<class _It>
+ void _Insert(iterator _Where, _It _First, _It _Last,
+ input_iterator_tag)
+ {
+ replace(_Where, _Where, _First, _Last);
+ }
+
+ void insert(iterator _Where, const_pointer _First, const_pointer _Last)
+ {
+ replace(_Where, _Where, _First, _Last);
+ }
+
+ void insert(iterator _Where, const_iterator _First, const_iterator _Last)
+ {
+ replace(_Where, _Where, _First, _Last);
+ }
+
+ _Myt& erase(size_type _Off = 0,
+ size_type _Count = npos)
+ {
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _Count)
+ _Count = _Mysize - _Off;
+ if (0 < _Count)
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off, _Myptr() + _Off + _Count,
+ _Mysize - _Off - _Count);
+ size_type _Newsize = _Mysize - _Count;
+ _Eos(_Newsize);
+ }
+ return (*this);
+ }
+
+ iterator erase(iterator _Where)
+ {
+ size_type _Count = _Pdif(_Where, begin());
+ erase(_Count, 1);
+ return (iterator(_Myptr() + _Count, this));
+ }
+
+ iterator erase(iterator _First, iterator _Last)
+ {
+ size_type _Count = _Pdif(_First, begin());
+ erase(_Count, _Pdif(_Last, _First));
+ return (iterator(_Myptr() + _Count, this));
+ }
+
+ void clear()
+ {
+ erase(begin(), end());
+ }
+
+ _Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
+ {
+ return (replace(_Off, _N0, _Right, 0, npos));
+ }
+
+ _Myt& replace(size_type _Off,
+ size_type _N0, const _Myt& _Right, size_type _Roff, size_type _Count)
+ {
+ if (_Mysize < _Off || _Right.size() < _Roff)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _N0)
+ _N0 = _Mysize - _Off;
+ size_type _Num = _Right.size() - _Roff;
+ if (_Num < _Count)
+ _Count = _Num;
+ if (npos - _Count <= _Mysize - _N0)
+ _String_base::_Xlen();
+
+ size_type _Nm = _Mysize - _N0 - _Off;
+ size_type _Newsize = _Mysize + _Count - _N0;
+ if (_Mysize < _Newsize)
+ _Grow(_Newsize);
+
+ if (this != &_Right)
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Right._Myptr() + _Roff, _Count);
+ }
+ else if (_Count <= _N0)
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Myptr() + _Roff, _Count);
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ }
+ else if (_Roff <= _Off)
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Myptr() + _Roff, _Count);
+ }
+ else if (_Off + _N0 <= _Roff)
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Myptr() + (_Roff + _Count - _N0), _Count);
+ }
+ else
+ {
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off, _Myres - _Off,
+ _Myptr() + _Roff, _N0);
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _N0, _Myres - _Off - _N0, _Myptr() + _Roff + _Count,
+ _Count - _N0);
+ }
+
+ _Eos(_Newsize);
+ return (*this);
+ }
+
+ _Myt& replace(size_type _Off,
+ size_type _N0, const _Elem *_Ptr, size_type _Count)
+ {
+ if (_Inside(_Ptr))
+ return (replace(_Off, _N0, *this,
+ _Ptr - _Myptr(), _Count));
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _N0)
+ _N0 = _Mysize - _Off;
+ if (npos - _Count <= _Mysize - _N0)
+ _String_base::_Xlen();
+ size_type _Nm = _Mysize - _N0 - _Off;
+
+ if (_Count < _N0)
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ size_type _Num;
+ if ((0 < _Count || 0 < _N0) && _Grow(_Num = _Mysize + _Count - _N0))
+ {
+ if (_N0 < _Count)
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Traits_helper::copy_s<_Traits>(_Myptr() + _Off, _Myres - _Off, _Ptr, _Count);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
+ {
+ return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
+ }
+
+ _Myt& replace(size_type _Off,
+ size_type _N0, size_type _Count, _Elem _Ch)
+ {
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _N0)
+ _N0 = _Mysize - _Off;
+ if (npos - _Count <= _Mysize - _N0)
+ _String_base::_Xlen();
+ size_type _Nm = _Mysize - _N0 - _Off;
+
+ if (_Count < _N0)
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ size_type _Num;
+ if ((0 < _Count || 0 < _N0) && _Grow(_Num = _Mysize + _Count - _N0))
+ {
+ if (_N0 < _Count)
+ _Traits_helper::move_s<_Traits>(_Myptr() + _Off + _Count, _Myres - _Off - _Count,
+ _Myptr() + _Off + _N0, _Nm);
+ _Chassign(_Off, _Count, _Ch);
+ _Eos(_Num);
+ }
+ return (*this);
+ }
+
+ _Myt& replace(iterator _First, iterator _Last, const _Myt& _Right)
+ {
+ return (replace(
+ _Pdif(_First, begin()), _Pdif(_Last, _First), _Right));
+ }
+
+ _Myt& replace(iterator _First, iterator _Last, const _Elem *_Ptr,
+ size_type _Count)
+ {
+ return (replace(
+ _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count));
+ }
+
+ _Myt& replace(iterator _First, iterator _Last, const _Elem *_Ptr)
+ {
+ return (replace(
+ _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr));
+ }
+
+ _Myt& replace(iterator _First, iterator _Last,
+ size_type _Count, _Elem _Ch)
+ {
+ return (replace(
+ _Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Ch));
+ }
+
+ template<class _It>
+ _Myt& replace(iterator _First, iterator _Last,
+ _It _First2, _It _Last2)
+ {
+ return (_Replace(_First, _Last,
+ _First2, _Last2, _Iter_cat(_First2)));
+ }
+
+ template<class _It>
+ _Myt& _Replace(iterator _First, iterator _Last,
+ _It _Count, _It _Ch, _Int_iterator_tag)
+ {
+ return (replace(_First, _Last, (size_type)_Count, (_Elem)_Ch));
+ }
+
+ template<class _It>
+ _Myt& _Replace(iterator _First, iterator _Last,
+ _It _First2, _It _Last2, input_iterator_tag)
+ {
+ _Myt _Right(_First2, _Last2);
+ replace(_First, _Last, _Right);
+ return (*this);
+ }
+
+ _Myt& replace(iterator _First, iterator _Last,
+ const_pointer _First2, const_pointer _Last2)
+ {
+ if (_First2 == _Last2)
+ erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
+ else
+ replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
+ &*_First2, _Last2 - _First2);
+ return (*this);
+ }
+
+ _Myt& replace(iterator _First, iterator _Last,
+ const_iterator _First2, const_iterator _Last2)
+ {
+ if (_First2 == _Last2)
+ erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
+ else
+ replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
+ &*_First2, _Last2 - _First2);
+ return (*this);
+ }
+
+ iterator begin()
+ {
+ return (iterator(_Myptr(), this));
+ }
+
+ const_iterator begin() const
+ {
+ return (const_iterator(_Myptr(), this));
+ }
+
+ iterator end()
+ {
+ return (iterator(_Myptr() + _Mysize, this));
+ }
+
+ const_iterator end() const
+ {
+ return (const_iterator(_Myptr() + _Mysize, this));
+ }
+
+ reverse_iterator rbegin()
+ {
+ return (reverse_iterator(end()));
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return (const_reverse_iterator(end()));
+ }
+
+ reverse_iterator rend()
+ {
+ return (reverse_iterator(begin()));
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return (const_reverse_iterator(begin()));
+ }
+
+ reference at(size_type _Off)
+ {
+ if (_Mysize <= _Off)
+ _String_base::_Xran();
+ return (_Myptr()[_Off]);
+ }
+
+ const_reference at(size_type _Off) const
+ {
+ if (_Mysize <= _Off)
+ _String_base::_Xran();
+ return (_Myptr()[_Off]);
+ }
+
+
+
+ reference operator[](size_type _Off)
+ {
+
+
+
+
+
+
+
+
+
+
+
+
+ { if (!(_Off <= _Mysize)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myptr()[_Off]);
+ }
+
+ const_reference operator[](size_type _Off) const
+ {
+
+
+
+
+
+
+
+
+
+
+
+
+ { if (!(_Off <= _Mysize)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myptr()[_Off]);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ void push_back(_Elem _Ch)
+ {
+ insert(end(), _Ch);
+ }
+
+ const _Elem * c_str() const
+ {
+ return (_Myptr());
+ }
+
+ const _Elem * data() const
+ {
+ return (c_str());
+ }
+
+ size_type length() const
+ {
+ return (_Mysize);
+ }
+
+ size_type size() const
+ {
+ return (_Mysize);
+ }
+
+ size_type max_size() const
+ {
+ size_type _Num = _Mybase::_Alval.max_size();
+ return (_Num <= 1 ? 1 : _Num - 1);
+ }
+
+ void resize(size_type _Newsize)
+ {
+ resize(_Newsize, _Elem());
+ }
+
+ void resize(size_type _Newsize, _Elem _Ch)
+ {
+ if (_Newsize <= _Mysize)
+ erase(_Newsize);
+ else
+ append(_Newsize - _Mysize, _Ch);
+ }
+
+ size_type capacity() const
+ {
+ return (_Myres);
+ }
+
+ void reserve(size_type _Newcap = 0)
+ {
+ if (_Mysize <= _Newcap && _Myres != _Newcap)
+ {
+ size_type _Size = _Mysize;
+ if (_Grow(_Newcap, true))
+ _Eos(_Size);
+ }
+ }
+
+ bool empty() const
+ {
+ return (_Mysize == 0);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ size_type copy(_Elem *_Dest,
+ size_type _Count, size_type _Off = 0) const
+ {
+
+ return _Copy_s(_Dest, _Count, _Count, _Off);
+ }
+
+ size_type _Copy_s(_Elem *_Dest, size_type _Dest_size,
+ size_type _Count, size_type _Off = 0) const
+ {
+ ;
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _Count)
+ _Count = _Mysize - _Off;
+ _Traits_helper::copy_s<_Traits>(_Dest, _Dest_size, _Myptr() + _Off, _Count);
+ return (_Count);
+ }
+
+ void swap(_Myt& _Right)
+ {
+ if (_Mybase::_Alval == _Right._Alval)
+ {
+
+
+
+
+
+ _Bxty _Tbx = _Bx;
+ _Bx = _Right._Bx, _Right._Bx = _Tbx;
+
+ size_type _Tlen = _Mysize;
+ _Mysize = _Right._Mysize, _Right._Mysize = _Tlen;
+
+ size_type _Tres = _Myres;
+ _Myres = _Right._Myres, _Right._Myres = _Tres;
+ }
+ else
+ {
+ _Myt _Tmp = *this; *this = _Right, _Right = _Tmp;
+ }
+ }
+
+ size_type find(const _Myt& _Right, size_type _Off = 0) const
+ {
+ return (find(_Right._Myptr(), _Off, _Right.size()));
+ }
+
+ size_type find(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (_Count == 0 && _Off <= _Mysize)
+ return (_Off);
+
+ size_type _Nm;
+ if (_Off < _Mysize && _Count <= (_Nm = _Mysize - _Off))
+ {
+ const _Elem *_Uptr, *_Vptr;
+ for (_Nm -= _Count - 1, _Vptr = _Myptr() + _Off;
+ (_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
+ _Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
+ if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
+ return (_Uptr - _Myptr());
+ }
+
+ return (npos);
+ }
+
+ size_type find(const _Elem *_Ptr, size_type _Off = 0) const
+ {
+ return (find(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type find(_Elem _Ch, size_type _Off = 0) const
+ {
+ return (find((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ size_type rfind(const _Myt& _Right, size_type _Off = npos) const
+ {
+ return (rfind(_Right._Myptr(), _Off, _Right.size()));
+ }
+
+ size_type rfind(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (_Count == 0)
+ return (_Off < _Mysize ? _Off : _Mysize);
+ if (_Count <= _Mysize)
+ {
+ const _Elem *_Uptr = _Myptr() +
+ (_Off < _Mysize - _Count ? _Off : _Mysize - _Count);
+ for (; ; --_Uptr)
+ if (_Traits::eq(*_Uptr, *_Ptr)
+ && _Traits::compare(_Uptr, _Ptr, _Count) == 0)
+ return (_Uptr - _Myptr());
+ else if (_Uptr == _Myptr())
+ break;
+ }
+
+ return (npos);
+ }
+
+ size_type rfind(const _Elem *_Ptr, size_type _Off = npos) const
+ {
+ return (rfind(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type rfind(_Elem _Ch, size_type _Off = npos) const
+ {
+ return (rfind((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ size_type find_first_of(const _Myt& _Right,
+ size_type _Off = 0) const
+ {
+ return (find_first_of(_Right._Myptr(), _Off, _Right.size()));
+ }
+
+ size_type find_first_of(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (0 < _Count && _Off < _Mysize)
+ {
+ const _Elem *const _Vptr = _Myptr() + _Mysize;
+ for (const _Elem *_Uptr = _Myptr() + _Off; _Uptr < _Vptr; ++_Uptr)
+ if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
+ return (_Uptr - _Myptr());
+ }
+
+ return (npos);
+ }
+
+ size_type find_first_of(const _Elem *_Ptr, size_type _Off = 0) const
+ {
+ return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type find_first_of(_Elem _Ch, size_type _Off = 0) const
+ {
+ return (find((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ size_type find_last_of(const _Myt& _Right,
+ size_type _Off = npos) const
+ {
+ return (find_last_of(_Right._Myptr(), _Off, _Right.size()));
+ }
+
+ size_type find_last_of(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (0 < _Count && 0 < _Mysize)
+ for (const _Elem *_Uptr = _Myptr()
+ + (_Off < _Mysize ? _Off : _Mysize - 1); ; --_Uptr)
+ if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
+ return (_Uptr - _Myptr());
+ else if (_Uptr == _Myptr())
+ break;
+
+ return (npos);
+ }
+
+ size_type find_last_of(const _Elem *_Ptr,
+ size_type _Off = npos) const
+ {
+ return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type find_last_of(_Elem _Ch, size_type _Off = npos) const
+ {
+ return (rfind((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ size_type find_first_not_of(const _Myt& _Right,
+ size_type _Off = 0) const
+ {
+ return (find_first_not_of(_Right._Myptr(), _Off,
+ _Right.size()));
+ }
+
+ size_type find_first_not_of(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (_Off < _Mysize)
+ {
+ const _Elem *const _Vptr = _Myptr() + _Mysize;
+ for (const _Elem *_Uptr = _Myptr() + _Off; _Uptr < _Vptr; ++_Uptr)
+ if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
+ return (_Uptr - _Myptr());
+ }
+ return (npos);
+ }
+
+ size_type find_first_not_of(const _Elem *_Ptr,
+ size_type _Off = 0) const
+ {
+ return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type find_first_not_of(_Elem _Ch, size_type _Off = 0) const
+ {
+ return (find_first_not_of((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ size_type find_last_not_of(const _Myt& _Right,
+ size_type _Off = npos) const
+ {
+ return (find_last_not_of(_Right._Myptr(), _Off, _Right.size()));
+ }
+
+ size_type find_last_not_of(const _Elem *_Ptr,
+ size_type _Off, size_type _Count) const
+ {
+ ;
+ if (0 < _Mysize)
+ for (const _Elem *_Uptr = _Myptr()
+ + (_Off < _Mysize ? _Off : _Mysize - 1); ; --_Uptr)
+ if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
+ return (_Uptr - _Myptr());
+ else if (_Uptr == _Myptr())
+ break;
+ return (npos);
+ }
+
+ size_type find_last_not_of(const _Elem *_Ptr,
+ size_type _Off = npos) const
+ {
+ return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
+ }
+
+ size_type find_last_not_of(_Elem _Ch, size_type _Off = npos) const
+ {
+ return (find_last_not_of((const _Elem *)&_Ch, _Off, 1));
+ }
+
+ _Myt substr(size_type _Off = 0, size_type _Count = npos) const
+ {
+ return (_Myt(*this, _Off, _Count));
+ }
+
+ int compare(const _Myt& _Right) const
+ {
+ return (compare(0, _Mysize, _Right._Myptr(), _Right.size()));
+ }
+
+ int compare(size_type _Off, size_type _N0,
+ const _Myt& _Right) const
+ {
+ return (compare(_Off, _N0, _Right, 0, npos));
+ }
+
+ int compare(size_type _Off,
+ size_type _N0, const _Myt& _Right,
+ size_type _Roff, size_type _Count) const
+ {
+ if (_Right.size() < _Roff)
+ _String_base::_Xran();
+ if (_Right._Mysize - _Roff < _Count)
+ _Count = _Right._Mysize - _Roff;
+ return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count));
+ }
+
+ int compare(const _Elem *_Ptr) const
+ {
+ return (compare(0, _Mysize, _Ptr, _Traits::length(_Ptr)));
+ }
+
+ int compare(size_type _Off, size_type _N0, const _Elem *_Ptr) const
+ {
+ return (compare(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
+ }
+
+ int compare(size_type _Off,
+ size_type _N0, const _Elem *_Ptr, size_type _Count) const
+ {
+ ;
+ if (_Mysize < _Off)
+ _String_base::_Xran();
+ if (_Mysize - _Off < _N0)
+ _N0 = _Mysize - _Off;
+
+ size_type _Ans = _Traits::compare(_Myptr() + _Off, _Ptr,
+ _N0 < _Count ? _N0 : _Count);
+ return (_Ans != 0 ? (int)_Ans : _N0 < _Count ? -1
+ : _N0 == _Count ? 0 : +1);
+ }
+
+ allocator_type get_allocator() const
+ {
+ return (_Mybase::_Alval);
+ }
+
+ enum
+ {
+ _BUF_SIZE = 16 / sizeof (_Elem) < 1 ? 1
+ : 16 / sizeof(_Elem)};
+
+protected:
+ enum
+ {
+ _ALLOC_MASK = sizeof (_Elem) <= 1 ? 15
+ : sizeof (_Elem) <= 2 ? 7
+ : sizeof (_Elem) <= 4 ? 3
+ : sizeof (_Elem) <= 8 ? 1 : 0};
+
+ void _Chassign(size_type _Off, size_type _Count, _Elem _Ch)
+ {
+ if (_Count == 1)
+ _Traits::assign(*(_Myptr() + _Off), _Ch);
+ else
+ _Traits::assign(_Myptr() + _Off, _Count, _Ch);
+ }
+
+ void _Copy(size_type _Newsize, size_type _Oldlen)
+ {
+ size_type _Newres = _Newsize | _ALLOC_MASK;
+ if (max_size() < _Newres)
+ _Newres = _Newsize;
+ else if (_Newres / 3 < _Myres / 2
+ && _Myres <= max_size() - _Myres / 2)
+ _Newres = _Myres + _Myres / 2;
+ _Elem *_Ptr = 0;
+
+ try {
+ _Ptr = _Mybase::_Alval.allocate(_Newres + 1);
+ } catch (...) {
+ _Newres = _Newsize;
+ try {
+ _Ptr = _Mybase::_Alval.allocate(_Newres + 1);
+ } catch (...) {
+ _Tidy(true);
+ throw;
+ }
+ }
+
+ if (0 < _Oldlen)
+ _Traits_helper::copy_s<_Traits>(_Ptr, _Newres + 1, _Myptr(), _Oldlen);
+ _Tidy(true);
+ _Bx._Ptr = _Ptr;
+ _Myres = _Newres;
+ _Eos(_Oldlen);
+ }
+
+ void _Eos(size_type _Newsize)
+ {
+ _Traits::assign(_Myptr()[_Mysize = _Newsize], _Elem());
+ }
+
+ bool _Grow(size_type _Newsize,
+ bool _Trim = false)
+ {
+ if (max_size() < _Newsize)
+ _String_base::_Xlen();
+ if (_Myres < _Newsize)
+ _Copy(_Newsize, _Mysize);
+ else if (_Trim && _Newsize < _BUF_SIZE)
+ _Tidy(true,
+ _Newsize < _Mysize ? _Newsize : _Mysize);
+ else if (_Newsize == 0)
+ _Eos(0);
+ return (0 < _Newsize);
+ }
+
+ bool _Inside(const _Elem *_Ptr)
+ {
+ ;
+ if (_Ptr < _Myptr() || _Myptr() + _Mysize <= _Ptr)
+ return (false);
+ else
+ return (true);
+ }
+
+ static size_type __cdecl _Pdif(const_iterator _P2,
+ const_iterator _P1)
+ {
+ return ((_P2)._Myptr == 0 ? 0 : _P2 - _P1);
+ }
+
+ void _Tidy(bool _Built = false,
+ size_type _Newsize = 0)
+ {
+ if (!_Built)
+ ;
+ else if (_BUF_SIZE <= _Myres)
+ {
+ _Elem *_Ptr = _Bx._Ptr;
+ if (0 < _Newsize)
+ _Traits_helper::copy_s<_Traits>(_Bx._Buf, _BUF_SIZE, _Ptr, _Newsize);
+ _Mybase::_Alval.deallocate(_Ptr, _Myres + 1);
+ }
+ _Myres = _BUF_SIZE - 1;
+ _Eos(_Newsize);
+ }
+
+ union _Bxty
+ {
+ _Elem _Buf[_BUF_SIZE];
+ _Elem *_Ptr;
+ } _Bx;
+
+ _Elem * _Myptr()
+ {
+ return (_BUF_SIZE <= _Myres ? _Bx._Ptr : _Bx._Buf);
+ }
+
+ const _Elem * _Myptr() const
+ {
+ return (_BUF_SIZE <= _Myres ? _Bx._Ptr : _Bx._Buf);
+ }
+
+ size_type _Mysize;
+ size_type _Myres;
+ };
+
+
+template<class _Elem, class _Traits, class _Ax>
+ class _Move_operation_category<basic_string<_Elem, _Traits, _Ax> >
+ {
+ public:
+ typedef _Swap_move_tag _Move_cat;
+ };
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ const typename basic_string<_Elem, _Traits, _Alloc>::size_type
+ basic_string<_Elem, _Traits, _Alloc>::npos =
+ (typename basic_string<_Elem, _Traits, _Alloc>::size_type)(-1);
+
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ void __cdecl swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
+ basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ _Left.swap(_Right);
+ }
+
+typedef basic_string<char, char_traits<char>, allocator<char> >
+ string;
+typedef basic_string<wchar_t, char_traits<wchar_t>,
+ allocator<wchar_t> > wstring;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+ #pragma warning(default: 4251)
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+
+
+
+
+class logic_error
+ : public std:: exception
+ {
+public:
+ explicit logic_error(const string& _Message)
+ : _Str(_Message)
+ {
+ }
+
+ virtual ~logic_error() throw ()
+ {
+ }
+
+ virtual const char * what() const throw ()
+ {
+ return (_Str.c_str());
+ }
+
+
+
+
+
+
+
+
+
+private:
+ string _Str;
+ };
+
+
+class domain_error
+ : public logic_error
+ {
+public:
+ explicit domain_error(const string& _Message)
+ : logic_error(_Message)
+ {
+ }
+
+ virtual ~domain_error() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class invalid_argument
+ : public logic_error
+ {
+public:
+ explicit invalid_argument(const string& _Message)
+ : logic_error(_Message)
+ {
+ }
+
+ virtual ~invalid_argument() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class length_error
+ : public logic_error
+ {
+public:
+ explicit length_error(const string& _Message)
+ : logic_error(_Message)
+ {
+ }
+
+ virtual ~length_error() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class out_of_range
+ : public logic_error
+ {
+public:
+ explicit out_of_range(const string& _Message)
+ : logic_error(_Message)
+ {
+ }
+
+ virtual ~out_of_range() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class runtime_error
+ : public std:: exception
+ {
+public:
+ explicit runtime_error(const string& _Message)
+ : _Str(_Message)
+ {
+ }
+
+ virtual ~runtime_error() throw ()
+ {
+ }
+
+ virtual const char * what() const throw ()
+ {
+ return (_Str.c_str());
+ }
+
+
+
+
+
+
+
+
+
+private:
+ string _Str;
+ };
+
+
+class overflow_error
+ : public runtime_error
+ {
+public:
+ explicit overflow_error(const string& _Message)
+ : runtime_error(_Message)
+ {
+ }
+
+ virtual ~overflow_error() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class underflow_error
+ : public runtime_error
+ {
+public:
+ explicit underflow_error(const string& _Message)
+ : runtime_error(_Message)
+ {
+ }
+
+ virtual ~underflow_error() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+class range_error
+ : public runtime_error
+ {
+public:
+ explicit range_error(const string& _Message)
+ : runtime_error(_Message)
+ {
+ }
+
+ virtual ~range_error() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+struct _DebugHeapTag_t
+ {
+ int _Type;
+ };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl _isctype( int _C, int _Type);
+ int __cdecl _isctype_l( int _C, int _Type, _locale_t _Locale);
+ int __cdecl isalpha( int _C);
+ int __cdecl _isalpha_l( int _C, _locale_t _Locale);
+ int __cdecl isupper( int _C);
+ int __cdecl _isupper_l( int _C, _locale_t _Locale);
+ int __cdecl islower( int _C);
+ int __cdecl _islower_l( int _C, _locale_t _Locale);
+ int __cdecl isdigit( int _C);
+ int __cdecl _isdigit_l( int _C, _locale_t _Locale);
+ int __cdecl isxdigit( int _C);
+ int __cdecl _isxdigit_l( int _C, _locale_t _Locale);
+ int __cdecl isspace( int _C);
+ int __cdecl _isspace_l( int _C, _locale_t _Locale);
+ int __cdecl ispunct( int _C);
+ int __cdecl _ispunct_l( int _C, _locale_t _Locale);
+ int __cdecl isalnum( int _C);
+ int __cdecl _isalnum_l( int _C, _locale_t _Locale);
+ int __cdecl isprint( int _C);
+ int __cdecl _isprint_l( int _C, _locale_t _Locale);
+ int __cdecl isgraph( int _C);
+ int __cdecl _isgraph_l( int _C, _locale_t _Locale);
+ int __cdecl iscntrl( int _C);
+ int __cdecl _iscntrl_l( int _C, _locale_t _Locale);
+ int __cdecl toupper( int _C);
+ int __cdecl tolower( int _C);
+ int __cdecl _tolower( int _C);
+ int __cdecl _tolower_l( int _C, _locale_t _Locale);
+ int __cdecl _toupper( int _C);
+ int __cdecl _toupper_l( int _C, _locale_t _Locale);
+ int __cdecl __isascii( int _C);
+ int __cdecl __toascii( int _C);
+ int __cdecl __iscsymf( int _C);
+ int __cdecl __iscsym( int _C);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct lconv {
+ char *decimal_point;
+ char *thousands_sep;
+ char *grouping;
+ char *int_curr_symbol;
+ char *currency_symbol;
+ char *mon_decimal_point;
+ char *mon_thousands_sep;
+ char *mon_grouping;
+ char *positive_sign;
+ char *negative_sign;
+ char int_frac_digits;
+ char frac_digits;
+ char p_cs_precedes;
+ char p_sep_by_space;
+ char n_cs_precedes;
+ char n_sep_by_space;
+ char p_sign_posn;
+ char n_sign_posn;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ int __cdecl _configthreadlocale( int _Flag);
+ char * __cdecl setlocale( int _Category, const char * _Locale);
+ struct lconv * __cdecl localeconv(void);
+ _locale_t __cdecl _get_current_locale(void);
+ _locale_t __cdecl _create_locale( int _Category, const char * _Locale);
+ void __cdecl _free_locale( _locale_t _Locale);
+
+
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "_get_current_locale" "instead. See online help for details.")) _locale_t __cdecl __get_current_locale(void);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "_create_locale" "instead. See online help for details.")) _locale_t __cdecl __create_locale( int _Category, const char * _Locale);
+__declspec(deprecated("This function or variable has been superceded by newer library or operating system functionality. Consider using" "_free_locale" "instead. See online help for details.")) void __cdecl __free_locale( _locale_t _Locale);
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef struct _Collvec
+ {
+ unsigned long _Hand;
+ unsigned int _Page;
+ } _Collvec;
+
+typedef struct _Ctypevec
+ {
+ unsigned long _Hand;
+ unsigned int _Page;
+ const short *_Table;
+ int _Delfl;
+ } _Ctypevec;
+
+typedef struct _Cvtvec
+ {
+ unsigned long _Hand;
+ unsigned int _Page;
+ } _Cvtvec;
+
+
+ _Collvec __cdecl _Getcoll();
+ _Ctypevec __cdecl _Getctype();
+ _Cvtvec __cdecl _Getcvt();
+
+ int __cdecl _Getdateorder();
+
+ int __cdecl _Mbrtowc( wchar_t *, const char *, size_t,
+ mbstate_t *, const _Cvtvec *);
+ float __cdecl _Stof(const char *, char **, long);
+ double __cdecl _Stod(const char *, char **, long);
+ long double __cdecl _Stold(const char *, char **,
+ long);
+ int __cdecl _Strcoll(const char *, const char *,
+ const char *, const char *, const _Collvec *);
+ size_t __cdecl _Strxfrm(
+ char * _String1,
+ char * _End1, const char *, const char *, const _Collvec *);
+ int __cdecl _Tolower(int, const _Ctypevec *);
+ int __cdecl _Toupper(int, const _Ctypevec *);
+ int __cdecl _Wcrtomb( char *, wchar_t, mbstate_t *,
+ const _Cvtvec *);
+ int __cdecl _Wcscoll(const wchar_t *, const wchar_t *,
+ const wchar_t *, const wchar_t *, const _Collvec *);
+ size_t __cdecl _Wcsxfrm(
+ wchar_t *_String1,
+ wchar_t *_End1, const wchar_t *, const wchar_t *, const _Collvec *);
+
+ short __cdecl _Getwctype(wchar_t, const _Ctypevec *);
+ const wchar_t * __cdecl _Getwctypes(const wchar_t *, const wchar_t *,
+ short*, const _Ctypevec*);
+ wchar_t __cdecl _Towlower(wchar_t, const _Ctypevec *);
+ wchar_t __cdecl _Towupper(wchar_t, const _Ctypevec *);
+
+}
+
+
+
+extern "C" {
+ void *__cdecl _Gettnames();
+ char *__cdecl _Getdays();
+ char *__cdecl _Getmonths();
+ size_t __cdecl _Strftime(
+ char *, size_t _Maxsize,
+ const char *, const struct tm *, void *);
+}
+
+extern "C" {
+_locale_t __cdecl _GetLocaleForCP(unsigned int);
+}
+
+
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+#pragma warning(disable:4412)
+
+
+namespace std {
+
+
+class _Timevec
+ {
+public:
+ _Timevec(void *_Ptr = 0)
+ : _Timeptr(_Ptr)
+ {
+ }
+
+ _Timevec(const _Timevec& _Right)
+ {
+ *this = _Right;
+ }
+
+ ~_Timevec()
+ {
+ free(_Timeptr);
+ }
+
+ _Timevec& operator=(const _Timevec& _Right)
+ {
+ _Timeptr = _Right._Timeptr;
+ ((_Timevec *)&_Right)->_Timeptr = 0;
+ return (*this);
+ }
+
+ void * _Getptr() const
+ {
+ return (_Timeptr);
+ }
+
+private:
+ void *_Timeptr;
+ };
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4412)
+class _Locinfo
+ {
+public:
+ typedef ::_Collvec _Collvec;
+ typedef ::_Ctypevec _Ctypevec;
+ typedef ::_Cvtvec _Cvtvec;
+ typedef std::_Timevec _Timevec;
+
+ static void __cdecl _Locinfo_ctor(_Locinfo *, const char *);
+ static void __cdecl _Locinfo_ctor(_Locinfo *, int, const char *);
+ static void __cdecl _Locinfo_dtor(_Locinfo *);
+ static _Locinfo& __cdecl _Locinfo_Addcats(_Locinfo *, int, const char *);
+
+ _Locinfo(const char *_Pch = "C")
+
+ : _Lock(0)
+
+ {
+ if (_Pch == 0)
+ throw runtime_error("bad locale name");
+ _Locinfo_ctor(this, _Pch);
+ }
+
+ _Locinfo(int _I, const char *_Pch)
+
+ : _Lock(0)
+
+ {
+ if (_Pch == 0)
+ throw runtime_error("bad locale name");
+ _Locinfo_ctor(this, _I, _Pch);
+ }
+
+ ~_Locinfo()
+ {
+ _Locinfo_dtor(this);
+ }
+
+ _Locinfo& _Addcats(int _I, const char *_Pch)
+ {
+ if (_Pch == 0)
+ throw runtime_error("bad locale name");
+ return _Locinfo_Addcats(this, _I, _Pch);
+ }
+
+ string _Getname() const
+ {
+ return (_Newlocname);
+ }
+
+ _Collvec _Getcoll() const
+ {
+ return (::_Getcoll());
+ }
+
+ _Ctypevec _Getctype() const
+ {
+ return (::_Getctype());
+ }
+
+ _Cvtvec _Getcvt() const
+ {
+ return (::_Getcvt());
+ }
+
+ const lconv * _Getlconv() const
+ {
+ return (localeconv());
+ }
+
+ _Timevec _Gettnames() const
+ {
+ return (_Timevec(::_Gettnames()));
+ }
+
+ const char * _Getdays() const
+ {
+ const char *_Ptr = ::_Getdays();
+ if (_Ptr != 0)
+ {
+ ((_Locinfo *)this)->_Days = _Ptr;
+ free((void *)_Ptr);
+ }
+ return (_Days.size() != 0 ? _Days.c_str()
+ : ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday"
+ ":Thu:Thursday:Fri:Friday:Sat:Saturday");
+ }
+
+ const char * _Getmonths() const
+ {
+ const char *_Ptr = ::_Getmonths();
+ if (_Ptr != 0)
+ {
+ ((_Locinfo *)this)->_Months = _Ptr;
+ free((void *)_Ptr);
+ }
+ return (_Months.size() != 0 ? _Months.c_str()
+ : ":Jan:January:Feb:February:Mar:March"
+ ":Apr:April:May:May:Jun:June"
+ ":Jul:July:Aug:August:Sep:September"
+ ":Oct:October:Nov:November:Dec:December");
+ }
+
+ const char * _Getfalse() const
+ {
+ return ("false");
+ }
+
+ const char * _Gettrue() const
+ {
+ return ("true");
+ }
+
+ int _Getdateorder() const
+ {
+ return ::_Getdateorder();
+ }
+
+private:
+
+
+
+
+
+ _Lockit _Lock;
+
+ string _Days;
+ string _Months;
+ string _Oldlocname;
+ string _Newlocname;
+ };
+#pragma warning(pop)
+
+
+template<class _Elem> inline
+ int __cdecl _LStrcoll(const _Elem *_First1, const _Elem *_Last1,
+ const _Elem *_First2, const _Elem *_Last2,
+ const _Locinfo::_Collvec *)
+ {
+ for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
+ if (*_First1 < *_First2)
+ return (-1);
+ else if (*_First2 < *_First1)
+ return (+1);
+ return (_First2 != _Last2 ? -1 : _First1 != _Last1 ? +1 : 0);
+ }
+
+template<> inline
+ int __cdecl _LStrcoll(const char *_First1, const char *_Last1,
+ const char *_First2, const char *_Last2,
+ const _Locinfo::_Collvec *_Vector)
+ {
+ return (_Strcoll(_First1, _Last1, _First2, _Last2, _Vector));
+ }
+
+template<> inline
+ int __cdecl _LStrcoll(const wchar_t *_First1, const wchar_t *_Last1,
+ const wchar_t *_First2, const wchar_t *_Last2,
+ const _Locinfo::_Collvec *_Vector)
+ {
+ return (_Wcscoll(_First1, _Last1, _First2, _Last2, _Vector));
+ }
+
+
+template<class _Elem> inline
+ size_t __cdecl _LStrxfrm(_Elem *_First1, _Elem *_Last1,
+ const _Elem *_First2, const _Elem *_Last2,
+ const _Locinfo::_Collvec *)
+ {
+ size_t _Count = _Last2 - _First2;
+ if (_Count <= (size_t)(_Last1 - _First1))
+ ::memcpy_s((_First1), ((_Last1 - _First1)* sizeof(_Elem)), (_First2), (_Count * sizeof (_Elem)));
+ return (_Count);
+ }
+
+template<> inline
+ size_t __cdecl _LStrxfrm(
+ char *_First1,
+ char *_Last1,
+ const char *_First2, const char *_Last2,
+ const _Locinfo::_Collvec *_Vector)
+ {
+ return (_Strxfrm(_First1, _Last1, _First2, _Last2, _Vector));
+ }
+
+template<> inline
+ size_t __cdecl _LStrxfrm(
+ wchar_t *_First1,
+ wchar_t *_Last1,
+ const wchar_t *_First2, const wchar_t *_Last2,
+ const _Locinfo::_Collvec *_Vector)
+ {
+ return (_Wcsxfrm(_First1, _Last1, _First2, _Last2, _Vector));
+ }
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+#pragma warning(disable:4412)
+
+
+namespace std {
+
+
+template<class _Dummy>
+ class _Locbase
+ {
+public:
+ static const int collate = ((1 << (1)) >> 1);
+ static const int ctype = ((1 << (2)) >> 1);
+ static const int monetary = ((1 << (3)) >> 1);
+ static const int numeric = ((1 << (4)) >> 1);
+ static const int time = ((1 << (5)) >> 1);
+ static const int messages = ((1 << (6)) >> 1);
+ static const int all = (((1 << (7)) >> 1) - 1);
+ static const int none = 0;
+ };
+
+template<class _Dummy>
+ const int _Locbase<_Dummy>::collate;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::ctype;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::monetary;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::numeric;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::time;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::messages;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::all;
+template<class _Dummy>
+ const int _Locbase<_Dummy>::none;
+
+
+class locale;
+template<class _Facet>
+ const _Facet& __cdecl use_facet(const locale&);
+
+
+#pragma warning(push)
+#pragma warning(disable:4412)
+class locale
+ : public _Locbase<int>
+ {
+public:
+ typedef int category;
+
+
+ class id
+ {
+ public:
+ id(size_t _Val = 0)
+ : _Id(_Val)
+ {
+ }
+
+ operator size_t()
+ {
+ if (_Id == 0)
+ {
+ { ::std:: _Lockit _Lock(0);
+ if (_Id == 0)
+ _Id = ++_Id_cnt;
+ }
+ }
+ return (_Id);
+ }
+
+ private:
+ id(const id&);
+ id& operator=(const id&);
+
+ size_t _Id;
+ static int& __cdecl _Id_cnt_func();
+
+
+
+ static int _Id_cnt;
+
+ };
+
+ class _Locimp;
+
+
+ class facet
+ {
+ friend class locale;
+ friend class _Locimp;
+
+ public:
+ static size_t __cdecl _Getcat(const facet ** = 0)
+ {
+ return ((size_t)(-1));
+ }
+
+ void _Incref()
+ {
+ { ::std:: _Lockit _Lock(0);
+ if (_Refs < (size_t)(-1))
+ ++_Refs;
+ }
+ }
+
+ facet * _Decref()
+ {
+ { ::std:: _Lockit _Lock(0);
+ if (0 < _Refs && _Refs < (size_t)(-1))
+ --_Refs;
+ return (_Refs == 0 ? this : 0);
+ }
+ }
+
+ void _Register()
+ {
+ facet_Register(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ virtual ~facet()
+ {
+ }
+
+ protected:
+ explicit facet(size_t _Initrefs = 0)
+ : _Refs(_Initrefs)
+ {
+ }
+
+ private:
+ static void __cdecl facet_Register(facet *);
+
+ facet(const facet&);
+ facet& operator=(const facet&);
+
+ size_t _Refs;
+ };
+
+
+ class _Locimp
+ : public facet
+ {
+ protected:
+ ~_Locimp()
+ {
+ _Locimp_dtor(this);
+ }
+
+ private:
+ static void __cdecl _Locimp_dtor(_Locimp *);
+ static void __cdecl _Locimp_ctor(_Locimp *,const _Locimp&);
+ static void __cdecl _Locimp_Addfac(_Locimp *,facet *, size_t);
+ friend class locale;
+
+ _Locimp(bool _Transparent = false)
+ : locale::facet(1), _Facetvec(0), _Facetcount(0),
+ _Catmask(none), _Xparent(_Transparent), _Name("*")
+ { }
+
+ _Locimp(const _Locimp& _Right)
+ : locale::facet(1), _Facetvec(0), _Facetcount(_Right._Facetcount),
+ _Catmask(_Right._Catmask), _Xparent(_Right._Xparent), _Name(_Right._Name)
+ {
+ _Locimp_ctor(this, _Right);
+ }
+
+ void _Addfac(facet *_Pfacet, size_t _Id)
+ {
+ _Locimp_Addfac(this, _Pfacet, _Id);
+ }
+
+ static _Locimp *__cdecl _Makeloc(const _Locinfo&,
+ category, _Locimp *, const locale *);
+
+ static void __cdecl _Makewloc(const _Locinfo&,
+ category, _Locimp *, const locale *);
+
+
+ static void __cdecl _Makeushloc(const _Locinfo&,
+ category, _Locimp *, const locale *);
+
+
+ static void __cdecl _Makexloc(const _Locinfo&,
+ category, _Locimp *, const locale *);
+
+ facet **_Facetvec;
+ size_t _Facetcount;
+ category _Catmask;
+ bool _Xparent;
+ string _Name;
+
+ static _Locimp *& __cdecl _Clocptr_func();
+
+
+
+ static _Locimp *_Clocptr;
+
+private:
+ _Locimp& operator=(const _Locimp&);
+
+ };
+
+ __declspec(deprecated("This is an obsolete part of the Standard C++ Library Implementation. Do not use it.")) locale& _Addfac(facet *_Fac, size_t _Id,
+ size_t _Catmask)
+ {
+ if (1 < this->_Ptr->_Refs)
+ {
+ this->_Ptr->_Decref();
+ this->_Ptr = new _Locimp(*this->_Ptr);
+ }
+ this->_Ptr->_Addfac(_Fac, _Id);
+
+ if (_Catmask != 0)
+ this->_Ptr->_Name = "*";
+ return (*this);
+ }
+
+ template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ bool operator()(const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right) const
+ {
+ const std::collate<_Elem>& _Coll_fac =
+ std::use_facet<std::collate<_Elem> >(*this);
+
+ return (_Coll_fac.compare(_Left.c_str(), _Left.c_str() + _Left.size(),
+ _Right.c_str(), _Right.c_str() + _Right.size()) < 0);
+ }
+
+ template<class _Facet>
+ locale combine(const locale& _Loc) const
+ {
+ _Facet *_Facptr;
+
+ try {
+ _Facptr = (_Facet *)&std::use_facet<_Facet>(_Loc);
+ } catch (...) {
+ throw runtime_error("locale::combine facet missing");
+ }
+
+ _Locimp *_Newimp = new _Locimp(*_Ptr);
+ _Newimp->_Addfac(_Facptr, _Facet::id);
+ _Newimp->_Catmask = 0;
+ _Newimp->_Name = "*";
+ return (locale(_Newimp));
+ }
+
+ template<class _Facet>
+ locale(const locale& _Loc, const _Facet *_Facptr)
+ : _Ptr(new _Locimp(*_Loc._Ptr))
+ {
+ if (_Facptr != 0)
+ {
+ _Ptr->_Addfac((_Facet *)_Facptr, _Facet::id);
+ if (_Facet::_Getcat() != (size_t)(-1))
+ _Ptr->_Catmask = 0, _Ptr->_Name = "*";
+ }
+ }
+
+
+ locale() throw ()
+ : _Ptr(_Init())
+ {
+ _Getgloballocale()->_Incref();
+ }
+
+ locale(_Uninitialized)
+ {
+ }
+
+ locale(const locale& _Right) throw ()
+ : _Ptr(_Right._Ptr)
+ {
+ _Ptr->_Incref();
+ }
+
+ locale(const locale& _Loc, const locale& _Other,
+ category _Cat)
+ : _Ptr(new _Locimp(*_Loc._Ptr))
+ {
+ try {
+ { _Locinfo _Lobj(_Loc._Ptr->_Catmask, _Loc._Ptr->_Name.c_str());
+ _Locimp::_Makeloc(_Lobj._Addcats(_Cat & _Other._Ptr->_Catmask,
+ _Other._Ptr->_Name.c_str()), _Cat, _Ptr, &_Other);
+ }
+ } catch (...) {
+ delete (_Ptr->_Decref());
+ throw;
+ }
+ }
+
+ explicit locale(const char *_Locname,
+ category _Cat = all)
+ : _Ptr(new _Locimp)
+ {
+ try {
+ _Init();
+ { _Locinfo _Lobj(_Cat, _Locname);
+ if (_Lobj._Getname().compare("*") == 0)
+ throw runtime_error("bad locale name");
+ _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, 0);
+ }
+ } catch (...) {
+ delete (_Ptr->_Decref());
+ throw;
+ }
+ }
+
+ locale(const locale& _Loc, const char * _Locname,
+ category _Cat)
+ : _Ptr(new _Locimp(*_Loc._Ptr))
+ {
+ try {
+ { _Locinfo _Lobj(_Loc._Ptr->_Catmask, _Loc._Ptr->_Name.c_str());
+ bool _Hadname = _Lobj._Getname().compare("*") != 0;
+ _Lobj._Addcats(_Cat, _Locname);
+
+ if (_Hadname && _Lobj._Getname().compare("*") == 0)
+ throw runtime_error("bad locale name");
+ _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, 0);
+ }
+ } catch (...) {
+ delete (_Ptr->_Decref());
+ throw;
+ }
+ }
+
+ ~locale() throw ()
+ {
+ if (_Ptr != 0)
+ delete (_Ptr->_Decref());
+ }
+
+ locale& operator=(const locale& _Right) throw ()
+ {
+ if (_Ptr != _Right._Ptr)
+ {
+ delete (_Ptr->_Decref());
+ _Ptr = _Right._Ptr;
+ _Ptr->_Incref();
+ }
+ return (*this);
+ }
+
+ string name() const
+ {
+ return (_Ptr->_Name);
+ }
+
+ const facet * _Getfacet(size_t _Id) const
+ {
+ const facet *_Facptr = _Id < _Ptr->_Facetcount
+ ? _Ptr->_Facetvec[_Id] : 0;
+ if (_Facptr != 0 || !_Ptr->_Xparent)
+ return (_Facptr);
+ else
+ {
+ locale::_Locimp *_Ptr = _Getgloballocale();
+ return (_Id < _Ptr->_Facetcount
+ ? _Ptr->_Facetvec[_Id]
+ : 0);
+ }
+ }
+
+
+ bool operator==(const locale& _Loc) const
+ {
+ return (_Ptr == _Loc._Ptr
+ || name().compare("*") != 0 && name().compare(_Loc.name()) == 0);
+ }
+
+ bool operator!=(const locale& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+ static const locale& __cdecl classic();
+
+ static locale __cdecl global(const locale&);
+
+ static locale __cdecl empty();
+
+private:
+ locale(_Locimp *_Ptrimp)
+ : _Ptr(_Ptrimp)
+ {
+ }
+
+ static _Locimp *__cdecl _Getgloballocale();
+ static _Locimp *__cdecl _Init();
+ static void __cdecl _Setgloballocale(void *);
+
+ _Locimp *_Ptr;
+ };
+#pragma warning(pop)
+
+
+template<class _Facet>
+ struct _Facetptr
+ {
+ static const locale::facet *_Psave;
+ };
+
+template<class _Facet>
+ const locale::facet *_Facetptr<_Facet>::_Psave = 0;
+
+template<class _Facet> inline __declspec(deprecated("This is an obsolete part of the Standard C++ Library Implementation. Do not use it."))
+ locale _Addfac(locale _Loc, const _Facet *_Facptr)
+ {
+ return (_Loc._Addfac((_Facet *)_Facptr, _Facet::id,
+ _Facet::_Getcat()));
+ }
+
+
+
+
+
+
+template<class _Facet> inline
+ const _Facet& __cdecl use_facet(const locale& _Loc)
+ {
+ { ::std:: _Lockit _Lock(0);
+ const locale::facet *_Psave =
+ _Facetptr<_Facet>::_Psave;
+
+ size_t _Id = _Facet::id;
+ const locale::facet *_Pf = _Loc._Getfacet(_Id);
+
+ if (_Pf != 0)
+ ;
+ else if (_Psave != 0)
+ _Pf = _Psave;
+ else if (_Facet::_Getcat(&_Psave) == (size_t)(-1))
+
+
+ throw bad_cast();
+
+
+
+
+
+ else
+ {
+ _Pf = _Psave;
+ _Facetptr<_Facet>::_Psave = _Psave;
+
+ locale::facet *_Pfmod = (_Facet *)_Psave;
+ _Pfmod->_Incref();
+ _Pfmod->_Register();
+ }
+
+ return ((const _Facet&)(*_Pf));
+ }
+ }
+
+template<class _Facet> inline __declspec(deprecated("This is an obsolete part of the Standard C++ Library Implementation. Do not use it."))
+ const _Facet& __cdecl use_facet(const locale& _Loc, const _Facet *,
+ bool = false)
+ {
+ return use_facet<_Facet>(_Loc);
+ }
+
+
+template<class _Elem,
+ class _InIt> inline
+ int __cdecl _Getloctxt(_InIt& _First, _InIt& _Last, size_t _Numfields,
+ const _Elem *_Ptr)
+ {
+ for (size_t _Off = 0; _Ptr[_Off] != (_Elem)0; ++_Off)
+ if (_Ptr[_Off] == _Ptr[0])
+ ++_Numfields;
+ string _Str(_Numfields, '\0');
+
+ int _Ans = -2;
+ for (size_t _Column = 1; ; ++_Column, ++_First, _Ans = -1)
+ {
+ bool _Prefix = false;
+ size_t _Off = 0;
+ size_t _Field = 0;
+
+ for (; _Field < _Numfields; ++_Field)
+ {
+ for (; _Ptr[_Off] != (_Elem)0 && _Ptr[_Off] != _Ptr[0]; ++_Off)
+ ;
+
+ if (_Str[_Field] != '\0')
+ _Off += _Str[_Field];
+ else if (_Ptr[_Off += _Column] == _Ptr[0]
+ || _Ptr[_Off] == (_Elem)0)
+ {
+ _Str[_Field] = (char)(_Column < 127
+ ? _Column : 127);
+ _Ans = (int)_Field;
+ }
+ else if (_First == _Last || _Ptr[_Off] != *_First)
+ _Str[_Field] = (char)(_Column < 127
+ ? _Column : 127);
+ else
+ _Prefix = true;
+ }
+
+ if (!_Prefix || _First == _Last)
+ break;
+ }
+ return (_Ans);
+ }
+
+
+
+
+
+template<class _Elem> inline
+ char __cdecl _Maklocbyte(_Elem _Char,
+ const _Locinfo::_Cvtvec&)
+ {
+ return ((char)(unsigned char)_Char);
+ }
+
+template<> inline
+ char __cdecl _Maklocbyte(wchar_t _Char,
+ const _Locinfo::_Cvtvec& _Cvt)
+ {
+ char _Byte = '\0';
+ mbstate_t _Mbst1 = {0};
+ _Wcrtomb(&_Byte, _Char, &_Mbst1, &_Cvt);
+ return (_Byte);
+ }
+
+
+
+
+
+
+template<class _Elem> inline
+ _Elem __cdecl _Maklocchr(char _Byte, _Elem *,
+ const _Locinfo::_Cvtvec&)
+ {
+ return ((_Elem)(unsigned char)_Byte);
+ }
+
+template<> inline
+ wchar_t __cdecl _Maklocchr(char _Byte, wchar_t *,
+ const _Locinfo::_Cvtvec& _Cvt)
+ {
+ wchar_t _Wc = L'\0';
+ mbstate_t _Mbst1 = {0};
+ _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst1, &_Cvt);
+ return (_Wc);
+ }
+
+
+
+
+
+
+template<class _Elem> inline
+ _Elem *__cdecl _Maklocstr(const char *_Ptr, _Elem *,
+ const _Locinfo::_Cvtvec&)
+ {
+ size_t _Count = ::strlen(_Ptr) + 1;
+ _Elem *_Ptrdest = new _Elem[_Count];
+
+#pragma warning(push)
+#pragma warning(disable: 6011)
+
+ for (_Elem *_Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr)
+ *_Ptrnext = (_Elem)(unsigned char)*_Ptr;
+ return (_Ptrdest);
+#pragma warning(pop)
+ }
+
+template<> inline
+ wchar_t *__cdecl _Maklocstr(const char *_Ptr, wchar_t *,
+ const _Locinfo::_Cvtvec& _Cvt)
+ {
+ size_t _Count, _Count1;
+ size_t _Wchars;
+ const char *_Ptr1;
+ int _Bytes;
+ wchar_t _Wc;
+ mbstate_t _Mbst1 = {0};
+
+ _Count1 = ::strlen(_Ptr) + 1;
+ for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count;
+ _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars)
+ if ((_Bytes = _Mbrtowc(&_Wc, _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0)
+ break;
+ ++_Wchars;
+
+ wchar_t *_Ptrdest = new wchar_t[_Wchars];
+ wchar_t *_Ptrnext = _Ptrdest;
+ mbstate_t _Mbst2 = {0};
+#pragma warning(push)
+#pragma warning(disable: 6011)
+
+ for (; 0 < _Wchars;
+ _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext)
+ if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0)
+ break;
+ *_Ptrnext = L'\0';
+#pragma warning(pop)
+ return (_Ptrdest);
+ }
+
+
+
+class codecvt_base
+ : public locale::facet
+ {
+public:
+ enum
+ {
+ ok, partial, error, noconv};
+ typedef int result;
+
+ codecvt_base(size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ }
+
+ bool always_noconv() const throw ()
+ {
+ return (do_always_noconv());
+ }
+
+ int max_length() const throw ()
+ {
+ return (do_max_length());
+ }
+
+ int encoding() const throw ()
+ {
+ return (do_encoding());
+ }
+
+ ~codecvt_base()
+ {
+ }
+
+protected:
+ virtual bool do_always_noconv() const throw ()
+ {
+ return (true);
+ }
+
+ virtual int do_max_length() const throw ()
+ {
+ return (1);
+ }
+
+ virtual int do_encoding() const throw ()
+ {
+ return (1);
+ }
+ };
+
+
+template<class _Elem,
+ class _Byte,
+ class _Statype>
+ class codecvt
+ : public codecvt_base
+ {
+public:
+ typedef _Elem intern_type;
+ typedef _Byte extern_type;
+ typedef _Statype state_type;
+
+ result in(_Statype& _State,
+ const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
+ {
+ return (do_in(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result out(_Statype& _State,
+ const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_out(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result unshift(_Statype& _State,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_unshift(_State, _First2, _Last2, _Mid2));
+ }
+
+ int length(const _Statype& _State, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ return (do_length(_State, _First1, _Last1, _Count));
+ }
+
+ static locale::id id;
+
+ explicit codecvt(size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new codecvt<_Elem, _Byte, _Statype>;
+ return (2);
+ }
+
+protected:
+ virtual ~codecvt()
+ {
+ }
+
+protected:
+ void _Init(const _Locinfo&)
+ {
+ }
+
+ virtual result do_in(_Statype&,
+ const _Byte *_First1, const _Byte *, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *, _Elem *& _Mid2) const
+ {
+ _Mid1 = _First1, _Mid2 = _First2;
+ return (noconv);
+ }
+
+ virtual result do_out(_Statype&,
+ const _Elem *_First1, const _Elem *, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *, _Byte *& _Mid2) const
+ {
+ _Mid1 = _First1, _Mid2 = _First2;
+ return (noconv);
+ }
+
+ virtual result do_unshift(_Statype&,
+ _Byte *_First2, _Byte *, _Byte *&_Mid2) const
+ {
+ _Mid2 = _First2;
+ return (noconv);
+ }
+
+ virtual int do_length(const _Statype&, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ return ((int)(_Count < (size_t)(_Last1 - _First1)
+ ? _Count : _Last1 - _First1));
+ }
+ };
+
+
+template<class _Elem,
+ class _Byte,
+ class _Statype>
+ locale::id codecvt<_Elem, _Byte, _Statype>::id;
+
+
+template<> class codecvt<wchar_t, char, _Mbstatet>
+ : public codecvt_base
+ {
+public:
+ typedef wchar_t _Elem;
+ typedef char _Byte;
+ typedef _Mbstatet _Statype;
+ typedef _Elem intern_type;
+ typedef _Byte extern_type;
+ typedef _Statype state_type;
+
+ result in(_Statype& _State,
+ const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
+ {
+ return (do_in(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result out(_Statype& _State,
+ const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_out(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result unshift(_Statype& _State,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_unshift(_State,
+ _First2, _Last2, _Mid2));
+ }
+
+ int length(const _Statype& _State, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ return (do_length(_State, _First1, _Last1, _Count));
+ }
+
+ static locale::id& __cdecl _Id_func();
+
+
+
+ static locale::id id;
+
+
+ explicit codecvt(size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new codecvt<_Elem, _Byte, _Statype>;
+ return (2);
+ }
+
+protected:
+ virtual ~codecvt()
+ {
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ virtual result do_in(_Statype& _State,
+ const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
+ {
+ ;
+ ;
+ _Mid1 = _First1, _Mid2 = _First2;
+ result _Ans = _Mid1 == _Last1 ? ok : partial;
+ int _Bytes;
+
+ while (_Mid1 != _Last1 && _Mid2 != _Last2)
+ switch (_Bytes = _Mbrtowc(_Mid2, _Mid1, _Last1 - _Mid1,
+ &_State, &_Cvt))
+ {
+ case -2:
+ _Mid1 = _Last1;
+ return (_Ans);
+
+ case -1:
+ return (error);
+
+ case 0:
+ if (*_Mid2 == (_Elem)0)
+ _Bytes = (int)::strlen(_Mid1) + 1;
+
+
+ default:
+ if (_Bytes == -3)
+ _Bytes = 0;
+ _Mid1 += _Bytes;
+ ++_Mid2;
+ _Ans = ok;
+ }
+ return (_Ans);
+ }
+
+ virtual result do_out(_Statype& _State,
+ const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ ;
+ ;
+ _Mid1 = _First1, _Mid2 = _First2;
+ result _Ans = _Mid1 == _Last1 ? ok : partial;
+ int _Bytes;
+
+ while (_Mid1 != _Last1 && _Mid2 != _Last2)
+ if (5 <= _Last2 - _Mid2)
+ if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1,
+ &_State, &_Cvt)) < 0)
+ return (error);
+ else
+ ++_Mid1, _Mid2 += _Bytes, _Ans = ok;
+ else
+ {
+ _Byte _Buf[5];
+ _Statype _Stsave = _State;
+
+ if ((_Bytes = _Wcrtomb(_Buf, *_Mid1,
+ &_State, &_Cvt)) < 0)
+ return (error);
+ else if (_Last2 - _Mid2 < _Bytes)
+ {
+ _State = _Stsave;
+ return (_Ans);
+ }
+ else
+ {
+ ::memcpy_s((_Mid2), (_Last2 - _Mid2), (_Buf), (_Bytes));
+ ++_Mid1, _Mid2 += _Bytes, _Ans = ok;
+ }
+ }
+ return (_Ans);
+ }
+
+ virtual result do_unshift(_Statype& _State,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ ;
+ _Mid2 = _First2;
+ result _Ans = ok;
+ int _Bytes;
+ _Byte _Buf[5];
+ _Statype _Stsave = _State;
+
+ if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0)
+ _Ans = error;
+ else if (_Last2 - _Mid2 < --_Bytes)
+ {
+ _State = _Stsave;
+ _Ans = partial;
+ }
+ else if (0 < _Bytes)
+ {
+ ::memcpy_s((_Mid2), (_Last2 - _Mid2), (_Buf), (_Bytes));
+ _Mid2 += _Bytes;
+ }
+ return (_Ans);
+ }
+
+ virtual int do_length(const _Statype& _State, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ ;
+ int _Wchars;
+ const _Byte *_Mid1;
+ _Statype _Mystate = _State;
+
+ for (_Wchars = 0, _Mid1 = _First1;
+ (size_t)_Wchars < _Count && _Mid1 != _Last1; )
+ {
+ int _Bytes;
+ _Elem _Ch;
+
+ switch (_Bytes = _Mbrtowc(&_Ch, _Mid1, _Last1 - _Mid1,
+ &_Mystate, &_Cvt))
+ {
+ case -2:
+ return (_Wchars);
+
+ case -1:
+ return (_Wchars);
+
+ case 0:
+ if (_Ch == (_Elem)0)
+ _Bytes = (int)::strlen(_Mid1) + 1;
+
+
+ default:
+ if (_Bytes == -3)
+ _Bytes = 0;
+ _Mid1 += _Bytes;
+ ++_Wchars;
+ }
+ }
+ return (_Wchars);
+ }
+
+ virtual bool do_always_noconv() const throw ()
+ {
+ return (false);
+ }
+
+ virtual int do_max_length() const throw ()
+ {
+ return (5);
+ }
+
+ virtual int do_encoding() const throw ()
+ {
+ return (0);
+ }
+
+private:
+ _Locinfo::_Cvtvec _Cvt;
+ };
+
+
+
+template<> class codecvt<unsigned short, char, _Mbstatet>
+ : public codecvt_base
+ {
+public:
+ typedef unsigned short _Elem;
+ typedef char _Byte;
+ typedef _Mbstatet _Statype;
+ typedef _Elem intern_type;
+ typedef _Byte extern_type;
+ typedef _Statype state_type;
+
+ result in(_Statype& _State,
+ const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
+ {
+ return (do_in(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result out(_Statype& _State,
+ const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_out(_State,
+ _First1, _Last1, _Mid1, _First2, _Last2, _Mid2));
+ }
+
+ result unshift(_Statype& _State,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ return (do_unshift(_State,
+ _First2, _Last2, _Mid2));
+ }
+
+ int length(const _Statype& _State, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ return (do_length(_State, _First1, _Last1, _Count));
+ }
+
+ static locale::id& __cdecl _Id_func();
+
+
+
+ static locale::id id;
+
+
+ explicit codecvt(size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new codecvt<_Elem, _Byte, _Statype>;
+ return (2);
+ }
+
+protected:
+ virtual ~codecvt()
+ {
+ }
+
+protected:
+ codecvt(const char *_Locname, size_t _Refs = 0)
+ : codecvt_base(_Refs)
+ {
+ { _Locinfo _Lobj(_Locname);
+ _Init(_Lobj);
+ }
+ }
+
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ virtual result do_in(_Statype& _State,
+ const _Byte *_First1, const _Byte *_Last1, const _Byte *& _Mid1,
+ _Elem *_First2, _Elem *_Last2, _Elem *& _Mid2) const
+ {
+ ;
+ ;
+ _Mid1 = _First1, _Mid2 = _First2;
+ result _Ans = _Mid1 == _Last1 ? ok : partial;
+ int _Bytes;
+
+ while (_Mid1 != _Last1 && _Mid2 != _Last2)
+ switch (_Bytes = _Mbrtowc((wchar_t *)_Mid2, _Mid1, _Last1 - _Mid1,
+ &_State, &_Cvt))
+ {
+ case -2:
+ _Mid1 = _Last1;
+ return (_Ans);
+
+ case -1:
+ return (error);
+
+ case 0:
+ if (*_Mid2 == (_Elem)0)
+ _Bytes = (int)::strlen(_Mid1) + 1;
+
+
+ default:
+ if (_Bytes == -3)
+ _Bytes = 0;
+ _Mid1 += _Bytes;
+ ++_Mid2;
+ _Ans = ok;
+ }
+ return (_Ans);
+ }
+
+ virtual result do_out(_Statype& _State,
+ const _Elem *_First1, const _Elem *_Last1, const _Elem *& _Mid1,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ ;
+ ;
+ _Mid1 = _First1, _Mid2 = _First2;
+ result _Ans = _Mid1 == _Last1 ? ok : partial;
+ int _Bytes;
+
+ while (_Mid1 != _Last1 && _Mid2 != _Last2)
+ if (5 <= _Last2 - _Mid2)
+ if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1,
+ &_State, &_Cvt)) < 0)
+ return (error);
+ else
+ ++_Mid1, _Mid2 += _Bytes, _Ans = ok;
+ else
+ {
+ _Byte _Buf[5];
+ _Statype _Stsave = _State;
+
+ if ((_Bytes = _Wcrtomb(_Buf, *_Mid1,
+ &_State, &_Cvt)) < 0)
+ return (error);
+ else if (_Last2 - _Mid2 < _Bytes)
+ {
+ _State = _Stsave;
+ return (_Ans);
+ }
+ else
+ {
+ ::memcpy_s((_Mid2), (_Last2 - _Mid2), (_Buf), (_Bytes));
+ ++_Mid1, _Mid2 += _Bytes, _Ans = ok;
+ }
+ }
+ return (_Ans);
+ }
+
+ virtual result do_unshift(_Statype& _State,
+ _Byte *_First2, _Byte *_Last2, _Byte *& _Mid2) const
+ {
+ ;
+ _Mid2 = _First2;
+ result _Ans = ok;
+ int _Bytes;
+ _Byte _Buf[5];
+ _Statype _Stsave = _State;
+
+ if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0)
+ _Ans = error;
+ else if (_Last2 - _Mid2 < --_Bytes)
+ {
+ _State = _Stsave;
+ _Ans = partial;
+ }
+ else if (0 < _Bytes)
+ {
+ ::memcpy_s((_Mid2), (_Last2 - _Mid2), (_Buf), (_Bytes));
+ _Mid2 += _Bytes;
+ }
+ return (_Ans);
+ }
+
+ virtual int do_length(const _Statype& _State, const _Byte *_First1,
+ const _Byte *_Last1, size_t _Count) const
+ {
+ ;
+ int _Wchars;
+ const _Byte *_Mid1;
+ _Statype _Mystate = _State;
+
+ for (_Wchars = 0, _Mid1 = _First1;
+ (size_t)_Wchars < _Count && _Mid1 != _Last1; )
+ {
+ int _Bytes;
+ _Elem _Ch;
+
+ switch (_Bytes = _Mbrtowc((wchar_t *)&_Ch, _Mid1, _Last1 - _Mid1,
+ &_Mystate, &_Cvt))
+ {
+ case -2:
+ return (_Wchars);
+
+ case -1:
+ return (_Wchars);
+
+ case 0:
+ if (_Ch == (_Elem)0)
+ _Bytes = (int)::strlen(_Mid1) + 1;
+
+
+ default:
+ if (_Bytes == -3)
+ _Bytes = 0;
+ _Mid1 += _Bytes;
+ ++_Wchars;
+ }
+ }
+ return (_Wchars);
+ }
+
+ virtual bool do_always_noconv() const throw ()
+ {
+ return (false);
+ }
+
+ virtual int do_max_length() const throw ()
+ {
+ return (5);
+ }
+
+ virtual int do_encoding() const throw ()
+ {
+ return (0);
+ }
+
+private:
+ _Locinfo::_Cvtvec _Cvt;
+ };
+
+
+
+template<class _Elem,
+ class _Byte,
+ class _Statype>
+ class codecvt_byname
+ : public codecvt<_Elem, _Byte, _Statype>
+ {
+public:
+ explicit codecvt_byname(const char *_Locname, size_t _Refs = 0)
+ : codecvt<_Elem, _Byte, _Statype>(_Locname, _Refs)
+ {
+ }
+
+protected:
+ virtual ~codecvt_byname()
+ {
+ }
+ };
+
+
+struct ctype_base
+ : public locale::facet
+ {
+ enum
+ {
+ alnum = 0x4|0x2|0x1|0x100, alpha = 0x2|0x1|0x100,
+ cntrl = 0x20, digit = 0x4, graph = 0x4|0x2|0x10|0x1|0x100,
+ lower = 0x2, print = 0x4|0x2|0x10|0x40|0x1|0x100|0x80,
+ punct = 0x10, space = 0x8|0x40|0x000, upper = 0x1,
+ xdigit = 0x80};
+ typedef short mask;
+
+ ctype_base(size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ }
+
+ ~ctype_base()
+ {
+ }
+
+protected:
+ static void __cdecl _Xran()
+ {
+ throw out_of_range("out_of_range in ctype<T>");
+ }
+ };
+
+
+template<class _Elem>
+ class ctype
+ : public ctype_base
+ {
+public:
+ typedef _Elem char_type;
+
+ bool is(mask _Maskval, _Elem _Ch) const
+ {
+ return (do_is(_Maskval, _Ch));
+ }
+
+ const _Elem * is(const _Elem *_First, const _Elem *_Last,
+ mask *_Dest) const
+ {
+ return (do_is(_First, _Last, _Dest));
+ }
+
+ const _Elem * scan_is(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_is(_Maskval, _First, _Last));
+ }
+
+ const _Elem * scan_not(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_not(_Maskval, _First, _Last));
+ }
+
+ _Elem tolower(_Elem _Ch) const
+ {
+ return (do_tolower(_Ch));
+ }
+
+ const _Elem * tolower(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_tolower(_First, _Last));
+ }
+
+ _Elem toupper(_Elem _Ch) const
+ {
+ return (do_toupper(_Ch));
+ }
+
+ const _Elem * toupper(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_toupper(_First, _Last));
+ }
+
+ _Elem widen(char _Byte) const
+ {
+ return (do_widen(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const char * widen(const char *_First, const char *_Last,
+ _Elem *_Dest) const
+ {
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_widen(_First, _Last, _Dest));
+#pragma warning(pop)
+ }
+
+ const char * _Widen_s(const char *_First, const char *_Last,
+ _Elem *_Dest, size_t _Dest_size) const
+ {
+ return (_Do_widen_s(_First, _Last, _Dest, _Dest_size));
+ }
+
+ char narrow(_Elem _Ch, char _Dflt = '\0') const
+ {
+ return (do_narrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const _Elem * narrow(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_narrow(_First, _Last, _Dflt, _Dest));
+#pragma warning(pop)
+ }
+
+ const _Elem * _Narrow_s(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest, size_t _Dest_size) const
+ {
+ return (_Do_narrow_s(_First, _Last, _Dflt, _Dest, _Dest_size));
+ }
+
+ static locale::id id;
+
+ explicit ctype(size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new ctype<_Elem>;
+ return (2);
+ }
+
+protected:
+ virtual ~ctype()
+ {
+ if (_Ctype._Delfl)
+ free((void *)_Ctype._Table);
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Ctype = _Lobj._Getctype();
+ }
+
+ virtual bool do_is(mask _Maskval, _Elem _Ch) const
+ {
+ return ((_Ctype._Table[(unsigned char)narrow(_Ch)]
+ & _Maskval) != 0);
+ }
+
+ virtual const _Elem * do_is(const _Elem *_First, const _Elem *_Last,
+ mask *_Dest) const
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Ctype._Table[(unsigned char)narrow(*_First)];
+ return (_First);
+ }
+
+ virtual const _Elem * do_scan_is(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && !is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual const _Elem * do_scan_not(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual _Elem do_tolower(_Elem _Ch) const
+ {
+ unsigned char _Byte = (unsigned char)narrow(_Ch, '\0');
+ if (_Byte == '\0')
+ return (_Ch);
+ else
+ return (widen((char)_Tolower(_Byte, &_Ctype)));
+ }
+
+ virtual const _Elem * do_tolower(_Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ {
+ unsigned char _Byte = (unsigned char)narrow(*_First, '\0');
+ if (_Byte != '\0')
+ *_First = (widen((char)_Tolower(_Byte, &_Ctype)));
+ }
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_toupper(_Elem _Ch) const
+ {
+ unsigned char _Byte = (unsigned char)narrow(_Ch, '\0');
+ if (_Byte == '\0')
+ return (_Ch);
+ else
+ return (widen((char)_Toupper(_Byte, &_Ctype)));
+ }
+
+ virtual const _Elem * do_toupper(_Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ {
+ unsigned char _Byte = (unsigned char)narrow(*_First, '\0');
+ if (_Byte != '\0')
+ *_First = (widen((char)_Toupper(_Byte, &_Ctype)));
+ }
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_widen(char _Byte) const
+ {
+ return (_Maklocchr(_Byte, (_Elem *)0, _Cvt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const char * do_widen(const char *_First,
+ const char *_Last, _Elem *_Dest) const
+ {
+
+ return _Do_widen_s(_First, _Last, _Dest, _Last - _First);
+ }
+
+ virtual const char * _Do_widen_s(const char *_First,
+ const char *_Last, _Elem *_Dest, size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Maklocchr(*_First, (_Elem *)0, _Cvt);
+ return (_First);
+ }
+
+ char _Donarrow(_Elem _Ch, char _Dflt) const
+ {
+ char _Byte;
+ if (_Ch == (_Elem)0)
+ return ('\0');
+ else if ((_Byte = _Maklocbyte((_Elem)_Ch, _Cvt)) == '\0')
+ return (_Dflt);
+ else
+ return (_Byte);
+ }
+
+ virtual char do_narrow(_Elem _Ch, char _Dflt) const
+ {
+ return (_Donarrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const _Elem * do_narrow(const _Elem *_First,
+ const _Elem *_Last, char _Dflt, char *_Dest) const
+ {
+
+ return _Do_narrow_s(_First, _Last, _Dflt, _Dest, _Last - _First);
+ }
+
+ virtual const _Elem * _Do_narrow_s(const _Elem *_First,
+ const _Elem *_Last, char _Dflt,
+ char *_Dest,
+ size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Donarrow(*_First, _Dflt);
+ return (_First);
+ }
+
+private:
+ _Locinfo::_Ctypevec _Ctype;
+ _Locinfo::_Cvtvec _Cvt;
+ };
+
+
+template<class _Elem>
+ locale::id ctype<_Elem>::id;
+
+
+template<> class ctype<char>
+ : public ctype_base
+ {
+ typedef ctype<char> _Myt;
+
+public:
+ typedef char _Elem;
+ typedef _Elem char_type;
+
+ bool is(mask _Maskval, _Elem _Ch) const
+ {
+ return ((_Ctype._Table[(unsigned char)_Ch] & _Maskval) != 0);
+ }
+
+ const _Elem * is(const _Elem *_First,
+ const _Elem *_Last, mask *_Dest) const
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Ctype._Table[(unsigned char)*_First];
+ return (_First);
+ }
+
+ const _Elem * scan_is(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && !is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ const _Elem * scan_not(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ _Elem tolower(_Elem _Ch) const
+ {
+ return (do_tolower(_Ch));
+ }
+
+ const _Elem * tolower(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_tolower(_First, _Last));
+ }
+
+ _Elem toupper(_Elem _Ch) const
+ {
+ return (do_toupper(_Ch));
+ }
+
+ const _Elem * toupper(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_toupper(_First, _Last));
+ }
+
+ _Elem widen(char _Byte) const
+ {
+ return (do_widen(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const _Elem * widen(const char *_First, const char *_Last,
+ _Elem *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_widen(_First, _Last, _Dest));
+#pragma warning(pop)
+ }
+
+ const _Elem * _Widen_s(const char *_First, const char *_Last,
+ _Elem *_Dest, size_t _Dest_size) const
+ {
+ return (_Do_widen_s(_First, _Last, _Dest, _Dest_size));
+ }
+
+ _Elem narrow(_Elem _Ch, char _Dflt = '\0') const
+ {
+ return (do_narrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const _Elem * narrow(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_narrow(_First, _Last, _Dflt, _Dest));
+#pragma warning(pop)
+ }
+
+ const _Elem * _Narrow_s(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest,
+ size_t _Dest_size) const
+ {
+ return (_Do_narrow_s(_First, _Last, _Dflt, _Dest, _Dest_size));
+ }
+
+ static locale::id& __cdecl _Id_func();
+
+
+
+ static locale::id id;
+
+
+ explicit ctype(const mask *_Table = 0,
+ bool _Deletetable = false,
+ size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ if (_Table != 0)
+ {
+ _Tidy();
+ _Ctype._Table = _Table;
+ _Ctype._Delfl = _Deletetable ? -1 : 0;
+ }
+ }
+
+ ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new ctype<_Elem>;
+ return (2);
+ }
+
+ static const size_t table_size = 1 << 8;
+
+protected:
+ virtual ~ctype()
+ {
+ _Tidy();
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Ctype = _Lobj._Getctype();
+ }
+
+ void _Tidy()
+ {
+ if (0 < _Ctype._Delfl)
+ free((void *)_Ctype._Table);
+ else if (_Ctype._Delfl < 0)
+ delete[] (void *)_Ctype._Table;
+ }
+
+ virtual _Elem do_tolower(_Elem _Ch) const
+ {
+ return ((_Elem)_Tolower((unsigned char)_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_tolower(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = (_Elem)_Tolower((unsigned char)*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_toupper(_Elem _Ch) const
+ {
+ return ((_Elem)_Toupper((unsigned char)_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_toupper(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = (_Elem)_Toupper((unsigned char)*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_widen(char _Byte) const
+ {
+ return (_Byte);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const _Elem * do_widen(const char *_First,
+ const char *_Last, _Elem *_Dest) const
+ {
+
+ return _Do_widen_s(_First, _Last, _Dest, _Last - _First);
+ }
+
+ virtual const _Elem * _Do_widen_s(const char *_First,
+ const char *_Last, _Elem *_Dest, size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ ::memcpy_s((_Dest), (_Dest_size), (_First), (_Last - _First));
+ return (_Last);
+ }
+
+ virtual _Elem do_narrow(_Elem _Ch, char) const
+ {
+ return (_Ch);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const _Elem * do_narrow(const _Elem *_First,
+ const _Elem *_Last, char _Dflt,
+ char *_Dest) const
+ {
+
+ return _Do_narrow_s(_First, _Last, _Dflt, _Dest, _Last - _First);
+ }
+
+ virtual const _Elem * _Do_narrow_s(const _Elem *_First,
+ const _Elem *_Last, char, char *_Dest,
+ size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ ::memcpy_s((_Dest), (_Dest_size), (_First), (_Last - _First));
+ return (_Last);
+ }
+
+ const mask * table() const throw ()
+ {
+ return (_Ctype._Table);
+ }
+
+ static const mask *__cdecl classic_table() throw ()
+ {
+ const _Myt& _Ctype_fac = use_facet<_Myt >(locale::classic());
+ return (_Ctype_fac.table());
+ }
+
+private:
+ _Locinfo::_Ctypevec _Ctype;
+ };
+
+
+template<> class ctype<wchar_t>
+ : public ctype_base
+ {
+ typedef ctype<wchar_t> _Myt;
+
+public:
+ typedef wchar_t _Elem;
+ typedef _Elem char_type;
+
+ bool is(mask _Maskval, _Elem _Ch) const
+ {
+ return (do_is(_Maskval, _Ch));
+ }
+
+ const _Elem * is(const _Elem *_First, const _Elem *_Last,
+ mask *_Dest) const
+ {
+ return (do_is(_First, _Last, _Dest));
+ }
+
+ const _Elem * scan_is(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_is(_Maskval, _First, _Last));
+ }
+
+ const _Elem * scan_not(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_not(_Maskval, _First, _Last));
+ }
+
+ _Elem tolower(_Elem _Ch) const
+ {
+ return (do_tolower(_Ch));
+ }
+
+ const _Elem * tolower(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_tolower(_First, _Last));
+ }
+
+ _Elem toupper(_Elem _Ch) const
+ {
+ return (do_toupper(_Ch));
+ }
+
+ const _Elem * toupper(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_toupper(_First, _Last));
+ }
+
+ _Elem widen(char _Byte) const
+ {
+ return (do_widen(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const char * widen(const char *_First, const char *_Last,
+ _Elem *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_widen(_First, _Last, _Dest));
+#pragma warning(pop)
+ }
+
+ const char * _Widen_s(const char *_First, const char *_Last,
+ _Elem *_Dest, size_t _Dest_size) const
+ {
+ return (_Do_widen_s(_First, _Last, _Dest, _Dest_size));
+ }
+
+ char narrow(_Elem _Ch, char _Dflt = '\0') const
+ {
+ return (do_narrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const _Elem * narrow(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_narrow(_First, _Last, _Dflt, _Dest));
+#pragma warning(pop)
+ }
+
+ const _Elem * _Narrow_s(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest,
+ size_t _Dest_size) const
+ {
+ return (_Do_narrow_s(_First, _Last, _Dflt, _Dest, _Dest_size));
+ }
+
+ static locale::id& __cdecl _Id_func();
+
+
+
+ static locale::id id;
+
+
+ explicit ctype(size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new ctype<_Elem>;
+ return (2);
+ }
+
+protected:
+ virtual ~ctype()
+ {
+ if (_Ctype._Delfl)
+ free((void *)_Ctype._Table);
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Ctype = _Lobj._Getctype();
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ virtual bool do_is(mask _Maskval, _Elem _Ch) const
+ {
+ return ((::_Getwctype(_Ch, &_Ctype) & _Maskval) != 0);
+ }
+
+ virtual const wchar_t * do_is(const _Elem *_First,
+ const _Elem *_Last, mask *_Dest) const
+ {
+ ;
+ ;
+ return (::_Getwctypes(_First, _Last, _Dest, &_Ctype));
+ }
+
+ virtual const _Elem * do_scan_is(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && !is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual const _Elem * do_scan_not(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual _Elem do_tolower(_Elem _Ch) const
+ {
+ return (_Towlower(_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_tolower(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Towlower(*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_toupper(_Elem _Ch) const
+ {
+ return (_Towupper(_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_toupper(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Towupper(*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ _Elem _Dowiden(char _Byte) const
+ {
+ mbstate_t _Mbst = {0};
+ wchar_t _Wc;
+ return (_Mbrtowc(&_Wc, &_Byte, 1, &_Mbst, &_Cvt) < 0
+ ? (wchar_t)(wint_t)(0xFFFF) : _Wc);
+ }
+
+ virtual _Elem do_widen(char _Byte) const
+ {
+ return (_Dowiden(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const char * do_widen(const char *_First,
+ const char *_Last, _Elem *_Dest) const
+ {
+
+ return _Do_widen_s(_First, _Last, _Dest, _Last - _First);
+ }
+
+ virtual const char * _Do_widen_s(const char *_First,
+ const char *_Last, _Elem *_Dest, size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Dowiden(*_First);
+ return (_First);
+ }
+
+ char _Donarrow(_Elem _Ch, char _Dflt) const
+ {
+ char _Buf[5];
+ mbstate_t _Mbst = {0};
+ return (_Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1
+ ? _Dflt : _Buf[0]);
+ }
+
+ virtual char do_narrow(_Elem _Ch, char _Dflt) const
+ {
+ return (_Donarrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const _Elem * do_narrow(const _Elem *_First,
+ const _Elem *_Last, char _Dflt,
+ char *_Dest) const
+ {
+
+ return _Do_narrow_s(_First, _Last, _Dflt, _Dest, _Last - _First);
+ }
+
+ virtual const _Elem * _Do_narrow_s(const _Elem *_First,
+ const _Elem *_Last, char _Dflt,
+ char *_Dest,
+ size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Donarrow(*_First, _Dflt);
+ return (_First);
+ }
+
+private:
+ _Locinfo::_Ctypevec _Ctype;
+ _Locinfo::_Cvtvec _Cvt;
+ };
+
+
+
+template<> class ctype<unsigned short>
+ : public ctype_base
+ {
+ typedef ctype<unsigned short> _Myt;
+
+public:
+ typedef unsigned short _Elem;
+ typedef _Elem char_type;
+
+ bool is(mask _Maskval, _Elem _Ch) const
+ {
+ return (do_is(_Maskval, _Ch));
+ }
+
+ const _Elem * is(const _Elem *_First, const _Elem *_Last,
+ mask *_Dest) const
+ {
+ return (do_is(_First, _Last, _Dest));
+ }
+
+ const _Elem * scan_is(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_is(_Maskval, _First, _Last));
+ }
+
+ const _Elem * scan_not(mask _Maskval, const _Elem *_First,
+ const _Elem *_Last) const
+ {
+ return (do_scan_not(_Maskval, _First, _Last));
+ }
+
+ _Elem tolower(_Elem _Ch) const
+ {
+ return (do_tolower(_Ch));
+ }
+
+ const _Elem * tolower(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_tolower(_First, _Last));
+ }
+
+ _Elem toupper(_Elem _Ch) const
+ {
+ return (do_toupper(_Ch));
+ }
+
+ const _Elem * toupper(_Elem *_First, const _Elem *_Last) const
+ {
+ return (do_toupper(_First, _Last));
+ }
+
+ _Elem widen(char _Byte) const
+ {
+ return (do_widen(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const char * widen(const char *_First, const char *_Last,
+ _Elem *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_widen(_First, _Last, _Dest));
+#pragma warning(pop)
+ }
+
+ const char * _Widen_s(const char *_First, const char *_Last,
+ _Elem *_Dest, size_t _Dest_size) const
+ {
+ return (_Do_widen_s(_First, _Last, _Dest, _Dest_size));
+ }
+
+ char narrow(_Elem _Ch, char _Dflt = '\0') const
+ {
+ return (do_narrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ const _Elem * narrow(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest) const
+ {
+
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return (do_narrow(_First, _Last, _Dflt, _Dest));
+#pragma warning(pop)
+ }
+
+ const _Elem * _Narrow_s(const _Elem *_First, const _Elem *_Last,
+ char _Dflt, char *_Dest,
+ size_t _Dest_size) const
+ {
+ return (_Do_narrow_s(_First, _Last, _Dflt, _Dest, _Dest_size));
+ }
+
+ static locale::id& __cdecl _Id_func();
+
+
+
+ static locale::id id;
+
+
+ explicit ctype(size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ ctype(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new ctype<_Elem>;
+ return (2);
+ }
+
+protected:
+ virtual ~ctype()
+ {
+ if (_Ctype._Delfl)
+ free((void *)_Ctype._Table);
+ }
+
+protected:
+ ctype(const char *_Locname, size_t _Refs = 0)
+ : ctype_base(_Refs)
+ {
+ { _Locinfo _Lobj(_Locname);
+ _Init(_Lobj);
+ }
+ }
+
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Ctype = _Lobj._Getctype();
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ virtual bool do_is(mask _Maskval, _Elem _Ch) const
+ {
+ return ((::_Getwctype(_Ch, &_Ctype) & _Maskval) != 0);
+ }
+
+ virtual const _Elem * do_is(const _Elem *_First,
+ const _Elem *_Last, mask *_Dest) const
+ {
+ ;
+ ;
+ return ((const _Elem *)::_Getwctypes((const wchar_t *)_First,
+ (const wchar_t *)_Last, _Dest, &_Ctype));
+ }
+
+ virtual const _Elem * do_scan_is(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && !is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual const _Elem * do_scan_not(mask _Maskval,
+ const _Elem *_First, const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last && is(_Maskval, *_First); ++_First)
+ ;
+ return (_First);
+ }
+
+ virtual _Elem do_tolower(_Elem _Ch) const
+ {
+ return (_Towlower(_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_tolower(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Towlower(*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ virtual _Elem do_toupper(_Elem _Ch) const
+ {
+ return (_Towupper(_Ch, &_Ctype));
+ }
+
+ virtual const _Elem * do_toupper(_Elem *_First,
+ const _Elem *_Last) const
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Towupper(*_First, &_Ctype);
+ return ((const _Elem *)_First);
+ }
+
+ _Elem _Dowiden(char _Byte) const
+ {
+ mbstate_t _Mbst = {0};
+ unsigned short _Wc;
+ return (_Mbrtowc((wchar_t *)&_Wc, &_Byte, 1, &_Mbst, &_Cvt) < 0
+ ? (unsigned short)(wint_t)(0xFFFF) : _Wc);
+ }
+
+ virtual _Elem do_widen(char _Byte) const
+ {
+ return (_Dowiden(_Byte));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const char * do_widen(const char *_First,
+ const char *_Last, _Elem *_Dest) const
+ {
+
+ return _Do_widen_s(_First, _Last, _Dest, _Last - _First);
+ }
+
+ virtual const char * _Do_widen_s(const char *_First,
+ const char *_Last, _Elem *_Dest, size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Dowiden(*_First);
+ return (_First);
+ }
+
+ char _Donarrow(_Elem _Ch, char _Dflt) const
+ {
+ char _Buf[5];
+ mbstate_t _Mbst = {0};
+ return (_Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1
+ ? _Dflt : _Buf[0]);
+ }
+
+ virtual char do_narrow(_Elem _Ch, char _Dflt) const
+ {
+ return (_Donarrow(_Ch, _Dflt));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual const _Elem * do_narrow(const _Elem *_First,
+ const _Elem *_Last, char _Dflt, char *_Dest) const
+ {
+
+ return _Do_narrow_s(_First, _Last, _Dflt, _Dest, _Last - _First);
+ }
+
+ virtual const _Elem * _Do_narrow_s(const _Elem *_First,
+ const _Elem *_Last, char _Dflt,
+ char *_Dest,
+ size_t _Dest_size) const
+ {
+ ;
+ ;
+ { if (!(_Dest_size >= (size_t)(_Last - _First))) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Donarrow(*_First, _Dflt);
+ return (_First);
+ }
+
+private:
+ _Locinfo::_Ctypevec _Ctype;
+ _Locinfo::_Cvtvec _Cvt;
+ };
+
+
+
+template<class _Elem>
+ class ctype_byname
+ : public ctype<_Elem>
+ {
+public:
+ explicit ctype_byname(const char *_Locname, size_t _Refs = 0)
+ : ctype<_Elem>(_Locname, _Refs)
+ {
+ }
+
+protected:
+ virtual ~ctype_byname()
+ {
+ }
+ };
+
+
+template<> class ctype_byname<char>
+ : public ctype<char>
+ {
+public:
+ explicit ctype_byname(const char *_Locname, size_t _Refs = 0)
+ : ctype<char>(_Locname, _Refs)
+ {
+ }
+
+protected:
+ virtual ~ctype_byname()
+ {
+ }
+ };
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+#pragma warning(disable:4412)
+
+
+namespace std {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Dummy>
+ class _Iosb
+ {
+public:
+ enum _Dummy_enum {_Dummy_enum_val = 1};
+
+ enum _Fmtflags
+ {
+ _Fmtmask = 0xffff, _Fmtzero = 0};
+
+ static const _Fmtflags skipws = (_Fmtflags)0x0001;
+ static const _Fmtflags unitbuf = (_Fmtflags)0x0002;
+ static const _Fmtflags uppercase = (_Fmtflags)0x0004;
+ static const _Fmtflags showbase = (_Fmtflags)0x0008;
+ static const _Fmtflags showpoint = (_Fmtflags)0x0010;
+ static const _Fmtflags showpos = (_Fmtflags)0x0020;
+ static const _Fmtflags left = (_Fmtflags)0x0040;
+ static const _Fmtflags right = (_Fmtflags)0x0080;
+ static const _Fmtflags internal = (_Fmtflags)0x0100;
+ static const _Fmtflags dec = (_Fmtflags)0x0200;
+ static const _Fmtflags oct = (_Fmtflags)0x0400;
+ static const _Fmtflags hex = (_Fmtflags)0x0800;
+ static const _Fmtflags scientific = (_Fmtflags)0x1000;
+ static const _Fmtflags fixed = (_Fmtflags)0x2000;
+ static const _Fmtflags boolalpha = (_Fmtflags)0x4000;
+ static const _Fmtflags _Stdio = (_Fmtflags)0x8000;
+ static const _Fmtflags adjustfield = (_Fmtflags)(0x0040
+ | 0x0080 | 0x0100);
+ static const _Fmtflags basefield = (_Fmtflags)(0x0200
+ | 0x0400 | 0x0800);
+ static const _Fmtflags floatfield = (_Fmtflags)(0x1000
+ | 0x2000);
+
+ enum _Iostate
+ {
+ _Statmask = 0x17};
+
+ static const _Iostate goodbit = (_Iostate)0x0;
+ static const _Iostate eofbit = (_Iostate)0x1;
+ static const _Iostate failbit = (_Iostate)0x2;
+ static const _Iostate badbit = (_Iostate)0x4;
+ static const _Iostate _Hardfail = (_Iostate)0x10;
+
+ enum _Openmode
+ {
+ _Openmask = 0xff};
+
+ static const _Openmode in = (_Openmode)0x01;
+ static const _Openmode out = (_Openmode)0x02;
+ static const _Openmode ate = (_Openmode)0x04;
+ static const _Openmode app = (_Openmode)0x08;
+ static const _Openmode trunc = (_Openmode)0x10;
+ static const _Openmode _Nocreate = (_Openmode)0x40;
+ static const _Openmode _Noreplace = (_Openmode)0x80;
+ static const _Openmode binary = (_Openmode)0x20;
+
+ enum _Seekdir
+ {
+ _Seekmask = 0x3};
+ static const _Seekdir beg = (_Seekdir)0;
+ static const _Seekdir cur = (_Seekdir)1;
+ static const _Seekdir end = (_Seekdir)2;
+
+ enum
+ {
+ _Openprot = 0x40};
+ };
+
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::skipws;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::unitbuf;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::uppercase;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showbase;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showpoint;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showpos;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::left;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::right;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::internal;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::dec;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::oct;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::hex;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::scientific;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::fixed;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::boolalpha;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::_Stdio;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::adjustfield;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::basefield;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::floatfield;
+
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::goodbit;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::eofbit;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::failbit;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::badbit;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::_Hardfail;
+
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::in;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::out;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::ate;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::app;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::trunc;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::_Nocreate;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::_Noreplace;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::binary;
+
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::beg;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::cur;
+template<class _Dummy>
+ const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::end;
+
+
+class ios_base
+ : public _Iosb<int>
+ {
+public:
+ typedef int fmtflags;
+ typedef int iostate;
+ typedef int openmode;
+ typedef int seekdir;
+
+ typedef std::streamoff streamoff;
+ typedef std::streampos streampos;
+
+ enum event
+ {
+ erase_event, imbue_event, copyfmt_event};
+
+ typedef void (__cdecl *event_callback)(event, ios_base&, int);
+ typedef unsigned int io_state, open_mode, seek_dir;
+
+
+ class failure
+ : public runtime_error
+ {
+ public:
+ explicit failure(const string &_Message)
+ : runtime_error(_Message)
+ {
+ }
+
+ virtual ~failure() throw ()
+ {
+ }
+
+
+
+
+
+
+
+
+
+
+ };
+
+
+ class Init
+ {
+ public:
+ Init()
+ {
+ _Init_ctor(this);
+ }
+
+ ~Init()
+ {
+ _Init_dtor(this);
+ }
+
+ private:
+ static void __cdecl _Init_ctor(Init *);
+ static void __cdecl _Init_dtor(Init *);
+
+ static int& __cdecl _Init_cnt_func();
+
+
+
+ static int _Init_cnt;
+
+ };
+
+ ios_base& operator=(const ios_base& _Right)
+ {
+ if (this != &_Right)
+ {
+ _Mystate = _Right._Mystate;
+ copyfmt(_Right);
+ }
+ return (*this);
+ }
+
+ operator void *() const
+ {
+ return (fail() ? 0 : (void *)this);
+ }
+
+ bool operator!() const
+ {
+ return (fail());
+ }
+
+ void clear(iostate _State, bool _Reraise)
+ {
+ _Mystate = (iostate)(_State & _Statmask);
+ if ((_Mystate & _Except) == 0)
+ ;
+ else if (_Reraise)
+ throw;
+ else if (_Mystate & _Except & badbit)
+ throw failure("ios_base::badbit set");
+ else if (_Mystate & _Except & failbit)
+ throw failure("ios_base::failbit set");
+ else
+ throw failure("ios_base::eofbit set");
+ }
+
+ void clear(iostate _State = goodbit)
+ {
+ clear(_State, false);
+ }
+
+ void clear(io_state _State)
+ {
+ clear((iostate)_State);
+ }
+
+ iostate rdstate() const
+ {
+ return (_Mystate);
+ }
+
+
+ void setstate(iostate _State, bool _Exreraise)
+ {
+ if (_State != goodbit)
+ clear((iostate)((int)rdstate() | (int)_State), _Exreraise);
+ }
+
+ void setstate(iostate _State)
+ {
+ if (_State != goodbit)
+ clear((iostate)((int)rdstate() | (int)_State), false);
+ }
+
+ void setstate(io_state _State)
+ {
+ setstate((iostate)_State);
+ }
+
+ bool good() const
+ {
+ return (rdstate() == goodbit);
+ }
+
+ bool eof() const
+ {
+ return ((int)rdstate() & (int)eofbit);
+ }
+
+ bool fail() const
+ {
+ return (((int)rdstate()
+ & ((int)badbit | (int)failbit)) != 0);
+ }
+
+ bool bad() const
+ {
+ return (((int)rdstate() & (int)badbit) != 0);
+ }
+
+
+
+
+ iostate exceptions() const
+ {
+ return (_Except);
+ }
+
+ void exceptions(iostate _Newexcept)
+ {
+ _Except = (iostate)((int)_Newexcept & (int)_Statmask);
+ clear(_Mystate);
+ }
+
+ void exceptions(io_state _State)
+ {
+ exceptions((iostate)_State);
+ }
+
+ fmtflags flags() const
+ {
+ return (_Fmtfl);
+ }
+
+ fmtflags flags(fmtflags _Newfmtflags)
+ {
+ fmtflags _Oldfmtflags = _Fmtfl;
+ _Fmtfl = (fmtflags)((int)_Newfmtflags & (int)_Fmtmask);
+ return (_Oldfmtflags);
+ }
+
+ fmtflags setf(fmtflags _Newfmtflags)
+ {
+ ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+ _Fmtfl = (fmtflags)((int)_Fmtfl
+ | (int)_Newfmtflags & (int)_Fmtmask);
+ return (_Oldfmtflags);
+ }
+
+ fmtflags setf(fmtflags _Newfmtflags, fmtflags _Mask)
+ {
+ ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+ _Fmtfl = (fmtflags)(((int)_Fmtfl & (int)~_Mask)
+ | ((int)_Newfmtflags & (int)_Mask & (int)_Fmtmask));
+ return (_Oldfmtflags);
+ }
+
+ void unsetf(fmtflags _Mask)
+ {
+ _Fmtfl = (fmtflags)((int)_Fmtfl & (int)~_Mask);
+ }
+
+ streamsize precision() const
+ {
+ return (_Prec);
+ }
+
+ streamsize precision(streamsize _Newprecision)
+ {
+ streamsize _Oldprecision = _Prec;
+ _Prec = _Newprecision;
+ return (_Oldprecision);
+ }
+
+ streamsize width() const
+ {
+ return (_Wide);
+ }
+
+ streamsize width(streamsize _Newwidth)
+ {
+ streamsize _Oldwidth = _Wide;
+ _Wide = _Newwidth;
+ return (_Oldwidth);
+ }
+
+ locale getloc() const
+ {
+ return (*_Ploc);
+ }
+
+ locale imbue(const locale& _Loc)
+ {
+ locale _Oldlocale = *_Ploc;
+ *_Ploc = _Loc;
+ _Callfns(imbue_event);
+ return (_Oldlocale);
+ }
+
+ static int __cdecl xalloc()
+ {
+ { ::std:: _Lockit _Lock(2);
+ return (_Index++);
+ }
+ }
+
+ long& iword(int _Idx)
+ {
+ return (_Findarr(_Idx)._Lo);
+ }
+
+ void *& pword(int _Idx)
+ {
+ return (_Findarr(_Idx)._Vp);
+ }
+
+ void register_callback(event_callback _Pfn, int _Idx)
+ {
+ _Calls = new _Fnarray(_Idx, _Pfn, _Calls);
+ }
+
+ ios_base& copyfmt(const ios_base& _Other)
+ {
+ if (this != &_Other)
+ {
+ _Tidy();
+ *_Ploc = *_Other._Ploc;
+ _Fmtfl = _Other._Fmtfl;
+ _Prec = _Other._Prec;
+ _Wide = _Other._Wide;
+ _Iosarray *_Ptr = _Other._Arr;
+
+ for (_Arr = 0; _Ptr != 0; _Ptr = _Ptr->_Next)
+ if (_Ptr->_Lo != 0 || _Ptr->_Vp != 0)
+ {
+ iword(_Ptr->_Index) = _Ptr->_Lo;
+ pword(_Ptr->_Index) = _Ptr->_Vp;
+ }
+
+ for (_Fnarray *_Q = _Other._Calls; _Q != 0; _Q = _Q->_Next)
+ register_callback(_Q->_Pfn, _Q->_Index);
+
+ _Callfns(copyfmt_event);
+ exceptions(_Other._Except);
+ }
+ return (*this);
+ }
+
+
+ virtual ~ios_base()
+ {
+ _Ios_base_dtor(this);
+ }
+
+ static bool __cdecl sync_with_stdio(bool _Newsync = true)
+ {
+ { ::std:: _Lockit _Lock(2);
+ const bool _Oldsync = _Sync;
+ _Sync = _Newsync;
+ return (_Oldsync);
+ }
+ }
+
+ static void __cdecl _Addstd(ios_base *);
+ size_t _Stdstr;
+
+protected:
+ ios_base()
+ {
+ }
+
+ void _Init()
+ {
+ _Ploc = 0;
+ _Except = goodbit;
+ _Fmtfl = skipws | dec;
+ _Prec = 6;
+ _Wide = 0;
+ _Arr = 0;
+ _Calls = 0;
+ clear(goodbit);
+ _Ploc = new locale;
+ }
+
+private:
+
+ struct _Iosarray
+ {
+ public:
+ _Iosarray(int _Idx, _Iosarray *_Link)
+ : _Next(_Link), _Index(_Idx), _Lo(0), _Vp(0)
+ {
+ }
+
+ _Iosarray *_Next;
+ int _Index;
+ long _Lo;
+ void *_Vp;
+ };
+
+
+ struct _Fnarray
+ {
+ _Fnarray(int _Idx, event_callback _Pnew, _Fnarray *_Link)
+ : _Next(_Link), _Index(_Idx), _Pfn(_Pnew)
+ {
+ }
+
+ _Fnarray *_Next;
+ int _Index;
+ event_callback _Pfn;
+ };
+
+ void _Callfns(event _Ev)
+ {
+ for (_Fnarray *_Ptr = _Calls; _Ptr != 0; _Ptr = _Ptr->_Next)
+ (*_Ptr->_Pfn)(_Ev, *this, _Ptr->_Index);
+ }
+
+ _Iosarray& _Findarr(int _Idx)
+ {
+ _Iosarray *_Ptr, *_Q;
+
+ for (_Ptr = _Arr, _Q = 0; _Ptr != 0; _Ptr = _Ptr->_Next)
+ if (_Ptr->_Index == _Idx)
+ return (*_Ptr);
+ else if (_Q == 0 && _Ptr->_Lo == 0 && _Ptr->_Vp == 0)
+ _Q = _Ptr;
+
+ if (_Q != 0)
+ {
+ _Q->_Index = _Idx;
+ return (*_Q);
+ }
+
+ _Arr = new _Iosarray(_Idx, _Arr);
+ return (*_Arr);
+ }
+
+ void __cdecl _Tidy()
+ {
+ _Callfns(erase_event);
+ _Iosarray *_Q1, *_Q2;
+
+ for (_Q1 = _Arr; _Q1 != 0; _Q1 = _Q2)
+ _Q2 = _Q1->_Next, delete (_Q1);
+ _Arr = 0;
+
+ _Fnarray *_Q3, *_Q4;
+ for (_Q3 = _Calls; _Q3 != 0; _Q3 = _Q4)
+ _Q4 = _Q3->_Next, delete (_Q3);
+ _Calls = 0;
+ }
+
+ static void __cdecl _Ios_base_dtor(ios_base *);
+
+ iostate _Mystate;
+ iostate _Except;
+ fmtflags _Fmtfl;
+ streamsize _Prec;
+ streamsize _Wide;
+ _Iosarray *_Arr;
+ _Fnarray *_Calls;
+ locale *_Ploc;
+
+
+
+
+
+ static int _Index;
+ static bool _Sync;
+
+ static int& __cdecl _Index_func();
+ static bool& __cdecl _Sync_func();
+ };
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+template<class _Elem,
+ class _Traits>
+ class basic_streambuf
+ {
+
+ basic_streambuf(const basic_streambuf<_Elem, _Traits>&);
+ basic_streambuf<_Elem, _Traits>&
+ operator=(const basic_streambuf<_Elem, _Traits>&);
+
+
+protected:
+ basic_streambuf()
+ : _Plocale(new(locale))
+ {
+ _Init();
+ }
+
+ basic_streambuf(_Uninitialized)
+ {
+ }
+
+public:
+ typedef basic_streambuf<_Elem, _Traits> _Myt;
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+
+ virtual ~basic_streambuf()
+ {
+ delete (_Plocale);
+ }
+
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+ pos_type pubseekoff(off_type _Off, ios_base::seekdir _Way,
+ ios_base::openmode _Mode = ios_base::in | ios_base::out)
+ {
+ return (seekoff(_Off, _Way, _Mode));
+ }
+
+ pos_type pubseekoff(off_type _Off, ios_base::seek_dir _Way,
+ ios_base::open_mode _Mode)
+ {
+ return (pubseekoff(_Off, (ios_base::seekdir)_Way,
+ (ios_base::openmode)_Mode));
+ }
+
+ pos_type pubseekpos(pos_type _Pos,
+ ios_base::openmode _Mode = ios_base::in | ios_base::out)
+ {
+ return (seekpos(_Pos, _Mode));
+ }
+
+ pos_type pubseekpos(pos_type _Pos, ios_base::open_mode _Mode)
+ {
+ return (seekpos(_Pos, (ios_base::openmode)_Mode));
+ }
+
+ _Myt *pubsetbuf(_Elem *_Buffer, streamsize _Count)
+ {
+ return (setbuf(_Buffer, _Count));
+ }
+
+ locale pubimbue(const locale &_Newlocale)
+ {
+ locale _Oldlocale = *_Plocale;
+ imbue(_Newlocale);
+ *_Plocale = _Newlocale;
+ return (_Oldlocale);
+ }
+
+ locale getloc() const
+ {
+ return (*_Plocale);
+ }
+
+ streamsize in_avail()
+ {
+ streamsize _Res = _Gnavail();
+ return (0 < _Res ? _Res : showmanyc());
+ }
+
+ int pubsync()
+ {
+ return (sync());
+ }
+
+ int_type sbumpc()
+ {
+ return (0 < _Gnavail()
+ ? _Traits::to_int_type(*_Gninc()) : uflow());
+ }
+
+ int_type sgetc()
+ {
+ return (0 < _Gnavail()
+ ? _Traits::to_int_type(*gptr()) : underflow());
+ }
+
+ streamsize _Sgetn_s(_Elem *_Ptr, size_t _Ptr_size, streamsize _Count)
+ {
+ return _Xsgetn_s(_Ptr, _Ptr_size, _Count);
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ streamsize sgetn(_Elem *_Ptr, streamsize _Count)
+ {
+#pragma warning(push)
+#pragma warning(disable:4996)
+ return xsgetn(_Ptr, _Count);
+#pragma warning(pop)
+ }
+
+ int_type snextc()
+ {
+ return (1 < _Gnavail()
+ ? _Traits::to_int_type(*_Gnpreinc())
+ : _Traits::eq_int_type(_Traits::eof(), sbumpc())
+ ? _Traits::eof() : sgetc());
+ }
+
+ int_type sputbackc(_Elem _Ch)
+ {
+ return (gptr() != 0 && eback() < gptr()
+ && _Traits::eq(_Ch, gptr()[-1])
+ ? _Traits::to_int_type(*_Gndec())
+ : pbackfail(_Traits::to_int_type(_Ch)));
+ }
+
+ void stossc()
+ {
+ if (0 < _Gnavail())
+ _Gninc();
+ else
+ uflow();
+ }
+
+ int_type sungetc()
+ {
+ return (gptr() != 0 && eback() < gptr()
+ ? _Traits::to_int_type(*_Gndec()) : pbackfail());
+ }
+
+ int_type sputc(_Elem _Ch)
+ {
+ return (0 < _Pnavail()
+ ? _Traits::to_int_type(*_Pninc() = _Ch)
+ : overflow(_Traits::to_int_type(_Ch)));
+ }
+
+ streamsize sputn(const _Elem *_Ptr, streamsize _Count)
+ {
+ return (xsputn(_Ptr, _Count));
+ }
+
+ void _Lock()
+ {
+ _Mylock._Lock();
+ }
+
+ void _Unlock()
+ {
+ _Mylock._Unlock();
+ }
+
+
+protected:
+ _Elem *eback() const
+ {
+ return (*_IGfirst);
+ }
+
+ _Elem *gptr() const
+ {
+ return (*_IGnext);
+ }
+
+ _Elem *pbase() const
+ {
+ return (*_IPfirst);
+ }
+
+ _Elem *pptr() const
+ {
+ return (*_IPnext);
+ }
+
+ _Elem *egptr() const
+ {
+ return (*_IGnext + *_IGcount);
+ }
+
+ void gbump(int _Off)
+ {
+ *_IGcount -= _Off;
+ *_IGnext += _Off;
+ }
+
+ void setg(_Elem *_First, _Elem *_Next, _Elem *_Last)
+ {
+ *_IGfirst = _First;
+ *_IGnext = _Next;
+ *_IGcount = (int)(_Last - _Next);
+ }
+
+ _Elem *epptr() const
+ {
+ return (*_IPnext + *_IPcount);
+ }
+
+ _Elem *_Gndec()
+ {
+ ++*_IGcount;
+ return (--*_IGnext);
+ }
+
+ _Elem *_Gninc()
+ {
+ --*_IGcount;
+ return ((*_IGnext)++);
+ }
+
+ _Elem *_Gnpreinc()
+ {
+ --*_IGcount;
+ return (++(*_IGnext));
+ }
+
+ streamsize _Gnavail() const
+ {
+ return (*_IGnext != 0 ? *_IGcount : 0);
+ }
+
+ void pbump(int _Off)
+ {
+ *_IPcount -= _Off;
+ *_IPnext += _Off;
+ }
+
+ void setp(_Elem *_First, _Elem *_Last)
+ {
+ *_IPfirst = _First;
+ *_IPnext = _First;
+ *_IPcount = (int)(_Last - _First);
+ }
+
+ void setp(_Elem *_First, _Elem *_Next, _Elem *_Last)
+ {
+ *_IPfirst = _First;
+ *_IPnext = _Next;
+ *_IPcount = (int)(_Last - _Next);
+ }
+
+ _Elem *_Pninc()
+ {
+ --*_IPcount;
+ return ((*_IPnext)++);
+ }
+
+ streamsize _Pnavail() const
+ {
+ return (*_IPnext != 0 ? *_IPcount : 0);
+ }
+
+ void _Init()
+ {
+ _IGfirst = &_Gfirst, _IPfirst = &_Pfirst;
+ _IGnext = &_Gnext, _IPnext = &_Pnext;
+ _IGcount = &_Gcount, _IPcount = &_Pcount;
+ setp(0, 0), setg(0, 0, 0);
+ }
+
+ void _Init(_Elem **_Gf, _Elem **_Gn, int *_Gc,
+ _Elem **_Pf, _Elem **_Pn, int *_Pc)
+ {
+ _IGfirst = _Gf, _IPfirst = _Pf;
+ _IGnext = _Gn, _IPnext = _Pn;
+ _IGcount = _Gc, _IPcount = _Pc;
+ }
+
+ virtual int_type overflow(int_type = _Traits::eof())
+ {
+ return (_Traits::eof());
+ }
+
+ virtual int_type pbackfail(int_type = _Traits::eof())
+ {
+ return (_Traits::eof());
+ }
+
+ virtual streamsize showmanyc()
+ {
+ return (0);
+ }
+
+ virtual int_type underflow()
+ {
+ return (_Traits::eof());
+ }
+
+ virtual int_type uflow()
+ {
+ return (_Traits::eq_int_type(_Traits::eof(), underflow())
+ ? _Traits::eof() : _Traits::to_int_type(*_Gninc()));
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ virtual streamsize xsgetn(_Elem * _Ptr,
+ streamsize _Count)
+ {
+
+ return _Xsgetn_s(_Ptr, (size_t)-1, _Count);
+ }
+
+ virtual streamsize _Xsgetn_s(_Elem * _Ptr,
+ size_t _Ptr_size, streamsize _Count)
+ {
+ int_type _Meta;
+ streamsize _Stream_size, _Size, _Copied;
+
+ for (_Copied = 0; 0 < _Count; )
+ if (0 < (_Stream_size = _Gnavail()))
+ {
+ _Size = _Stream_size;
+ if (_Count < _Size)
+ _Size = _Count;
+ _Traits_helper::copy_s<_Traits>(_Ptr, _Ptr_size, gptr(), _Size);
+ _Ptr += _Size;
+ _Copied += _Size;
+ _Count -= _Size;
+ gbump((int)_Size);
+ }
+ else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow()))
+ break;
+ else
+ {
+ *_Ptr++ = _Traits::to_char_type(_Meta);
+ ++_Copied;
+ --_Count;
+ }
+
+ return (_Copied);
+ }
+
+ virtual streamsize xsputn(const _Elem *_Ptr,
+ streamsize _Count)
+ {
+ streamsize _Stream_size, _Size, _Copied;
+
+ for (_Copied = 0; 0 < _Count; )
+ if (0 < (_Stream_size = _Pnavail()))
+ {
+ _Size = _Stream_size;
+ if (_Count < _Size)
+ _Size = _Count;
+ _Traits_helper::copy_s<_Traits>(pptr(), _Stream_size, _Ptr, _Size);
+ _Ptr += _Size;
+ _Copied += _Size;
+ _Count -= _Size;
+ pbump((int)_Size);
+ }
+ else if (_Traits::eq_int_type(_Traits::eof(),
+ overflow(_Traits::to_int_type(*_Ptr))))
+ break;
+ else
+ {
+ ++_Ptr;
+ ++_Copied;
+ --_Count;
+ }
+
+ return (_Copied);
+ }
+
+ virtual pos_type seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode = ios_base::in | ios_base::out)
+ {
+ return (streampos(_BADOFF));
+ }
+
+ virtual pos_type seekpos(pos_type,
+ ios_base::openmode = ios_base::in | ios_base::out)
+ {
+ return (streampos(_BADOFF));
+ }
+
+ virtual _Myt * setbuf(_Elem *, streamsize)
+ {
+ return (this);
+ }
+
+ virtual int sync()
+ {
+ return (0);
+ }
+
+ virtual void imbue(const locale&)
+ {
+ }
+
+private:
+ _Mutex _Mylock;
+ _Elem *_Gfirst;
+ _Elem *_Pfirst;
+ _Elem **_IGfirst;
+ _Elem **_IPfirst;
+ _Elem *_Gnext;
+ _Elem *_Pnext;
+ _Elem **_IGnext;
+ _Elem **_IPnext;
+ int _Gcount;
+ int _Pcount;
+ int *_IGcount;
+ int *_IPcount;
+ locale *_Plocale;
+ };
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+
+
+
+extern "C" {
+
+extern long __cdecl _Stolx(const char *, char **,
+ int, int *);
+extern unsigned long __cdecl _Stoulx(const char *,
+ char **, int, int *);
+extern float __cdecl _Stofx(const char *, char **,
+ long, int *);
+extern double __cdecl _Stodx(const char *, char **,
+ long, int *);
+extern long double __cdecl _Stoldx(const char *,
+ char **, long, int *);
+
+}
+
+
+
+
+
+
+
+
+
+namespace std {
+
+
+
+
+template<class _Elem>
+ class numpunct
+ : public locale::facet
+ {
+public:
+ typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
+ string_type;
+ typedef _Elem char_type;
+
+ static locale::id id;
+
+ _Elem decimal_point() const
+ {
+ return (do_decimal_point());
+ }
+
+ _Elem thousands_sep() const
+ {
+ return (do_thousands_sep());
+ }
+
+ string grouping() const
+ {
+ return (do_grouping());
+ }
+
+ string_type falsename() const
+ {
+ return (do_falsename());
+ }
+
+ string_type truename() const
+ {
+ return (do_truename());
+ }
+
+ explicit numpunct(size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ if (_Kseparator == 0)
+ _Kseparator =
+ _Maklocchr(',', (_Elem *)0, _Lobj._Getcvt());
+ }
+ }
+
+ numpunct(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new numpunct<_Elem>;
+ return (4);
+ }
+
+protected:
+ virtual ~numpunct()
+ {
+ _Tidy();
+ }
+
+protected:
+ numpunct(const char *_Locname, size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ { _Locinfo _Lobj(_Locname);
+ _Init(_Lobj);
+ }
+ }
+
+ void _Init(const _Locinfo& _Lobj)
+ {
+ const lconv *_Ptr = _Lobj._Getlconv();
+
+ _Grouping = 0;
+ _Falsename = 0;
+ _Truename = 0;
+
+ try {
+ _Grouping = _Maklocstr(_Ptr->grouping, (char *)0, _Lobj._Getcvt());
+ _Falsename = _Maklocstr(_Lobj._Getfalse(), (_Elem *)0, _Lobj._Getcvt());
+ _Truename = _Maklocstr(_Lobj._Gettrue(), (_Elem *)0, _Lobj._Getcvt());
+ } catch (...) {
+ _Tidy();
+ throw;
+ }
+
+ _Dp = _Maklocchr(_Ptr->decimal_point[0], (_Elem *)0, _Lobj._Getcvt());
+ _Kseparator =
+ _Maklocchr(_Ptr->thousands_sep[0], (_Elem *)0, _Lobj._Getcvt());
+ }
+
+ virtual _Elem do_decimal_point() const
+ {
+ return (_Dp);
+ }
+
+ virtual _Elem do_thousands_sep() const
+ {
+ return (_Kseparator);
+ }
+
+ virtual string do_grouping() const
+ {
+ return (string(_Grouping));
+ }
+
+ virtual string_type do_falsename() const
+ {
+ return (string_type(_Falsename));
+ }
+
+ virtual string_type do_truename() const
+ {
+ return (string_type(_Truename));
+ }
+
+private:
+ void _Tidy()
+ {
+ delete[] ((void *)_Grouping);
+ delete[] ((void *)_Falsename);
+ delete[] ((void *)_Truename);
+ }
+
+ const char *_Grouping;
+ _Elem _Dp;
+ _Elem _Kseparator;
+ const _Elem *_Falsename;
+ const _Elem *_Truename;
+ };
+
+typedef numpunct<char> _Npc;
+typedef numpunct<wchar_t> _Npwc;
+
+
+template<class _Elem>
+ class numpunct_byname
+ : public numpunct<_Elem>
+ {
+public:
+ explicit numpunct_byname(const char *_Locname, size_t _Refs = 0)
+ : numpunct<_Elem>(_Locname, _Refs)
+ {
+ }
+
+protected:
+ virtual ~numpunct_byname()
+ {
+ }
+ };
+
+
+template<class _Elem>
+ locale::id numpunct<_Elem>::id;
+
+
+template<class _Elem,
+ class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> > >
+ class num_get
+ : public locale::facet
+ {
+public:
+ typedef numpunct<_Elem> _Mypunct;
+ typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
+ _Mystr;
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new num_get<_Elem, _InIt>;
+ return (4);
+ }
+
+ static locale::id id;
+
+protected:
+ virtual ~num_get()
+ {
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ _Locinfo::_Cvtvec _Cvt;
+
+public:
+ explicit num_get(size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ num_get(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ typedef _Elem char_type;
+ typedef _InIt iter_type;
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ _Bool& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned short& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned int& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ long& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned long& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ __int64& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned __int64& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ float& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ double& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ long double& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+ _InIt get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ void *& _Val) const
+ {
+ return (do_get(_First, _Last, _Iosbase, _State, _Val));
+ }
+
+protected:
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ _Bool& _Val) const
+ {
+ ;
+ int _Ans = -1;
+
+ if (_Iosbase.flags() & ios_base::boolalpha)
+ {
+ typedef typename _Mystr::size_type _Mystrsize;
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Iosbase.getloc());
+ _Mystr _Str((_Mystrsize)1, (char_type)0);
+ _Str += _Punct_fac.falsename();
+ _Str += (char_type)0;
+ _Str += _Punct_fac.truename();
+ _Ans = _Getloctxt(_First, _Last, (size_t)2, _Str.c_str());
+ }
+ else
+ {
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ const unsigned long _Ulo = ::_Stoulx(_Ac, &_Ep,
+ _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
+ _Iosbase.getloc()), &_Errno);
+ if (_Ep != _Ac && _Errno == 0 && _Ulo <= 1)
+ _Ans = _Ulo;
+ }
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ans < 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans != 0;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned short& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
+ _Iosbase.getloc());
+ char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac;
+ const unsigned long _Ans =
+ ::_Stoulx(_Ptr, &_Ep, _Base, &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ptr || _Errno != 0 || 0xffff < _Ans)
+ _State |= ios_base::failbit;
+ else
+ _Val = (unsigned short)(_Ac[0] == '-'
+ ? 0 -_Ans : _Ans);
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned int& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
+ _Iosbase.getloc());
+ char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac;
+ const unsigned long _Ans =
+ ::_Stoulx(_Ptr, &_Ep, _Base, &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ptr || _Errno != 0 || 0xffffffff < _Ans)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ac[0] == '-' ? 0 -_Ans : _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ long& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ const long _Ans = ::_Stolx(_Ac, &_Ep,
+ _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
+ _Iosbase.getloc()), &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned long& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ const unsigned long _Ans = ::_Stoulx(_Ac, &_Ep,
+ _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
+ _Iosbase.getloc()), &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ __int64& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ const __int64 _Ans = ::_strtoi64(_Ac, &_Ep, _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()));
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ unsigned __int64& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+ const unsigned __int64 _Ans = ::_strtoui64(_Ac, &_Ep, _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()));
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ float& _Val) const
+ {
+ ;
+ char _Ac[8 + 36 + 16], *_Ep;
+ int _Errno = 0;
+ const float _Ans = ::_Stofx(_Ac, &_Ep,
+ _Getffld(_Ac, _First, _Last,
+ _Iosbase.getloc()), &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ double& _Val) const
+ {
+ ;
+ char _Ac[8 + 36 + 16], *_Ep;
+ int _Errno = 0;
+ const double _Ans = ::_Stodx(_Ac, &_Ep,
+ _Getffld(_Ac, _First, _Last,
+ _Iosbase.getloc()), &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ long double& _Val) const
+ {
+ ;
+ char _Ac[8 + 36 + 16], *_Ep;
+ int _Errno = 0;
+ const long double _Ans = ::_Stoldx(_Ac, &_Ep,
+ _Getffld(_Ac, _First, _Last,
+ _Iosbase.getloc()), &_Errno);
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Ans;
+ return (_First);
+ }
+
+ virtual _InIt do_get(_InIt _First, _InIt _Last,
+ ios_base& _Iosbase, ios_base::iostate& _State,
+ void *& _Val) const
+ {
+ ;
+ char _Ac[32], *_Ep;
+ int _Errno = 0;
+
+
+ int _Base = _Getifld(_Ac, _First, _Last, ios_base::hex,
+ _Iosbase.getloc());
+ const unsigned __int64 _Ans =
+ (sizeof (void *) == sizeof (unsigned long))
+ ? (unsigned __int64)::_Stoulx(_Ac, &_Ep, _Base, &_Errno)
+ : ::_strtoui64(_Ac, &_Ep, _Base);
+
+
+
+
+
+
+
+ if (_First == _Last)
+ _State |= ios_base::eofbit;
+ if (_Ep == _Ac || _Errno != 0)
+ _State |= ios_base::failbit;
+ else
+ _Val = (void *)(uintptr_t)_Ans;
+ return (_First);
+ }
+
+private:
+ int __cdecl _Getifld( char *_Ac,
+ _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield,
+ const locale& _Loc) const
+ {
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Loc);
+ const string _Grouping = _Punct_fac.grouping();
+ const _Elem _Kseparator = _Punct_fac.thousands_sep();
+ const _Elem _E0 = _Maklocchr('0', (_Elem *)0, _Cvt);
+ char *_Ptr = _Ac;
+
+ if (_First == _Last)
+ ;
+ else if (*_First == _Maklocchr('+', (_Elem *)0, _Cvt))
+ *_Ptr++ = '+', ++_First;
+ else if (*_First == _Maklocchr('-', (_Elem *)0, _Cvt))
+ *_Ptr++ = '-', ++_First;
+
+ _Basefield &= ios_base::basefield;
+ int _Base = _Basefield == ios_base::oct ? 8
+ : _Basefield == ios_base::hex ? 16
+ : _Basefield == ios_base::_Fmtzero ? 0 : 10;
+
+ bool _Seendigit = false;
+ bool _Nonzero = false;
+
+ if (_First != _Last && *_First == _E0)
+ {
+ _Seendigit = true, ++_First;
+ if (_First != _Last && (*_First == _Maklocchr('x', (_Elem *)0, _Cvt)
+ || *_First == _Maklocchr('X', (_Elem *)0, _Cvt))
+ && (_Base == 0 || _Base == 16))
+ _Base = 16, _Seendigit = false, ++_First;
+ else if (_Base == 0)
+ _Base = 8;
+ }
+
+ int _Dlen = _Base == 0 || _Base == 10 ? 10
+ : _Base == 8 ? 8 : 16 + 6;
+ string _Groups((size_t)1, (char)_Seendigit);
+ size_t _Group = 0;
+
+ for (char *const _Pe = &_Ac[32 - 1];
+ _First != _Last; ++_First)
+ if (::memchr("0123456789abcdefABCDEF",
+ *_Ptr = _Maklocbyte((_Elem)*_First, _Cvt), _Dlen) != 0)
+ {
+ if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe)
+ ++_Ptr, _Nonzero = true;
+ _Seendigit = true;
+ if (_Groups[_Group] != 127)
+ ++_Groups[_Group];
+ }
+ else if (_Groups[_Group] == '\0'
+ || _Kseparator == (_Elem)0
+ || *_First != _Kseparator)
+ break;
+ else
+ {
+ _Groups.append((string::size_type)1, '\0');
+ ++_Group;
+ }
+
+ if (_Group == 0)
+ ;
+ else if ('\0' < _Groups[_Group])
+ ++_Group;
+ else
+ _Seendigit = false;
+
+ for (const char *_Pg = _Grouping.c_str(); _Seendigit && 0 < _Group; )
+ if (*_Pg == 127)
+ break;
+ else if (0 < --_Group && *_Pg != _Groups[_Group]
+ || 0 == _Group && *_Pg < _Groups[_Group])
+ _Seendigit = false;
+ else if ('\0' < _Pg[1])
+ ++_Pg;
+
+ if (_Seendigit && !_Nonzero)
+ *_Ptr++ = '0';
+ else if (!_Seendigit)
+ _Ptr = _Ac;
+ *_Ptr = '\0';
+ return (_Base);
+ }
+
+ int __cdecl _Getffld( char *_Ac,
+ _InIt& _First, _InIt &_Last, const locale& _Loc) const
+ {
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Loc);
+ const string _Grouping = _Punct_fac.grouping();
+ const _Elem _E0 = _Maklocchr('0', (_Elem *)0, _Cvt);
+ char *_Ptr = _Ac;
+ bool _Bad = false;
+
+ if (_First == _Last)
+ ;
+ else if (*_First == _Maklocchr('+', (_Elem *)0, _Cvt))
+ *_Ptr++ = '+', ++_First;
+ else if (*_First == _Maklocchr('-', (_Elem *)0, _Cvt))
+ *_Ptr++ = '-', ++_First;
+
+ bool _Seendigit = false;
+ int _Significant = 0;
+ int _Pten = 0;
+
+ if (*_Grouping.c_str() == 127 || *_Grouping.c_str() <= '\0')
+ for (; _First != _Last
+ && _E0 <= *_First && *_First <= _E0 + 9;
+ _Seendigit = true, ++_First)
+ if (36 <= _Significant)
+ ++_Pten;
+ else if (*_First == _E0 && _Significant == 0)
+ ;
+ else
+ {
+ *_Ptr++ = (char)((*_First - _E0) + '0');
+ ++_Significant;
+ }
+ else
+ {
+ const _Elem _Kseparator = _Punct_fac.thousands_sep();
+ string _Groups((size_t)1, '\0');
+ size_t _Group = 0;
+
+ for (; _First != _Last; ++_First)
+ if (_E0 <= *_First && *_First <= _E0 + 9)
+ {
+ _Seendigit = true;
+ if (36 <= _Significant)
+ ++_Pten;
+ else if (*_First == _E0 && _Significant == 0)
+ ;
+ else
+ {
+ *_Ptr++ = (char)((*_First - _E0) + '0');
+ ++_Significant;
+ }
+ if (_Groups[_Group] != 127)
+ ++_Groups[_Group];
+ }
+ else if (_Groups[_Group] == '\0'
+ || _Kseparator == (_Elem)0
+ || *_First != _Kseparator)
+ break;
+ else
+ {
+ _Groups.append((size_t)1, '\0');
+ ++_Group;
+ }
+ if (_Group == 0)
+ ;
+ else if ('\0' < _Groups[_Group])
+ ++_Group;
+ else
+ _Bad = true;
+
+ for (const char *_Pg = _Grouping.c_str();
+ !_Bad && 0 < _Group; )
+ if (*_Pg == 127)
+ break;
+ else if (0 < --_Group && *_Pg != _Groups[_Group]
+ || 0 == _Group && *_Pg < _Groups[_Group])
+ _Bad = true;
+ else if ('\0' < _Pg[1])
+ ++_Pg;
+ }
+
+ if (_Seendigit && _Significant == 0)
+ *_Ptr++ = '0';
+
+ if (_First != _Last && *_First == _Punct_fac.decimal_point())
+ *_Ptr++ = localeconv()->decimal_point[0], ++_First;
+
+ if (_Significant == 0)
+ {
+ for (; _First != _Last && *_First == _E0;
+ _Seendigit = true, ++_First)
+ --_Pten;
+ if (_Pten < 0)
+ *_Ptr++ = '0', ++_Pten;
+ }
+
+ for (; _First != _Last
+ && _E0 <= *_First && *_First <= _E0 + 9;
+ _Seendigit = true, ++_First)
+ if (_Significant < 36)
+ {
+ *_Ptr++ = (char)((*_First - _E0) + '0');
+ ++_Significant;
+ }
+
+ if (_Seendigit && _First != _Last
+ && (*_First == _Maklocchr('e', (_Elem *)0, _Cvt)
+ || *_First == _Maklocchr('E', (_Elem *)0, _Cvt)))
+ {
+ *_Ptr++ = 'e', ++_First;
+ _Seendigit = false, _Significant = 0;
+
+ if (_First == _Last)
+ ;
+ else if (*_First == _Maklocchr('+', (_Elem *)0, _Cvt))
+ *_Ptr++ = '+', ++_First;
+ else if (*_First == _Maklocchr('-', (_Elem *)0, _Cvt))
+ *_Ptr++ = '-', ++_First;
+ for (; _First != _Last && *_First == _E0; )
+ _Seendigit = true, ++_First;
+ if (_Seendigit)
+ *_Ptr++ = '0';
+ for (; _First != _Last
+ && _E0 <= *_First && *_First <= _E0 + 9;
+ _Seendigit = true, ++_First)
+ if (_Significant < 8)
+ {
+ *_Ptr++ = (char)((*_First - _E0) + '0');
+ ++_Significant;
+ }
+ }
+
+ if (_Bad || !_Seendigit)
+ _Ptr = _Ac;
+ *_Ptr = '\0';
+ return (_Pten);
+ }
+ };
+
+
+template<class _Elem,
+ class _InIt>
+ locale::id num_get<_Elem, _InIt>::id;
+
+
+template<class _Elem,
+ class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem> > >
+ class num_put
+ : public locale::facet
+ {
+public:
+ typedef numpunct<_Elem> _Mypunct;
+ typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
+ _Mystr;
+
+ static size_t __cdecl _Getcat(const locale::facet **_Ppf = 0)
+ {
+ if (_Ppf != 0 && *_Ppf == 0)
+ *_Ppf = new num_put<_Elem, _OutIt>;
+ return (4);
+ }
+
+ static locale::id id;
+
+protected:
+ virtual ~num_put()
+ {
+ }
+
+protected:
+ void _Init(const _Locinfo& _Lobj)
+ {
+ _Cvt = _Lobj._Getcvt();
+ }
+
+ _Locinfo::_Cvtvec _Cvt;
+
+public:
+ explicit num_put(size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ { _Locinfo _Lobj;
+ _Init(_Lobj);
+ }
+ }
+
+ num_put(const _Locinfo& _Lobj, size_t _Refs = 0)
+ : locale::facet(_Refs)
+ {
+ _Init(_Lobj);
+ }
+
+ typedef _Elem char_type;
+ typedef _OutIt iter_type;
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, _Bool _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, long _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, unsigned long _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, __int64 _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, unsigned __int64 _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, double _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, long double _Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+ _OutIt put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, const void *_Val) const
+ {
+ return (do_put(_Dest, _Iosbase, _Fill, _Val));
+ }
+
+protected:
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, _Bool _Val) const
+ {
+ ;
+ if (!(_Iosbase.flags() & ios_base::boolalpha))
+ return (do_put(_Dest, _Iosbase, _Fill, (long)_Val));
+ else
+ {
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Iosbase.getloc());
+ _Mystr _Str;
+ if (_Val)
+ _Str.assign(_Punct_fac.truename());
+ else
+ _Str.assign(_Punct_fac.falsename());
+
+ size_t _Fillcount = _Iosbase.width() <= 0
+ || (size_t)_Iosbase.width() <= _Str.size()
+ ? 0 : (size_t)_Iosbase.width() - _Str.size();
+
+ if ((_Iosbase.flags() & ios_base::adjustfield) != ios_base::left)
+ {
+ _Dest = _Rep(_Dest, _Fill, _Fillcount);
+ _Fillcount = 0;
+ }
+ _Dest = _Put(_Dest, _Str.c_str(), _Str.size());
+ _Iosbase.width(0);
+ return (_Rep(_Dest, _Fill, _Fillcount));
+ }
+ }
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, long _Val) const
+ {
+ const size_t _Buf_size = 2 * 32;
+ char _Buf[_Buf_size], _Fmt[6];
+ return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
+ ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "ld",
+ _Iosbase.flags()), _Val)));
+ }
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, unsigned long _Val) const
+ {
+ const size_t _Buf_size = 2 * 32;
+ char _Buf[_Buf_size], _Fmt[6];
+ return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
+ ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "lu",
+ _Iosbase.flags()), _Val)));
+ }
+
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, __int64 _Val) const
+ {
+ const size_t _Buf_size = 2 * 32;
+ char _Buf[_Buf_size], _Fmt[8];
+ return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
+ ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "Ld",
+ _Iosbase.flags()), _Val)));
+ }
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, unsigned __int64 _Val) const
+ {
+ const size_t _Buf_size = 2 * 32;
+ char _Buf[_Buf_size], _Fmt[8];
+ return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
+ ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "Lu",
+ _Iosbase.flags()), _Val)));
+ }
+
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, double _Val) const
+ {
+ const size_t _Buf_size = 8 + 36 + 64;
+ char _Buf[_Buf_size], _Fmt[8];
+ streamsize _Precision = _Iosbase.precision() <= 0
+ && !(_Iosbase.flags() & ios_base::fixed)
+ ? 6 : _Iosbase.precision();
+ int _Significance = 36 < _Precision
+ ? 36 : (int)_Precision;
+ _Precision -= _Significance;
+ size_t _Beforepoint = 0;
+ size_t _Afterpoint = 0;
+
+ if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::fixed)
+ {
+ bool _Signed = _Val < 0;
+ if (_Signed)
+ _Val = -_Val;
+
+ for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
+ _Val /= 1e10;
+
+ if (0 < _Val)
+ for (; 10 <= _Precision && _Val <= 1e-35
+ && _Afterpoint < 5000; _Afterpoint += 10)
+ {
+ _Val *= 1e10;
+ _Precision -= 10;
+ }
+
+ if (_Signed)
+ _Val = -_Val;
+ }
+
+ return (_Fput(_Dest, _Iosbase, _Fill, _Buf,
+ _Beforepoint, _Afterpoint, _Precision,
+ ::sprintf_s(_Buf, _Buf_size, _Ffmt(_Fmt, 0, _Iosbase.flags()),
+ _Significance, _Val)));
+ }
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, long double _Val) const
+ {
+ const size_t _Buf_size = 8 + 36 + 64;
+ char _Buf[_Buf_size], _Fmt[8];
+ streamsize _Precision = _Iosbase.precision() <= 0
+ && !(_Iosbase.flags() & ios_base::fixed)
+ ? 6 : _Iosbase.precision();
+ int _Significance = 36 < _Precision
+ ? 36 : (int)_Precision;
+ _Precision -= _Significance;
+ size_t _Beforepoint = 0;
+ size_t _Afterpoint = 0;
+
+ if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::fixed)
+ {
+ bool _Signed = _Val < 0;
+ if (_Signed)
+ _Val = -_Val;
+
+ for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
+ _Val /= 1e10;
+
+ if (0 < _Val)
+ for (; 10 <= _Precision && _Val <= 1e-35
+ && _Afterpoint < 5000; _Afterpoint += 10)
+ {
+ _Val *= 1e10;
+ _Precision -= 10;
+ }
+
+ if (_Signed)
+ _Val = -_Val;
+ }
+
+ return (_Fput(_Dest, _Iosbase, _Fill, _Buf,
+ _Beforepoint, _Afterpoint, _Precision,
+ ::sprintf_s(_Buf, _Buf_size, _Ffmt(_Fmt, 'L', _Iosbase.flags()),
+ _Significance, _Val)));
+ }
+
+ virtual _OutIt do_put(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, const void *_Val) const
+ {
+ const size_t _Buf_size = 2 * 32;
+ char _Buf[_Buf_size];
+ return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
+ ::sprintf_s(_Buf, _Buf_size, "%p", _Val)));
+ }
+
+private:
+ char *__cdecl _Ffmt( char *_Fmt,
+ char _Spec, ios_base::fmtflags _Flags) const
+ {
+ char *_Ptr = _Fmt;
+ *_Ptr++ = '%';
+
+ if (_Flags & ios_base::showpos)
+ *_Ptr++ = '+';
+ if (_Flags & ios_base::showpoint)
+ *_Ptr++ = '#';
+ *_Ptr++ = '.';
+ *_Ptr++ = '*';
+ if (_Spec != '\0')
+ *_Ptr++ = _Spec;
+
+ ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
+ *_Ptr++ = _Ffl == ios_base::fixed ? 'f'
+ : _Ffl == ios_base::scientific ? 'e' : 'g';
+ *_Ptr = '\0';
+ return (_Fmt);
+ }
+
+ _OutIt __cdecl _Fput(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, const char *_Buf,
+ size_t _Beforepoint, size_t _Afterpoint,
+ size_t _Trailing, size_t _Count) const
+ {
+ ;
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Iosbase.getloc());
+ const string _Grouping = _Punct_fac.grouping();
+ const _Elem _Kseparator = _Punct_fac.thousands_sep();
+ string _Groupstring;
+ const _Elem _E0 = _Maklocchr('0', (_Elem *)0, _Cvt);
+ size_t _Prefix = _Buf[0] == '+' || _Buf[0] == '-' ? 1 : 0;
+
+ char _Enders[3];
+ _Enders[0] = ::localeconv()->decimal_point[0];
+ _Enders[1] = 'e';
+ _Enders[2] = '\0';
+
+ const char *_Eptr = (const char *)::memchr(_Buf,
+ 'e', _Count);
+ const char *_Pointptr = (const char *)::memchr(_Buf,
+ _Enders[0], _Count);
+ if (_Pointptr == 0)
+ _Trailing = 0;
+
+ if (*_Grouping.c_str() != 127 && '\0' < *_Grouping.c_str())
+ {
+ _Groupstring.append(_Buf, _Count);
+ if (_Eptr == 0)
+ _Groupstring.append(_Trailing, '0');
+ else
+ {
+ if (_Pointptr == 0)
+ {
+ _Groupstring.append(_Beforepoint, '0');
+ _Beforepoint = 0;
+ }
+ _Groupstring.insert(_Eptr - _Buf, _Trailing, '0');
+ }
+ _Trailing = 0;
+
+ if (_Pointptr == 0)
+ _Groupstring.append(_Beforepoint, '0');
+ else
+ {
+ _Groupstring.insert(_Pointptr - _Buf + 1, _Afterpoint, '0');
+ _Groupstring.insert(_Pointptr - _Buf, _Beforepoint, '0');
+ _Afterpoint = 0;
+ }
+ _Beforepoint = 0;
+
+ const char *_Pg = _Grouping.c_str();
+ size_t _Off = ::strcspn(&_Groupstring[0], &_Enders[0]);
+ while (*_Pg != 127 && '\0' < *_Pg
+ && (size_t)*_Pg < _Off - _Prefix)
+ {
+ _Groupstring.insert(_Off -= *_Pg, (size_t)1, '\0');
+ if ('\0' < _Pg[1])
+ ++_Pg;
+ }
+
+ _Buf = &_Groupstring[0];
+ _Trailing = 0;
+ _Count = _Groupstring.size();
+ }
+
+ size_t _Fillcount = _Beforepoint + _Afterpoint + _Trailing + _Count;
+ _Fillcount = _Iosbase.width() <= 0
+ || (size_t)_Iosbase.width() <= _Fillcount
+ ? 0 : (size_t)_Iosbase.width() - _Fillcount;
+ ios_base::fmtflags _Adjustfield =
+ _Iosbase.flags() & ios_base::adjustfield;
+ if (_Adjustfield != ios_base::left
+ && _Adjustfield != ios_base::internal)
+ {
+ _Dest = _Rep(_Dest, _Fill, _Fillcount);
+ _Fillcount = 0;
+ }
+ else if (_Adjustfield == ios_base::internal)
+ {
+ if (0 < _Prefix)
+ {
+ _Dest = _Putc(_Dest, _Buf, 1);
+ ++_Buf, --_Count;
+ }
+ _Dest = _Rep(_Dest, _Fill, _Fillcount);
+ _Fillcount = 0;
+ }
+
+ _Pointptr = (const char *)::memchr(_Buf,
+ _Enders[0], _Count);
+ if (_Pointptr != 0)
+ {
+ size_t _Fracoffset = _Pointptr - _Buf + 1;
+ _Dest = _Putgrouped(_Dest, _Buf, _Fracoffset - 1, _Kseparator);
+ _Dest = _Rep(_Dest, _E0, _Beforepoint);
+ _Dest = _Rep(_Dest, _Punct_fac.decimal_point(), 1);
+ _Dest = _Rep(_Dest, _E0, _Afterpoint);
+ _Buf += _Fracoffset, _Count -= _Fracoffset;
+ }
+
+ _Eptr = (const char *)::memchr(_Buf,
+ 'e', _Count);
+ if (_Eptr != 0)
+ {
+ size_t _Expoffset = _Eptr - _Buf + 1;
+ _Dest = _Putgrouped(_Dest, _Buf, _Expoffset - 1, _Kseparator);
+ _Dest = _Rep(_Dest, _E0, _Trailing), _Trailing = 0;
+ _Dest = _Putc(_Dest, _Iosbase.flags() & ios_base::uppercase
+ ? "E" : "e", 1);
+ _Buf += _Expoffset, _Count -= _Expoffset;
+ }
+
+ _Dest = _Putgrouped(_Dest, _Buf, _Count,
+ _Kseparator);
+ _Dest = _Rep(_Dest, _E0, _Trailing);
+ _Iosbase.width(0);
+ return (_Rep(_Dest, _Fill, _Fillcount));
+ }
+
+ char *__cdecl _Ifmt( char *_Fmt,
+ const char *_Spec, ios_base::fmtflags _Flags) const
+ {
+ char *_Ptr = _Fmt;
+ *_Ptr++ = '%';
+
+ if (_Flags & ios_base::showpos)
+ *_Ptr++ = '+';
+ if (_Flags & ios_base::showbase)
+ *_Ptr++ = '#';
+ if (_Spec[0] != 'L')
+ *_Ptr++ = _Spec[0];
+ else
+ {
+ *_Ptr++ = 'I';
+ *_Ptr++ = '6';
+ *_Ptr++ = '4';
+ }
+
+ ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
+ *_Ptr++ = _Basefield == ios_base::oct ? 'o'
+ : _Basefield != ios_base::hex ? _Spec[1]
+ : _Flags & ios_base::uppercase ? 'X' : 'x';
+ *_Ptr = '\0';
+ return (_Fmt);
+ }
+
+ _OutIt __cdecl _Iput(_OutIt _Dest,
+ ios_base& _Iosbase, _Elem _Fill, char *_Buf, size_t _Count) const
+ {
+ ;
+ const _Mypunct& _Punct_fac = use_facet<_Mypunct >(_Iosbase.getloc());
+ const string _Grouping = _Punct_fac.grouping();
+ const size_t _Prefix = *_Buf == '+' || *_Buf == '-' ? 1
+ : *_Buf == '0' && (_Buf[1] == 'x' || _Buf[1] == 'X') ? 2
+ : 0;
+
+ if (*_Grouping.c_str() != 127 && '\0' < *_Grouping.c_str())
+ {
+ const char *_Pg = _Grouping.c_str();
+ size_t _Off = _Count;
+ while (*_Pg != 127 && '\0' < *_Pg
+ && (size_t)*_Pg < _Off - _Prefix)
+ {
+ _Off -= *_Pg;
+ ::memmove_s((&_Buf[_Off + 1]), (_Count + 1 - _Off), (&_Buf[_Off]), (_Count + 1 - _Off));
+ _Buf[_Off] = '\0', ++_Count;
+ if ('\0' < _Pg[1])
+ ++_Pg;
+ }
+ }
+
+ size_t _Fillcount = _Iosbase.width() <= 0
+ || (size_t)_Iosbase.width() <= _Count
+ ? 0 : (size_t)_Iosbase.width() - _Count;
+
+ ios_base::fmtflags _Adjustfield =
+ _Iosbase.flags() & ios_base::adjustfield;
+ if (_Adjustfield != ios_base::left
+ && _Adjustfield != ios_base::internal)
+ {
+ _Dest = _Rep(_Dest, _Fill, _Fillcount);
+ _Fillcount = 0;
+ }
+ else if (_Adjustfield == ios_base::internal)
+ {
+ _Dest = _Putc(_Dest, _Buf, _Prefix);
+ _Buf += _Prefix, _Count -= _Prefix;
+ _Dest = _Rep(_Dest, _Fill, _Fillcount), _Fillcount = 0;
+ }
+
+ _Dest = _Putgrouped(_Dest, _Buf, _Count,
+ _Punct_fac.thousands_sep());
+ _Iosbase.width(0);
+ return (_Rep(_Dest, _Fill, _Fillcount));
+ }
+
+ _OutIt __cdecl _Put(_OutIt _Dest,
+ const _Elem *_Ptr, size_t _Count) const
+ {
+ for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
+ *_Dest = *_Ptr;
+ return (_Dest);
+ }
+
+ _OutIt __cdecl _Putc(_OutIt _Dest,
+ const char *_Ptr, size_t _Count) const
+ {
+ for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
+ *_Dest = _Maklocchr(*_Ptr, (_Elem *)0, _Cvt);
+ return (_Dest);
+ }
+
+ _OutIt __cdecl _Putgrouped(_OutIt _Dest,
+ const char *_Ptr, size_t _Count, _Elem _Kseparator) const
+ {
+ for (; ; ++_Ptr, --_Count)
+ {
+ const char *_Pend =
+ (const char *)::memchr(_Ptr, '\0', _Count);
+ size_t _Groupsize = _Pend != 0 ? _Pend - _Ptr : _Count;
+
+ _Dest = _Putc(_Dest, _Ptr, _Groupsize);
+ _Ptr += _Groupsize, _Count -= _Groupsize;
+ if (_Count == 0)
+ break;
+ if (_Kseparator != (_Elem)0)
+ _Dest = _Rep(_Dest, _Kseparator, 1);
+ }
+ return (_Dest);
+ }
+
+ _OutIt __cdecl _Rep(_OutIt _Dest,
+ _Elem _Ch, size_t _Count) const
+ {
+ for (; 0 < _Count; --_Count, ++_Dest)
+ *_Dest = _Ch;
+ return (_Dest);
+ }
+ };
+
+
+template<class _Elem,
+ class _OutIt>
+ locale::id num_put<_Elem, _OutIt>::id;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+template<class _Elem,
+ class _Traits>
+ class basic_ios
+ : public ios_base
+ {
+public:
+ typedef basic_ios<_Elem, _Traits> _Myt;
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ typedef basic_streambuf<_Elem, _Traits> _Mysb;
+ typedef ctype<_Elem> _Ctype;
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+ explicit basic_ios(_Mysb *_Strbuf)
+ {
+ init(_Strbuf);
+ }
+
+ virtual ~basic_ios()
+ {
+ }
+
+ void clear(iostate _State = goodbit, bool _Reraise = false)
+ {
+ ios_base::clear((iostate)(_Mystrbuf == 0
+ ? (int)_State | (int)badbit : (int)_State), _Reraise);
+ }
+
+ void clear(io_state _State)
+ {
+ clear((iostate)_State);
+ }
+
+ void setstate(iostate _State, bool _Reraise = false)
+ {
+ if (_State != goodbit)
+ clear((iostate)((int)rdstate() | (int)_State), _Reraise);
+ }
+
+ void setstate(io_state _State)
+ {
+ setstate((iostate)_State);
+ }
+
+ _Myt& copyfmt(const _Myt& _Right)
+ {
+ _Tiestr = _Right.tie();
+ _Fillch = _Right.fill();
+ ios_base::copyfmt(_Right);
+ return (*this);
+ }
+
+ _Myos * tie() const
+ {
+ return (_Tiestr);
+ }
+
+ _Myos * tie(_Myos *_Newtie)
+ {
+ _Myos *_Oldtie = _Tiestr;
+ _Tiestr = _Newtie;
+ return (_Oldtie);
+ }
+
+ _Mysb * rdbuf() const
+ {
+ return (_Mystrbuf);
+ }
+
+ _Mysb * rdbuf(_Mysb *_Strbuf)
+ {
+ _Mysb *_Oldstrbuf = _Mystrbuf;
+ _Mystrbuf = _Strbuf;
+ clear();
+ return (_Oldstrbuf);
+ }
+
+ locale imbue(const locale& _Loc)
+ {
+ locale _Oldlocale = ios_base::imbue(_Loc);
+ if (rdbuf() != 0)
+ rdbuf()->pubimbue(_Loc);
+ return (_Oldlocale);
+ }
+
+ _Elem fill() const
+ {
+ return (_Fillch);
+ }
+
+ _Elem fill(_Elem _Newfill)
+ {
+ _Elem _Oldfill = _Fillch;
+ _Fillch = _Newfill;
+ return (_Oldfill);
+ }
+
+ char narrow(_Elem _Ch, char _Dflt = '\0') const
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(getloc());
+ return (_Ctype_fac.narrow(_Ch, _Dflt));
+ }
+
+ _Elem widen(char _Byte) const
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(getloc());
+ return (_Ctype_fac.widen(_Byte));
+ }
+
+protected:
+ void init(_Mysb *_Strbuf = 0,
+ bool _Isstd = false)
+ {
+ _Init();
+ _Mystrbuf = _Strbuf;
+ _Tiestr = 0;
+ _Fillch = widen(' ');
+
+ if (_Mystrbuf == 0)
+ setstate(badbit);
+
+ if (_Isstd)
+ _Addstd(this);
+ else
+ _Stdstr = 0;
+ }
+
+ basic_ios()
+ {
+ }
+
+private:
+ basic_ios(const _Myt&);
+ _Myt& operator=(const _Myt&);
+
+ _Mysb *_Mystrbuf;
+ _Myos *_Tiestr;
+ _Elem _Fillch;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+inline ios_base& __cdecl boolalpha(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::boolalpha);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl dec(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::dec, ios_base::basefield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl fixed(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::fixed, ios_base::floatfield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl hex(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::hex, ios_base::basefield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl internal(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::internal, ios_base::adjustfield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl left(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::left, ios_base::adjustfield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl noboolalpha(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::boolalpha);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl noshowbase(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::showbase);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl noshowpoint(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::showpoint);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl noshowpos(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::showpos);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl noskipws(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::skipws);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl nounitbuf(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::unitbuf);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl nouppercase(ios_base& _Iosbase)
+ {
+ _Iosbase.unsetf(ios_base::uppercase);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl oct(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::oct, ios_base::basefield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl right(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::right, ios_base::adjustfield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl scientific(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::scientific, ios_base::floatfield);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl showbase(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::showbase);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl showpoint(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::showpoint);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl showpos(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::showpos);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl skipws(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::skipws);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl unitbuf(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::unitbuf);
+ return (_Iosbase);
+ }
+
+inline ios_base& __cdecl uppercase(ios_base& _Iosbase)
+ {
+ _Iosbase.setf(ios_base::uppercase);
+ return (_Iosbase);
+ }
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits>
+ class basic_ostream
+ : virtual public basic_ios<_Elem, _Traits>
+ {
+public:
+ typedef basic_ostream<_Elem, _Traits> _Myt;
+ typedef basic_ios<_Elem, _Traits> _Myios;
+ typedef basic_streambuf<_Elem, _Traits> _Mysb;
+ typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
+ typedef num_put<_Elem, _Iter> _Nput;
+
+ explicit basic_ostream(basic_streambuf<_Elem, _Traits> *_Strbuf,
+ bool _Isstd = false)
+ {
+ _Myios::init(_Strbuf, _Isstd);
+ }
+
+ basic_ostream(_Uninitialized)
+ {
+ ios_base::_Addstd(this);
+ }
+
+ virtual ~basic_ostream()
+ {
+ }
+
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+ class _Sentry_base
+ {
+ public:
+ _Sentry_base(_Myt& _Ostr)
+ : _Myostr(_Ostr)
+ {
+ if (_Myostr.rdbuf() != 0)
+ _Myostr.rdbuf()->_Lock();
+ }
+
+ ~_Sentry_base()
+ {
+ if (_Myostr.rdbuf() != 0)
+ _Myostr.rdbuf()->_Unlock();
+ }
+
+ _Myt& _Myostr;
+ };
+
+ class sentry
+ : public _Sentry_base
+ {
+ public:
+ explicit sentry(_Myt& _Ostr)
+ : _Sentry_base(_Ostr)
+ {
+ if (_Ostr.good() && _Ostr.tie() != 0)
+ _Ostr.tie()->flush();
+ _Ok = _Ostr.good();
+ }
+
+ ~sentry()
+ {
+
+
+ if (!std:: uncaught_exception())
+ this->_Myostr._Osfx();
+ }
+
+
+
+
+
+
+ operator bool() const
+ {
+ return (_Ok);
+ }
+
+ private:
+ sentry(const sentry&);
+ sentry& operator=(const sentry&);
+
+ bool _Ok;
+ };
+
+ bool opfx()
+ {
+ if (ios_base::good() && _Myios::tie() != 0)
+ _Myios::tie()->flush();
+ return (ios_base::good());
+ }
+
+ void osfx()
+ {
+ _Osfx();
+ }
+
+ void _Osfx()
+ {
+ try {
+ if (ios_base::flags() & ios_base::unitbuf)
+ flush();
+ } catch (...) {
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _Myt& operator<<(_Myt& (__cdecl *_Pfn)(_Myt&))
+ {
+ ;
+ return ((*_Pfn)(*this));
+ }
+
+ _Myt& operator<<(_Myios& (__cdecl *_Pfn)(_Myios&))
+ {
+ ;
+ (*_Pfn)(*(_Myios *)this);
+ return (*this);
+ }
+
+ _Myt& operator<<(ios_base& (__cdecl *_Pfn)(ios_base&))
+ {
+ ;
+ (*_Pfn)(*(ios_base *)this);
+ return (*this);
+ }
+
+ _Myt& operator<<(_Bool _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(short _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+ ios_base::fmtflags _Bfl =
+ ios_base::flags() & ios_base::basefield;
+ long _Tmp = (_Bfl == ios_base::oct
+ || _Bfl == ios_base::hex)
+ ? (long)(unsigned short)_Val : (long)_Val;
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Tmp).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+
+
+
+
+
+
+
+ _Myt& operator<<(unsigned short _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), (unsigned long)_Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(int _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+ ios_base::fmtflags _Bfl =
+ ios_base::flags() & ios_base::basefield;
+ long _Tmp = (_Bfl == ios_base::oct
+ || _Bfl == ios_base::hex)
+ ? (long)(unsigned int)_Val : (long)_Val;
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Tmp).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(unsigned int __w64 _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), (unsigned long)_Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(long _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(unsigned long __w64 _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), (unsigned long)_Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+ _Myt& operator<<(__int64 _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(unsigned __int64 _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+ _Myt& operator<<(float _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), (double)_Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(double _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(long double _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(const void *_Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nput& _Nput_fac = use_facet<_Nput >(ios_base::getloc());
+
+ try {
+ if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
+ _Myios::fill(), _Val).failed())
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator<<(_Mysb *_Strbuf)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ bool _Copied = false;
+ const sentry _Ok(*this);
+
+ if (_Ok && _Strbuf != 0)
+ for (int_type _Meta = _Traits::eof(); ; _Copied = true)
+ {
+ try {
+ _Meta = _Traits::eq_int_type(_Traits::eof(), _Meta)
+ ? _Strbuf->sgetc() : _Strbuf->snextc();
+ } catch (...) {
+ _Myios::setstate(ios_base::failbit);
+ throw;
+ }
+
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ break;
+
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Myios::rdbuf()->sputc(
+ _Traits::to_char_type(_Meta))))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ ios_base::width(0);
+ _Myios::setstate(_Strbuf == 0 ? ios_base::badbit
+ : !_Copied ? _State | ios_base::failbit : _State);
+ return (*this);
+ }
+
+ _Myt& put(_Elem _Ch)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Myios::rdbuf()->sputc(_Ch)))
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& write(const _Elem *_Str,
+ streamsize _Count)
+ {
+ ;
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count)
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& flush()
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ if (!ios_base::fail() && _Myios::rdbuf()->pubsync() == -1)
+ _State |= ios_base::badbit;
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& seekp(pos_type _Pos)
+ {
+ if (!ios_base::fail()
+ && (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
+ ios_base::out) == _BADOFF)
+ _Myios::setstate(ios_base::failbit);
+ return (*this);
+ }
+
+ _Myt& seekp(off_type _Off, ios_base::seekdir _Way)
+ {
+ if (!ios_base::fail()
+ && (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
+ ios_base::out) == _BADOFF)
+ _Myios::setstate(ios_base::failbit);
+ return (*this);
+ }
+
+ pos_type tellp()
+ {
+ if (!ios_base::fail())
+ return (_Myios::rdbuf()->pubseekoff(0,
+ ios_base::cur, ios_base::out));
+ else
+ return (pos_type(_BADOFF));
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>& __cdecl operator<<(
+ basic_ostream<_Elem, _Traits>& _Ostr, const char *_Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ streamsize _Count = (streamsize)::strlen(_Val);
+ streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
+ ? 0 : _Ostr.width() - _Count;
+ const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ const ctype<_Elem>& _Ctype_fac = use_facet<ctype<_Elem> >(_Ostr.getloc());
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+
+ for (; _State == ios_base::goodbit && 0 < _Count; --_Count, ++_Val)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ctype_fac.widen(*_Val))))
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+ _Ostr.width(0);
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>& __cdecl operator<<(
+ basic_ostream<_Elem, _Traits>& _Ostr, char _Ch)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
+
+ if (_Ok)
+ {
+ const ctype<_Elem>& _Ctype_fac = use_facet<ctype<_Elem> >(_Ostr.getloc());
+ streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit
+ && _Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ctype_fac.widen(_Ch))))
+ _State |= ios_base::badbit;
+
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.width(0);
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr,
+ const char *_Val)
+ {
+ typedef char _Elem;
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ ios_base::iostate _State = ios_base::goodbit;
+ streamsize _Count = (streamsize)_Traits::length(_Val);
+ streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
+ ? 0 : _Ostr.width() - _Count;
+ const typename _Myos::sentry _Ok(_Ostr);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+
+ if (_State == ios_base::goodbit
+ && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+ _Ostr.width(0);
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr, char _Ch)
+ {
+ typedef char _Elem;
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ ios_base::iostate _State = ios_base::goodbit;
+ const typename _Myos::sentry _Ok(_Ostr);
+
+ if (_Ok)
+ {
+ streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit
+ && _Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ch)))
+ _State |= ios_base::badbit;
+
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.width(0);
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>& __cdecl operator<<(
+ basic_ostream<_Elem, _Traits>& _Ostr, const _Elem *_Val)
+ {
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ ios_base::iostate _State = ios_base::goodbit;
+ streamsize _Count = (streamsize)_Traits::length(_Val);
+ streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
+ ? 0 : _Ostr.width() - _Count;
+ const typename _Myos::sentry _Ok(_Ostr);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+
+ if (_State == ios_base::goodbit
+ && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+ _Ostr.width(0);
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>& __cdecl operator<<(
+ basic_ostream<_Elem, _Traits>& _Ostr, _Elem _Ch)
+ {
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ ios_base::iostate _State = ios_base::goodbit;
+ const typename _Myos::sentry _Ok(_Ostr);
+
+ if (_Ok)
+ {
+ streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+
+ if (_State == ios_base::goodbit
+ && _Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ch)))
+ _State |= ios_base::badbit;
+
+ for (; _State == ios_base::goodbit && 0 < _Pad;
+ --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ _State |= ios_base::badbit;
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.width(0);
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr, const signed char *_Val)
+ {
+ return (_Ostr << (const char *)_Val);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr, signed char _Ch)
+ {
+ return (_Ostr << (char)_Ch);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr, const unsigned char *_Val)
+ {
+ return (_Ostr << (const char *)_Val);
+ }
+
+template<class _Traits> inline
+ basic_ostream<char, _Traits>& __cdecl operator<<(
+ basic_ostream<char, _Traits>& _Ostr, unsigned char _Ch)
+ {
+ return (_Ostr << (char)_Ch);
+ }
+
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>&
+ __cdecl endl(basic_ostream<_Elem, _Traits>& _Ostr)
+ {
+ _Ostr.put(_Ostr.widen('\n'));
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>&
+ __cdecl ends(basic_ostream<_Elem, _Traits>& _Ostr)
+ {
+ _Ostr.put(_Elem());
+ return (_Ostr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_ostream<_Elem, _Traits>&
+ __cdecl flush(basic_ostream<_Elem, _Traits>& _Ostr)
+ {
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+ inline basic_ostream<char, char_traits<char> >&
+ __cdecl endl(basic_ostream<char, char_traits<char> >& _Ostr)
+ {
+ _Ostr.put('\n');
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+ inline basic_ostream<wchar_t, char_traits<wchar_t> >&
+ __cdecl endl(basic_ostream<wchar_t,
+ char_traits<wchar_t> >& _Ostr)
+ {
+ _Ostr.put('\n');
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+
+ inline basic_ostream<char, char_traits<char> >&
+ __cdecl ends(basic_ostream<char, char_traits<char> >& _Ostr)
+ {
+ _Ostr.put('\0');
+ return (_Ostr);
+ }
+
+ inline basic_ostream<wchar_t, char_traits<wchar_t> >&
+ __cdecl ends(basic_ostream<wchar_t,
+ char_traits<wchar_t> >& _Ostr)
+ {
+ _Ostr.put('\0');
+ return (_Ostr);
+ }
+
+
+ inline basic_ostream<char, char_traits<char> >&
+ __cdecl flush(basic_ostream<char, char_traits<char> >& _Ostr)
+ {
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+ inline basic_ostream<wchar_t, char_traits<wchar_t> >&
+ __cdecl flush(basic_ostream<wchar_t,
+ char_traits<wchar_t> >& _Ostr)
+ {
+ _Ostr.flush();
+ return (_Ostr);
+ }
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+template<class _Elem,
+ class _Traits>
+ class basic_istream
+ : virtual public basic_ios<_Elem, _Traits>
+ {
+public:
+ typedef basic_istream<_Elem, _Traits> _Myt;
+ typedef basic_ios<_Elem, _Traits> _Myios;
+ typedef basic_streambuf<_Elem, _Traits> _Mysb;
+ typedef istreambuf_iterator<_Elem, _Traits> _Iter;
+ typedef ctype<_Elem> _Ctype;
+ typedef num_get<_Elem, _Iter> _Nget;
+
+
+ explicit basic_istream(_Mysb *_Strbuf, bool _Isstd = false)
+ : _Chcount(0)
+ {
+ _Myios::init(_Strbuf, _Isstd);
+ }
+
+ basic_istream(_Uninitialized)
+ {
+ ios_base::_Addstd(this);
+ }
+
+ virtual ~basic_istream()
+ {
+ }
+
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+
+ class _Sentry_base
+ {
+ public:
+ _Sentry_base(_Myt& _Istr)
+ : _Myistr(_Istr)
+ {
+ if (_Myistr.rdbuf() != 0)
+ _Myistr.rdbuf()->_Lock();
+ }
+
+ ~_Sentry_base()
+ {
+ if (_Myistr.rdbuf() != 0)
+ _Myistr.rdbuf()->_Unlock();
+ }
+
+ _Myt& _Myistr;
+ };
+
+ class sentry
+ : public _Sentry_base
+ {
+ public:
+ explicit sentry(_Myt& _Istr, bool _Noskip = false)
+ : _Sentry_base(_Istr)
+ {
+ _Ok = this->_Myistr._Ipfx(_Noskip);
+ }
+
+ operator bool() const
+ {
+ return (_Ok);
+ }
+
+ private:
+ sentry(const sentry&);
+ sentry& operator=(const sentry&);
+
+ bool _Ok;
+ };
+
+ bool _Ipfx(bool _Noskip = false)
+ {
+ if (ios_base::good())
+ {
+ if (_Myios::tie() != 0)
+ _Myios::tie()->flush();
+
+ if (!_Noskip && ios_base::flags() & ios_base::skipws)
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(ios_base::getloc());
+
+ try {
+ int_type _Meta = _Myios::rdbuf()->sgetc();
+
+ for (; ; _Meta = _Myios::rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _Myios::setstate(ios_base::eofbit);
+ break;
+ }
+ else if (!_Ctype_fac.is(_Ctype::space,
+ _Traits::to_char_type(_Meta)))
+ break;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ if (ios_base::good())
+ return (true);
+ }
+ _Myios::setstate(ios_base::failbit);
+ return (false);
+ }
+
+ bool ipfx(bool _Noskip = false)
+ {
+ return _Ipfx(_Noskip);
+ }
+
+ void isfx()
+ {
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _Myt& operator>>(_Myt& (__cdecl *_Pfn)(_Myt&))
+ {
+ ;
+ return ((*_Pfn)(*this));
+ }
+
+ _Myt& operator>>(_Myios& (__cdecl *_Pfn)(_Myios&))
+ {
+ ;
+ (*_Pfn)(*(_Myios *)this);
+ return (*this);
+ }
+
+ _Myt& operator>>(ios_base& (__cdecl *_Pfn)(ios_base&))
+ {
+ ;
+ (*_Pfn)(*(ios_base *)this);
+ return (*this);
+ }
+
+ _Myt& operator>>(_Bool& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(short& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ long _Tmp = 0;
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Tmp);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+
+ if (_State & ios_base::failbit
+ || _Tmp < (-32768) || 32767 < _Tmp)
+ _State |= ios_base::failbit;
+ else
+ _Val = (short)_Tmp;
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+
+
+
+
+
+
+
+ _Myt& operator>>(unsigned short& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(int& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ long _Tmp = 0;
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Tmp);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+
+ if (_State & ios_base::failbit
+ || _Tmp < (-2147483647 - 1) || 2147483647 < _Tmp)
+ _State |= ios_base::failbit;
+ else
+ _Val = _Tmp;
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(unsigned int& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(long& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(unsigned long __w64& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, (unsigned long)_Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+ _Myt& operator>>(__int64& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(unsigned __int64& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+
+ _Myt& operator>>(float& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(double& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(long double& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(void *& _Val)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const sentry _Ok(*this);
+
+ if (_Ok)
+ {
+ const _Nget& _Nget_fac = use_facet<_Nget >(ios_base::getloc());
+
+ try {
+ _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
+ *this, _State, _Val);
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& operator>>(_Mysb *_Strbuf)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ bool _Copied = false;
+ const sentry _Ok(*this);
+
+ if (_Ok && _Strbuf != 0)
+ {
+ try {
+ int_type _Meta = _Myios::rdbuf()->sgetc();
+
+ for (; ; _Meta = _Myios::rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else
+ {
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Strbuf->sputc(_Traits::to_char_type(_Meta))))
+ break;
+ } catch (...) {
+ break;
+ }
+ _Copied = true;
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(!_Copied ? _State | ios_base::failbit : _State);
+ return (*this);
+ }
+
+ int_type get()
+ {
+ int_type _Meta = 0;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (!_Ok)
+ _Meta = _Traits::eof();
+ else
+ {
+ try {
+ _Meta = _Myios::rdbuf()->sbumpc();
+
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ _State |= ios_base::eofbit | ios_base::failbit;
+ else
+ ++_Chcount;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (_Meta);
+ }
+
+ _Myt& get(_Elem *_Str, streamsize _Count)
+ {
+ return (get(_Str, _Count, _Myios::widen('\n')));
+ }
+
+ _Myt& get(_Elem *_Str,
+ streamsize _Count, _Elem _Delim)
+ {
+ ;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok && 0 < _Count)
+ {
+ try {
+ int_type _Meta = _Myios::rdbuf()->sgetc();
+
+ for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (_Traits::to_char_type(_Meta) == _Delim)
+ break;
+ else
+ {
+ *_Str++ = _Traits::to_char_type(_Meta);
+ ++_Chcount;
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_Chcount == 0
+ ? _State | ios_base::failbit : _State);
+ *_Str = _Elem();
+ return (*this);
+ }
+
+ _Myt& get(_Elem& _Ch)
+ {
+ int_type _Meta = get();
+ if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
+ _Ch = _Traits::to_char_type(_Meta);
+ return (*this);
+ }
+
+ _Myt& get(_Mysb& _Strbuf)
+ {
+ return (get(_Strbuf, _Myios::widen('\n')));
+ }
+
+ _Myt& get(_Mysb& _Strbuf, _Elem _Delim)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok)
+ {
+ try {
+ int_type _Meta = _Myios::rdbuf()->sgetc();
+
+ for (; ; _Meta = _Myios::rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else
+ {
+ try {
+ _Elem _Ch = _Traits::to_char_type(_Meta);
+ if (_Ch == _Delim
+ || _Traits::eq_int_type(_Traits::eof(),
+ _Strbuf.sputc(_Ch)))
+ break;
+ } catch (...) {
+ break;
+ }
+ ++_Chcount;
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ if (_Chcount == 0)
+ _State |= ios_base::failbit;
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& getline(_Elem *_Str, streamsize _Count)
+ {
+ return (getline(_Str, _Count, _Myios::widen('\n')));
+ }
+
+ _Myt& getline(_Elem *_Str,
+ streamsize _Count, _Elem _Delim)
+ {
+ ;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok && 0 < _Count)
+ {
+ int_type _Metadelim = _Traits::to_int_type(_Delim);
+
+ try {
+ int_type _Meta = _Myios::rdbuf()->sgetc();
+
+ for (; ; _Meta = _Myios::rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (_Meta == _Metadelim)
+ {
+ ++_Chcount;
+ _Myios::rdbuf()->sbumpc();
+ break;
+ }
+ else if (--_Count <= 0)
+ {
+ _State |= ios_base::failbit;
+ break;
+ }
+ else
+ {
+ ++_Chcount;
+ *_Str++ = _Traits::to_char_type(_Meta);
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ *_Str = _Elem();
+ _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
+ return (*this);
+ }
+
+ _Myt& ignore(streamsize _Count = 1,
+ int_type _Metadelim = _Traits::eof())
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok && 0 < _Count)
+ {
+ try {
+ for (; ; )
+ {
+ int_type _Meta;
+ if (_Count != 2147483647 && --_Count < 0)
+ break;
+ else if (_Traits::eq_int_type(_Traits::eof(),
+ _Meta = _Myios::rdbuf()->sbumpc()))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else
+ {
+ ++_Chcount;
+ if (_Meta == _Metadelim)
+ break;
+ }
+ }
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& _Read_s(_Elem *_Str, size_t _Str_size, streamsize _Count)
+ {
+ ;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok)
+ {
+ try {
+ const streamsize _Num = _Myios::rdbuf()->_Sgetn_s(_Str, _Str_size, _Count);
+ _Chcount += _Num;
+ if (_Num != _Count)
+ _State |= ios_base::eofbit | ios_base::failbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& read(_Elem *_Str, streamsize _Count)
+ {
+ return _Read_s(_Str, (size_t)-1, _Count);
+ }
+
+ streamsize _Readsome_s(_Elem *_Str, size_t _Str_size, streamsize _Count)
+ {
+ ;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+ streamsize _Num;
+
+ if (!_Ok)
+ _State |= ios_base::failbit;
+ else if ((_Num = _Myios::rdbuf()->in_avail()) < 0)
+ _State |= ios_base::eofbit;
+ else if (0 < _Num)
+ _Read_s(_Str, _Str_size, _Num < _Count ? _Num : _Count);
+
+ _Myios::setstate(_State);
+ return (gcount());
+ }
+
+ __declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ streamsize readsome(_Elem *_Str, streamsize _Count)
+ {
+ return _Readsome_s(_Str, (size_t)-1, _Count);
+ }
+
+ int_type peek()
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ int_type _Meta = 0;
+ const sentry _Ok(*this, true);
+
+ if (!_Ok)
+ _Meta = _Traits::eof();
+ else
+ {
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Meta = _Myios::rdbuf()->sgetc()))
+ _State |= ios_base::eofbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (_Meta);
+ }
+
+ _Myt& putback(_Elem _Ch)
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok)
+ {
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Myios::rdbuf()->sputbackc(_Ch)))
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ _Myt& unget()
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ _Chcount = 0;
+ const sentry _Ok(*this, true);
+
+ if (_Ok)
+ {
+ try {
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Myios::rdbuf()->sungetc()))
+ _State |= ios_base::badbit;
+ } catch (...) { _Myios::setstate(ios_base::badbit, true); }
+ }
+
+ _Myios::setstate(_State);
+ return (*this);
+ }
+
+ streamsize gcount() const
+ {
+ return (_Chcount);
+ }
+
+ int sync()
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ int _Ans;
+
+ if (_Myios::rdbuf() == 0)
+ _Ans = -1;
+ else if (_Myios::rdbuf()->pubsync() == -1)
+ {
+ _State |= ios_base::badbit;
+ _Ans = -1;
+ }
+ else
+ _Ans = 0;
+
+ _Myios::setstate(_State);
+ return (_Ans);
+ }
+
+ _Myt& seekg(pos_type _Pos)
+ {
+ if (!ios_base::fail()
+ && (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
+ ios_base::in) == _BADOFF)
+ _Myios::setstate(ios_base::failbit);
+ return (*this);
+ }
+
+ _Myt& seekg(off_type _Off, ios_base::seekdir _Way)
+ {
+ if (!ios_base::fail()
+ && (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
+ ios_base::in) == _BADOFF)
+ _Myios::setstate(ios_base::failbit);
+ return (*this);
+ }
+
+ pos_type tellg()
+ {
+ if (!ios_base::fail())
+ return (_Myios::rdbuf()->pubseekoff(0,
+ ios_base::cur, ios_base::in));
+ else
+ return (pos_type(_BADOFF));
+ }
+
+private:
+ streamsize _Chcount;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits>
+ class basic_iostream
+ : public basic_istream<_Elem, _Traits>,
+ public basic_ostream<_Elem, _Traits>
+ {
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+ explicit basic_iostream(basic_streambuf<_Elem, _Traits> *_Strbuf)
+ : basic_istream<_Elem, _Traits>(_Strbuf, false),
+ basic_ostream<_Elem, _Traits>(_Strbuf)
+ {
+ }
+
+ virtual ~basic_iostream()
+ {
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits> inline
+ basic_istream<_Elem, _Traits>& __cdecl operator>>(
+ basic_istream<_Elem, _Traits>& _Istr, _Elem *_Str)
+ {
+ ;
+ typedef basic_istream<_Elem, _Traits> _Myis;
+ typedef ctype<_Elem> _Ctype;
+ ios_base::iostate _State = ios_base::goodbit;
+ _Elem *_Str0 = _Str;
+ const typename _Myis::sentry _Ok(_Istr);
+
+ if (_Ok)
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(_Istr.getloc());
+
+ try {
+ streamsize _Count = 0 < _Istr.width() ? _Istr.width() : 2147483647;
+ typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
+ _Elem _Ch;
+ for (; 0 < --_Count; _Meta = _Istr.rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (_Ctype_fac.is(_Ctype::space,
+ _Ch = _Traits::to_char_type(_Meta))
+ || _Ch == _Elem())
+ break;
+ else
+ *_Str++ = _Traits::to_char_type(_Meta);
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ *_Str = _Elem();
+ _Istr.width(0);
+ _Istr.setstate(_Str == _Str0 ? _State | ios_base::failbit : _State);
+ return (_Istr);
+ }
+
+template<class _Elem,
+ class _Traits> inline
+ basic_istream<_Elem, _Traits>& __cdecl operator>>(
+ basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch)
+ {
+ typedef basic_istream<_Elem, _Traits> _Myis;
+ typename _Myis::int_type _Meta;
+ ios_base::iostate _State = ios_base::goodbit;
+ const typename _Myis::sentry _Ok(_Istr);
+
+ if (_Ok)
+ {
+ try {
+ _Meta = _Istr.rdbuf()->sbumpc();
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ _State |= ios_base::eofbit | ios_base::failbit;
+ else
+ _Ch = _Traits::to_char_type(_Meta);
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ _Istr.setstate(_State);
+ return (_Istr);
+ }
+
+template<class _Traits> inline
+ basic_istream<char, _Traits>& __cdecl operator>>(
+ basic_istream<char, _Traits>& _Istr, signed char *_Str)
+ {
+ return (_Istr >> (char *)_Str);
+ }
+
+template<class _Traits> inline
+ basic_istream<char, _Traits>& __cdecl operator>>(
+ basic_istream<char, _Traits>& _Istr, signed char& _Ch)
+ {
+ return (_Istr >> (char&)_Ch);
+ }
+
+template<class _Traits> inline
+ basic_istream<char, _Traits>& __cdecl operator>>(
+ basic_istream<char, _Traits>& _Istr, unsigned char *_Str)
+ {
+ return (_Istr >> (char *)_Str);
+ }
+
+template<class _Traits> inline
+ basic_istream<char, _Traits>& __cdecl operator>>(
+ basic_istream<char, _Traits>& _Istr, unsigned char& _Ch)
+ {
+ return (_Istr >> (char&)_Ch);
+ }
+
+
+template<class _Elem,
+ class _Traits> inline
+ basic_istream<_Elem, _Traits>&
+ __cdecl ws(basic_istream<_Elem, _Traits>& _Istr)
+ {
+ typedef basic_istream<_Elem, _Traits> _Myis;
+ typedef ctype<_Elem> _Ctype;
+
+ if (!_Istr.eof())
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const typename _Myis::sentry _Ok(_Istr, true);
+
+ if (_Ok)
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(_Istr.getloc());
+
+ try {
+ for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
+ _Meta = _Istr.rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (!_Ctype_fac.is(_Ctype::space,
+ _Traits::to_char_type(_Meta)))
+ break;
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ _Istr.setstate(_State);
+ }
+ return (_Istr);
+ }
+
+ inline basic_istream<char, char_traits<char> >&
+ __cdecl ws(basic_istream<char, char_traits<char> >& _Istr)
+ {
+ typedef char _Elem;
+ typedef char_traits<_Elem> _Traits;
+
+ if (!_Istr.eof())
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);
+
+ if (_Ok)
+ {
+ const ctype<_Elem>& _Ctype_fac =
+ use_facet<ctype<_Elem> >(_Istr.getloc());
+
+ try {
+ for (_Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
+ _Meta = _Istr.rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (!_Ctype_fac.is(ctype<_Elem>::space,
+ _Traits::to_char_type(_Meta)))
+ break;
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ _Istr.setstate(_State);
+ }
+ return (_Istr);
+ }
+
+ inline basic_istream<wchar_t, char_traits<wchar_t> >&
+ __cdecl ws(basic_istream<wchar_t, char_traits<wchar_t> >& _Istr)
+ {
+ typedef wchar_t _Elem;
+ typedef char_traits<_Elem> _Traits;
+
+ if (!_Istr.eof())
+ {
+ ios_base::iostate _State = ios_base::goodbit;
+ const basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);
+
+ if (_Ok)
+ {
+ const ctype<_Elem>& _Ctype_fac =
+ use_facet<ctype<_Elem> >(_Istr.getloc());
+
+ try {
+ for (_Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
+ _Meta = _Istr.rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (!_Ctype_fac.is(ctype<_Elem>::space,
+ _Traits::to_char_type(_Meta)))
+ break;
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ _Istr.setstate(_State);
+ }
+ return (_Istr);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4189)
+
+
+namespace std {
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_string<_Elem, _Traits, _Alloc> __cdecl operator+(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_string<_Elem, _Traits, _Alloc> __cdecl operator+(
+ const _Elem *_Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_string<_Elem, _Traits, _Alloc> __cdecl operator+(
+ const _Elem _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (basic_string<_Elem, _Traits, _Alloc>(1, _Left) += _Right);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_string<_Elem, _Traits, _Alloc> __cdecl operator+(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_string<_Elem, _Traits, _Alloc> __cdecl operator+(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem _Right)
+ {
+ return (basic_string<_Elem, _Traits, _Alloc>(_Left) += _Right);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator==(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Left.compare(_Right) == 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator==(
+ const _Elem * _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Right.compare(_Left) == 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator==(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (_Left.compare(_Right) == 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator!=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator!=(
+ const _Elem *_Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator!=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Left.compare(_Right) < 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<(
+ const _Elem * _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Right.compare(_Left) > 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (_Left.compare(_Right) < 0);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>(
+ const _Elem * _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<=(
+ const _Elem * _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator<=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>=(
+ const _Elem * _Left,
+ const basic_string<_Elem, _Traits, _Alloc>& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ bool __cdecl operator>=(
+ const basic_string<_Elem, _Traits, _Alloc>& _Left,
+ const _Elem *_Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_istream<_Elem, _Traits>& __cdecl operator>>(
+ basic_istream<_Elem, _Traits>& _Istr,
+ basic_string<_Elem, _Traits, _Alloc>& _Str)
+ {
+ typedef ctype<_Elem> _Ctype;
+ typedef basic_istream<_Elem, _Traits> _Myis;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+ typedef typename _Mystr::size_type _Mysizt;
+
+ ios_base::iostate _State = ios_base::goodbit;
+ bool _Changed = false;
+ const typename _Myis::sentry _Ok(_Istr);
+
+ if (_Ok)
+ {
+ const _Ctype& _Ctype_fac = use_facet<_Ctype >(_Istr.getloc());
+ _Str.erase();
+
+ try {
+ _Mysizt _Size = 0 < _Istr.width()
+ && (_Mysizt)_Istr.width() < _Str.max_size()
+ ? (_Mysizt)_Istr.width() : _Str.max_size();
+ typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();
+
+ for (; 0 < _Size; --_Size, _Meta = _Istr.rdbuf()->snextc())
+ if(_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (_Ctype_fac.is(_Ctype::space,
+ _Traits::to_char_type(_Meta)))
+ break;
+ else
+ {
+ _Str.append(1, _Traits::to_char_type(_Meta));
+ _Changed = true;
+ }
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ _Istr.width(0);
+ if (!_Changed)
+ _State |= ios_base::failbit;
+ _Istr.setstate(_State);
+ return (_Istr);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_istream<_Elem, _Traits>& __cdecl getline(
+ basic_istream<_Elem, _Traits>& _Istr,
+ basic_string<_Elem, _Traits, _Alloc>& _Str,
+ const _Elem _Delim)
+ {
+ typedef basic_istream<_Elem, _Traits> _Myis;
+ ios_base::iostate _State = ios_base::goodbit;
+ bool _Changed = false;
+ const typename _Myis::sentry _Ok(_Istr, true);
+
+ if (_Ok)
+ {
+ try {
+ _Str.erase();
+ const typename _Traits::int_type _Metadelim =
+ _Traits::to_int_type(_Delim);
+ typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();
+
+ for (; ; _Meta = _Istr.rdbuf()->snextc())
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ {
+ _State |= ios_base::eofbit;
+ break;
+ }
+ else if (_Traits::eq_int_type(_Meta, _Metadelim))
+ {
+ _Changed = true;
+ _Istr.rdbuf()->sbumpc();
+ break;
+ }
+ else if (_Str.max_size() <= _Str.size())
+ {
+ _State |= ios_base::failbit;
+ break;
+ }
+ else
+ {
+ _Str += _Traits::to_char_type(_Meta);
+ _Changed = true;
+ }
+ } catch (...) { (_Istr).setstate(ios_base::badbit, true); }
+ }
+
+ if (!_Changed)
+ _State |= ios_base::failbit;
+ _Istr.setstate(_State);
+ return (_Istr);
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_istream<_Elem, _Traits>& __cdecl getline(
+ basic_istream<_Elem, _Traits>& _Istr,
+ basic_string<_Elem, _Traits, _Alloc>& _Str)
+ {
+ return (getline(_Istr, _Str, _Istr.widen('\n')));
+ }
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc> inline
+ basic_ostream<_Elem, _Traits>& __cdecl operator<<(
+ basic_ostream<_Elem, _Traits>& _Ostr,
+ const basic_string<_Elem, _Traits, _Alloc>& _Str)
+ {
+ typedef basic_ostream<_Elem, _Traits> _Myos;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+ typedef typename _Mystr::size_type _Mysizt;
+
+ ios_base::iostate _State = ios_base::goodbit;
+ _Mysizt _Size = _Str.size();
+ _Mysizt _Pad = _Ostr.width() <= 0 || (_Mysizt)_Ostr.width() <= _Size
+ ? 0 : (_Mysizt)_Ostr.width() - _Size;
+ const typename _Myos::sentry _Ok(_Ostr);
+
+ if (!_Ok)
+ _State |= ios_base::badbit;
+ else
+ {
+ try {
+ if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+
+ if (_State == ios_base::goodbit)
+ for (_Mysizt _Count = 0; _Count < _Size; ++_Count)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Str[_Count])))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+
+ if (_State == ios_base::goodbit)
+ for (; 0 < _Pad; --_Pad)
+ if (_Traits::eq_int_type(_Traits::eof(),
+ _Ostr.rdbuf()->sputc(_Ostr.fill())))
+ {
+ _State |= ios_base::badbit;
+ break;
+ }
+ _Ostr.width(0);
+ } catch (...) { (_Ostr).setstate(ios_base::badbit, true); }
+ }
+
+ _Ostr.setstate(_State);
+ return (_Ostr);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+ #pragma warning(default: 4189)
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+ #pragma warning(disable:4251)
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class basic_stringbuf
+ : public basic_streambuf<_Elem, _Traits>
+ {
+public:
+ typedef _Alloc allocator_type;
+ typedef basic_streambuf<_Elem, _Traits> _Mysb;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+
+ explicit basic_stringbuf(ios_base::openmode _Mode =
+ ios_base::in | ios_base::out)
+ {
+ _Init(0, 0, _Getstate(_Mode));
+ }
+
+ explicit basic_stringbuf(const _Mystr& _Str,
+ ios_base::openmode _Mode = ios_base::in | ios_base::out)
+ {
+ _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
+ }
+
+ virtual ~basic_stringbuf()
+ {
+ _Tidy();
+ }
+
+ enum
+ {
+ _Allocated = 1,
+ _Constant = 2,
+ _Noread = 4,
+ _Append = 8,
+ _Atend = 16};
+ typedef int _Strstate;
+
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+
+ _Mystr str() const
+ {
+ if (!(_Mystate & _Constant) && _Mysb::pptr() != 0)
+ {
+ _Mystr _Str(_Mysb::pbase(), (_Seekhigh < _Mysb::pptr()
+ ? _Mysb::pptr() : _Seekhigh) - _Mysb::pbase());
+ return (_Str);
+ }
+ else if (!(_Mystate & _Noread) && _Mysb::gptr() != 0)
+ {
+ _Mystr _Str(_Mysb::eback(), _Mysb::egptr() - _Mysb::eback());
+ return (_Str);
+ }
+ else
+ {
+ _Mystr _Nul;
+ return (_Nul);
+ }
+ }
+
+ void str(const _Mystr& _Newstr)
+ {
+ _Tidy();
+ _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
+ }
+
+protected:
+ virtual int_type overflow(int_type _Meta = _Traits::eof())
+ {
+ if (_Mystate & _Append
+ && _Mysb::pptr() != 0 && _Mysb::pptr() < _Seekhigh)
+ _Mysb::setp(_Mysb::pbase(), _Seekhigh, _Mysb::epptr());
+
+ if (_Traits::eq_int_type(_Traits::eof(), _Meta))
+ return (_Traits::not_eof(_Meta));
+ else if (_Mysb::pptr() != 0
+ && _Mysb::pptr() < _Mysb::epptr())
+ {
+ *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+ return (_Meta);
+ }
+ else if (_Mystate & _Constant)
+ return (_Traits::eof());
+ else
+ {
+ size_t _Oldsize = _Mysb::pptr() == 0
+ ? 0 : _Mysb::epptr() - _Mysb::eback();
+ size_t _Newsize = _Oldsize;
+ size_t _Inc = _Newsize / 2 < _MINSIZE
+ ? _MINSIZE : _Newsize / 2;
+ _Elem *_Ptr = 0;
+
+ while (0 < _Inc && 2147483647 - _Inc < _Newsize)
+ _Inc /= 2;
+ if (0 < _Inc)
+ {
+ _Newsize += _Inc;
+ _Ptr = _Al.allocate(_Newsize);
+ }
+
+ if (0 < _Oldsize)
+ _Traits_helper::copy_s<_Traits>(_Ptr, _Newsize, _Mysb::eback(), _Oldsize);
+ if (_Mystate & _Allocated)
+ _Al.deallocate(_Mysb::eback(), _Oldsize);
+ _Mystate |= _Allocated;
+
+ if (_Oldsize == 0)
+ {
+ _Seekhigh = _Ptr;
+ _Mysb::setp(_Ptr, _Ptr + _Newsize);
+ if (_Mystate & _Noread)
+ _Mysb::setg(_Ptr, 0, _Ptr);
+ else
+ _Mysb::setg(_Ptr, _Ptr, _Ptr + 1);
+ }
+ else
+ {
+ _Seekhigh = _Seekhigh - _Mysb::eback() + _Ptr;
+ _Mysb::setp(_Mysb::pbase() - _Mysb::eback() + _Ptr,
+ _Mysb::pptr() - _Mysb::eback() + _Ptr, _Ptr + _Newsize);
+ if (_Mystate & _Noread)
+ _Mysb::setg(_Ptr, 0, _Ptr);
+ else
+ _Mysb::setg(_Ptr,
+ _Mysb::gptr() - _Mysb::eback() + _Ptr,
+ _Mysb::pptr() + 1);
+ }
+
+ *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+ return (_Meta);
+ }
+ }
+
+ virtual int_type pbackfail(int_type _Meta = _Traits::eof())
+ {
+ if (_Mysb::gptr() == 0
+ || _Mysb::gptr() <= _Mysb::eback()
+ || !_Traits::eq_int_type(_Traits::eof(), _Meta)
+ && !_Traits::eq(_Traits::to_char_type(_Meta), _Mysb::gptr()[-1])
+ && _Mystate & _Constant)
+ return (_Traits::eof());
+ else
+ {
+ _Mysb::gbump(-1);
+ if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
+ *_Mysb::gptr() = _Traits::to_char_type(_Meta);
+ return (_Traits::not_eof(_Meta));
+ }
+ }
+
+ virtual int_type underflow()
+ {
+ if (_Mysb::gptr() == 0)
+ return (_Traits::eof());
+ else if (_Mysb::gptr() < _Mysb::egptr())
+ return (_Traits::to_int_type(*_Mysb::gptr()));
+ else if (_Mystate & _Noread || _Mysb::pptr() == 0
+ || _Mysb::pptr() <= _Mysb::gptr() && _Seekhigh <= _Mysb::gptr())
+ return (_Traits::eof());
+ else
+ {
+ if (_Seekhigh < _Mysb::pptr())
+ _Seekhigh = _Mysb::pptr();
+ _Mysb::setg(_Mysb::eback(), _Mysb::gptr(), _Seekhigh);
+ return (_Traits::to_int_type(*_Mysb::gptr()));
+ }
+ }
+
+ virtual pos_type seekoff(off_type _Off,
+ ios_base::seekdir _Way,
+ ios_base::openmode _Which = ios_base::in | ios_base::out)
+ {
+ if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
+ _Seekhigh = _Mysb::pptr();
+
+ if (_Which & ios_base::in && _Mysb::gptr() != 0)
+ {
+ if (_Way == ios_base::end)
+ _Off += (off_type)(_Seekhigh - _Mysb::eback());
+ else if (_Way == ios_base::cur
+ && (_Which & ios_base::out) == 0)
+ _Off += (off_type)(_Mysb::gptr() - _Mysb::eback());
+ else if (_Way != ios_base::beg)
+ _Off = _BADOFF;
+
+ if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
+ {
+ _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
+ if (_Which & ios_base::out && _Mysb::pptr() != 0)
+ _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
+ _Mysb::epptr());
+ }
+ else
+ _Off = _BADOFF;
+ }
+ else if (_Which & ios_base::out && _Mysb::pptr() != 0)
+ {
+ if (_Way == ios_base::end)
+ _Off += (off_type)(_Seekhigh - _Mysb::eback());
+ else if (_Way == ios_base::cur)
+ _Off += (off_type)(_Mysb::pptr() - _Mysb::eback());
+ else if (_Way != ios_base::beg)
+ _Off = _BADOFF;
+
+ if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
+ _Mysb::pbump((int)(_Mysb::eback()
+ - _Mysb::pptr() + _Off));
+ else
+ _Off = _BADOFF;
+ }
+ else
+ _Off = _BADOFF;
+ return (pos_type(_Off));
+ }
+
+ virtual pos_type seekpos(pos_type _Ptr,
+ ios_base::openmode _Mode = ios_base::in | ios_base::out)
+ {
+ streamoff _Off = (streamoff)_Ptr;
+ if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
+ _Seekhigh = _Mysb::pptr();
+
+ if (_Off == _BADOFF)
+ ;
+ else if (_Mode & ios_base::in && _Mysb::gptr() != 0)
+ {
+ if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
+ {
+ _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
+ if (_Mode & ios_base::out && _Mysb::pptr() != 0)
+ _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
+ _Mysb::epptr());
+ }
+ else
+ _Off = _BADOFF;
+ }
+ else if (_Mode & ios_base::out && _Mysb::pptr() != 0)
+ {
+ if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
+ _Mysb::pbump((int)(_Mysb::eback()
+ - _Mysb::pptr() + _Off));
+ else
+ _Off = _BADOFF;
+ }
+ else
+ _Off = _BADOFF;
+ return (streampos(_Off));
+ }
+
+ void _Init(const _Elem *_Ptr,
+ size_t _Count, _Strstate _State)
+ {
+ _Seekhigh = 0;
+ _Mystate = _State;
+
+ if (_Count != 0
+ && (_Mystate & (_Noread | _Constant)) != (_Noread | _Constant))
+ {
+ _Elem *_Pnew = _Al.allocate(_Count);
+ _Traits_helper::copy_s<_Traits>(_Pnew, _Count, _Ptr, _Count);
+ _Seekhigh = _Pnew + _Count;
+
+ if (!(_Mystate & _Noread))
+ _Mysb::setg(_Pnew, _Pnew,
+ _Pnew + _Count);
+ if (!(_Mystate & _Constant))
+ {
+ _Mysb::setp(_Pnew,
+ (_Mystate & _Atend) ? _Pnew + _Count : _Pnew,
+ _Pnew + _Count);
+ if (_Mysb::gptr() == 0)
+ _Mysb::setg(_Pnew, 0, _Pnew);
+ }
+ _Mystate |= _Allocated;
+ }
+ }
+
+ void _Tidy()
+ {
+ if (_Mystate & _Allocated)
+ _Al.deallocate(_Mysb::eback(),
+ (_Mysb::pptr() != 0 ? _Mysb::epptr()
+ : _Mysb::egptr()) - _Mysb::eback());
+ _Mysb::setg(0, 0, 0);
+ _Mysb::setp(0, 0);
+ _Seekhigh = 0;
+ _Mystate &= ~_Allocated;
+ }
+
+private:
+ enum
+ {
+ _MINSIZE = 32};
+
+ _Strstate _Getstate(ios_base::openmode _Mode)
+ {
+ _Strstate _State = (_Strstate)0;
+ if (!(_Mode & ios_base::in))
+ _State |= _Noread;
+ if (!(_Mode & ios_base::out))
+ _State |= _Constant;
+ if (_Mode & ios_base::app)
+ _State |= _Append;
+ if (_Mode & ios_base::ate)
+ _State |= _Atend;
+ return (_State);
+ }
+
+ _Elem *_Seekhigh;
+ _Strstate _Mystate;
+ allocator_type _Al;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class basic_istringstream
+ : public basic_istream<_Elem, _Traits>
+ {
+public:
+ typedef _Alloc allocator_type;
+ typedef basic_stringbuf<_Elem, _Traits, _Alloc> _Mysb;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+
+ explicit basic_istringstream(ios_base::openmode _Mode = ios_base::in)
+ : basic_istream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Mode | ios_base::in)
+ {
+ }
+
+ explicit basic_istringstream(const _Mystr& _Str,
+ ios_base::openmode _Mode = ios_base::in)
+ : basic_istream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Str, _Mode | ios_base::in)
+ {
+ }
+
+ virtual ~basic_istringstream()
+ {
+ }
+
+ _Mysb * rdbuf() const
+ {
+ return ((_Mysb *)&_Stringbuffer);
+ }
+
+ _Mystr str() const
+ {
+ return (_Stringbuffer.str());
+ }
+
+ void str(const _Mystr& _Newstr)
+ {
+ _Stringbuffer.str(_Newstr);
+ }
+
+private:
+ _Mysb _Stringbuffer;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class basic_ostringstream
+ : public basic_ostream<_Elem, _Traits>
+ {
+public:
+ typedef _Alloc allocator_type;
+ typedef basic_stringbuf<_Elem, _Traits, _Alloc> _Mysb;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+
+ explicit basic_ostringstream(ios_base::openmode _Mode = ios_base::out)
+ : basic_ostream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Mode | ios_base::out)
+ {
+ }
+
+ explicit basic_ostringstream(const _Mystr& _Str,
+ ios_base::openmode _Mode = ios_base::out)
+ : basic_ostream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Str, _Mode | ios_base::out)
+ {
+ }
+
+ virtual ~basic_ostringstream()
+ {
+ }
+
+ _Mysb * rdbuf() const
+ {
+ return ((_Mysb *)&_Stringbuffer);
+ }
+
+ _Mystr str() const
+ {
+ return (_Stringbuffer.str());
+ }
+
+ void str(const _Mystr& _Newstr)
+ {
+ _Stringbuffer.str(_Newstr);
+ }
+
+private:
+ _Mysb _Stringbuffer;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Elem,
+ class _Traits,
+ class _Alloc>
+ class basic_stringstream
+ : public basic_iostream<_Elem, _Traits>
+ {
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef _Alloc allocator_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
+
+ explicit basic_stringstream(ios_base::openmode _Mode =
+ ios_base::in | ios_base::out)
+ : basic_iostream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Mode)
+ {
+ }
+
+ explicit basic_stringstream(const _Mystr& _Str,
+ ios_base::openmode _Mode = ios_base::in | ios_base::out)
+ : basic_iostream<_Elem, _Traits>(&_Stringbuffer),
+ _Stringbuffer(_Str, _Mode)
+ {
+ }
+
+ virtual ~basic_stringstream()
+ {
+ }
+
+ basic_stringbuf<_Elem, _Traits, _Alloc> * rdbuf() const
+ {
+ return ((basic_stringbuf<_Elem, _Traits, _Alloc> *)&_Stringbuffer);
+ }
+
+ _Mystr str() const
+ {
+ return (_Stringbuffer.str());
+ }
+
+ void str(const _Mystr& _Newstr)
+ {
+ _Stringbuffer.str(_Newstr);
+ }
+
+private:
+ basic_stringbuf<_Elem, _Traits, _Alloc>
+ _Stringbuffer;
+ };
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4244)
+
+
+typedef struct _C_double_complex
+ {
+ double _Val[2];
+ } _C_double_complex;
+
+typedef struct _C_float_complex
+ {
+ float _Val[2];
+ } _C_float_complex;
+
+typedef struct _C_ldouble_complex
+ {
+ long double _Val[2];
+ } _C_ldouble_complex;
+
+
+
+
+
+namespace std {
+typedef ::_C_double_complex _Dcomplex_value;
+typedef ::_C_float_complex _Fcomplex_value;
+typedef ::_C_ldouble_complex _Lcomplex_value;
+
+
+
+
+template<class _Ty>
+ class _Ctraits
+ {
+public:
+ static _Ty __cdecl _Cosh(_Ty _Left, _Ty _Right)
+ {
+ return (::_Cosh((double)_Left, (double)_Right));
+ }
+
+ static short __cdecl _Exp(_Ty *_Pleft, _Ty _Right, short _Exponent)
+ {
+ double _Tmp = (double)*_Pleft;
+ short _Ans = ::_Exp(&_Tmp, (double)_Right, _Exponent);
+ *_Pleft = (_Ty)_Tmp;
+ return (_Ans);
+ }
+
+ static _Ty __cdecl _Infv(_Ty)
+ {
+ return (::_Inf._Double);
+ }
+
+ static bool __cdecl _Isinf(_Ty _Left)
+ {
+ double _Tmp = (double)_Left;
+ return (::_Dtest(&_Tmp) == 1);
+ }
+
+ static bool __cdecl _Isnan(_Ty _Left)
+ {
+ double _Tmp = (double)_Left;
+ return (::_Dtest(&_Tmp) == 2);
+ }
+
+ static _Ty __cdecl _Nanv(_Ty)
+ {
+ return (::_Nan._Double);
+ }
+
+ static _Ty __cdecl _Sinh(_Ty _Left, _Ty _Right)
+ {
+ return (::_Sinh((double)_Left, (double)_Right));
+ }
+
+ static _Ty __cdecl atan2(_Ty _Yval, _Ty _Xval)
+ {
+ return (::atan2((double)_Yval, (double)_Xval));
+ }
+
+ static _Ty __cdecl cos(_Ty _Left)
+ {
+ return (::cos((double)_Left));
+ }
+
+ static _Ty __cdecl exp(_Ty _Left)
+ {
+ return (::exp((double)_Left));
+ }
+
+ static _Ty __cdecl ldexp(_Ty _Left, int _Exponent)
+ {
+ return (::ldexp((double)_Left, _Exponent));
+ }
+
+ static _Ty __cdecl log(_Ty _Left)
+ {
+ return (::log((double)_Left));
+ }
+
+ static _Ty __cdecl pow(_Ty _Left, _Ty _Right)
+ {
+ return (::pow((double)_Left, (double)_Right));
+ }
+
+ static _Ty __cdecl sin(_Ty _Left)
+ {
+ return (::sin((double)_Left));
+ }
+
+ static _Ty __cdecl sqrt(_Ty _Left)
+ {
+ return (::sqrt((double)_Left));
+ }
+
+ static _Ty __cdecl tan(_Ty _Left)
+ {
+ return (::tan((double)_Left));
+ }
+ };
+
+
+template<> class _Ctraits<long double>
+ {
+public:
+ typedef long double _Ty;
+
+ static _Ty __cdecl _Cosh(_Ty _Left, _Ty _Right)
+ {
+ return (::_LCosh(_Left, _Right));
+ }
+
+ static short __cdecl _Exp(_Ty *_Pleft, _Ty _Right, short _Exponent)
+ {
+ return (::_LExp(_Pleft, _Right, _Exponent));
+ }
+
+ static _Ty __cdecl _Infv(_Ty)
+ {
+ return (::_LInf._Long_double);
+ }
+
+ static bool __cdecl _Isinf(_Ty _Left)
+ {
+ return (::_LDtest(&_Left) == 1);
+ }
+
+ static bool __cdecl _Isnan(_Ty _Left)
+ {
+ return (::_LDtest(&_Left) == 2);
+ }
+
+ static _Ty __cdecl _Nanv(_Ty)
+ {
+ return (::_LNan._Long_double);
+ }
+
+ static _Ty __cdecl _Sinh(_Ty _Left, _Ty _Right)
+ {
+ return (::_LSinh(_Left, _Right));
+ }
+
+ static _Ty __cdecl atan2(_Ty _Yval, _Ty _Xval)
+ {
+ return (::atan2l(_Yval, _Xval));
+ }
+
+ static _Ty __cdecl cos(_Ty _Left)
+ {
+ return (::cosl(_Left));
+ }
+
+ static _Ty __cdecl exp(_Ty _Left)
+ {
+ return (::expl(_Left));
+ }
+
+ static _Ty __cdecl ldexp(_Ty _Left, int _Exponent)
+ {
+ return (::ldexpl(_Left, _Exponent));
+ }
+
+ static _Ty __cdecl log(_Ty _Left)
+ {
+ return (::logl(_Left));
+ }
+
+ static _Ty __cdecl pow(_Ty _Left, _Ty _Right)
+ {
+ return (::powl(_Left, _Right));
+ }
+
+ static _Ty __cdecl sin(_Ty _Left)
+ {
+ return (::sinl(_Left));
+ }
+
+ static _Ty __cdecl sqrt(_Ty _Left)
+ {
+ return (::sqrtl(_Left));
+ }
+
+ static _Ty __cdecl tan(_Ty _Left)
+ {
+ return (::tanl(_Left));
+ }
+ };
+
+
+template<> class _Ctraits<double>
+ {
+public:
+ typedef double _Ty;
+
+ static _Ty __cdecl _Cosh(_Ty _Left, _Ty _Right)
+ {
+ return (::_Cosh(_Left, _Right));
+ }
+
+ static short __cdecl _Exp(_Ty *_Pleft, _Ty _Right, short _Exponent)
+ {
+ return (::_Exp(_Pleft, _Right, _Exponent));
+ }
+
+ static _Ty __cdecl _Infv(_Ty)
+ {
+ return (::_Inf._Double);
+ }
+
+ static bool __cdecl _Isinf(_Ty _Left)
+ {
+ return (::_Dtest(&_Left) == 1);
+ }
+
+ static bool __cdecl _Isnan(_Ty _Left)
+ {
+ return (::_Dtest(&_Left) == 2);
+ }
+
+ static _Ty __cdecl _Nanv(_Ty)
+ {
+ return (::_Nan._Double);
+ }
+
+ static _Ty __cdecl _Sinh(_Ty _Left, _Ty _Right)
+ {
+ return (::_Sinh(_Left, _Right));
+ }
+
+ static _Ty __cdecl atan2(_Ty _Yval, _Ty _Xval)
+ {
+ return (::atan2(_Yval, _Xval));
+ }
+
+ static _Ty __cdecl cos(_Ty _Left)
+ {
+ return (::cos(_Left));
+ }
+
+ static _Ty __cdecl exp(_Ty _Left)
+ {
+ return (::exp(_Left));
+ }
+
+ static _Ty __cdecl ldexp(_Ty _Left, int _Exponent)
+ {
+ return (::ldexp(_Left, _Exponent));
+ }
+
+ static _Ty __cdecl log(_Ty _Left)
+ {
+ return (::log(_Left));
+ }
+
+ static _Ty __cdecl pow(_Ty _Left, _Ty _Right)
+ {
+ return (::pow(_Left, _Right));
+ }
+
+ static _Ty __cdecl sin(_Ty _Left)
+ {
+ return (::sin(_Left));
+ }
+
+ static _Ty __cdecl sqrt(_Ty _Left)
+ {
+ return (::sqrt(_Left));
+ }
+
+ static _Ty __cdecl tan(_Ty _Left)
+ {
+ return (::tan(_Left));
+ }
+ };
+
+
+template<> class _Ctraits<float>
+ {
+public:
+ typedef float _Ty;
+
+ static _Ty __cdecl _Cosh(_Ty _Left, _Ty _Right)
+ {
+ return (::_FCosh(_Left, _Right));
+ }
+
+ static short __cdecl _Exp(_Ty *_Pleft, _Ty _Right, short _Exponent)
+ {
+ return (::_FExp(_Pleft, _Right, _Exponent));
+ }
+
+ static _Ty __cdecl _Infv(_Ty)
+ {
+ return (::_FInf._Float);
+ }
+
+ static bool __cdecl _Isinf(_Ty _Left)
+ {
+ return (::_FDtest(&_Left) == 1);
+ }
+
+ static bool __cdecl _Isnan(_Ty _Left)
+ {
+ return (::_FDtest(&_Left) == 2);
+ }
+
+ static _Ty __cdecl _Nanv(_Ty)
+ {
+ return (::_FNan._Float);
+ }
+
+ static _Ty __cdecl _Sinh(_Ty _Left, _Ty _Right)
+ {
+ return (::_FSinh(_Left, _Right));
+ }
+
+ static _Ty __cdecl atan2(_Ty _Yval, _Ty _Xval)
+ {
+ return (::atan2f(_Yval, _Xval));
+ }
+
+ static _Ty __cdecl cos(_Ty _Left)
+ {
+ return (::cosf(_Left));
+ }
+
+ static _Ty __cdecl exp(_Ty _Left)
+ {
+ return (::expf(_Left));
+ }
+
+ static _Ty __cdecl ldexp(_Ty _Left, int _Exponent)
+ {
+ return (::ldexpf(_Left, _Exponent));
+ }
+
+ static _Ty __cdecl log(_Ty _Left)
+ {
+ return (::logf(_Left));
+ }
+
+ static _Ty __cdecl pow(_Ty _Left, _Ty _Right)
+ {
+ return (::powf(_Left, _Right));
+ }
+
+ static _Ty __cdecl sin(_Ty _Left)
+ {
+ return (::sinf(_Left));
+ }
+
+ static _Ty __cdecl sqrt(_Ty _Left)
+ {
+ return (::sqrtf(_Left));
+ }
+
+ static _Ty __cdecl tan(_Ty _Left)
+ {
+ return (::tanf(_Left));
+ }
+ };
+
+template<class _Ty>
+ class complex;
+template<> class complex<float>;
+template<> class complex<double>;
+template<> class complex<long double>;
+
+
+template<class _Ty>
+ struct _Complex_value
+ {
+ enum {_Re = 0, _Im = 1};
+ _Ty _Val[2];
+ };
+
+
+template<class _Ty,
+ class _Valbase>
+ class _Complex_base
+ : public _Valbase
+ {
+public:
+ typedef _Ctraits<_Ty> _Myctraits;
+ typedef _Complex_base<_Ty, _Valbase> _Myt;
+ typedef _Ty value_type;
+
+ _Complex_base(const _Ty& _Realval, const _Ty& _Imagval)
+ {
+ this->_Val[0] = _Realval;
+ this->_Val[1] = _Imagval;
+ }
+
+ _Ty real(const _Ty& _Right)
+ {
+ return (this->_Val[0] = _Right);
+ }
+
+ _Ty imag(const _Ty& _Right)
+ {
+ return (this->_Val[1] = _Right);
+ }
+
+ _Ty real() const
+ {
+ return (this->_Val[0]);
+ }
+
+ _Ty imag() const
+ {
+ return (this->_Val[1]);
+ }
+
+protected:
+ template<class _Other> inline
+ void _Add(const complex<_Other>& _Right)
+ {
+ this->_Val[0] = this->_Val[0] + (_Ty)_Right.real();
+ this->_Val[1] = this->_Val[1] + (_Ty)_Right.imag();
+ }
+
+ template<class _Other> inline
+ void _Sub(const complex<_Other>& _Right)
+ {
+ this->_Val[0] = this->_Val[0] - (_Ty)_Right.real();
+ this->_Val[1] = this->_Val[1] - (_Ty)_Right.imag();
+ }
+
+ template<class _Other> inline
+ void _Mul(const complex<_Other>& _Right)
+ {
+ _Ty _Rightreal = (_Ty)_Right.real();
+ _Ty _Rightimag = (_Ty)_Right.imag();
+
+ _Ty _Tmp = this->_Val[0] * _Rightreal
+ - this->_Val[1] * _Rightimag;
+ this->_Val[1] = this->_Val[0] * _Rightimag
+ + this->_Val[1] * _Rightreal;
+ this->_Val[0] = _Tmp;
+ }
+
+ template<class _Other> inline
+ void _Div(const complex<_Other>& _Right)
+ {
+ typedef _Ctraits<_Ty> _Myctraits;
+ _Ty _Rightreal = (_Ty)_Right.real();
+ _Ty _Rightimag = (_Ty)_Right.imag();
+
+ if (_Myctraits::_Isnan(_Rightreal) || _Myctraits::_Isnan(_Rightimag))
+ {
+ this->_Val[0] = _Myctraits::_Nanv(_Rightreal);
+ this->_Val[1] = this->_Val[0];
+ }
+ else if ((_Rightimag < 0 ? -_Rightimag : +_Rightimag)
+ < (_Rightreal < 0 ? -_Rightreal : +_Rightreal))
+ {
+ _Ty _Wr = _Rightimag / _Rightreal;
+ _Ty _Wd = _Rightreal + _Wr * _Rightimag;
+
+ if (_Myctraits::_Isnan(_Wd) || _Wd == 0)
+ {
+ this->_Val[0] = _Myctraits::_Nanv(_Rightreal);
+ this->_Val[1] = this->_Val[0];
+ }
+ else
+ {
+ _Ty _Tmp = (this->_Val[0]
+ + this->_Val[1] * _Wr) / _Wd;
+ this->_Val[1] = (this->_Val[1]
+ - this->_Val[0] * _Wr) / _Wd;
+ this->_Val[0] = _Tmp;
+ }
+ }
+ else if (_Rightimag == 0)
+ {
+ this->_Val[0] = _Myctraits::_Nanv(_Rightreal);
+ this->_Val[1] = this->_Val[0];
+ }
+ else
+ {
+ _Ty _Wr = _Rightreal / _Rightimag;
+ _Ty _Wd = _Rightimag + _Wr * _Rightreal;
+
+ if (_Myctraits::_Isnan(_Wd) || _Wd == 0)
+ {
+ this->_Val[0] = _Myctraits::_Nanv(_Rightreal);
+ this->_Val[1] = this->_Val[0];
+ }
+ else
+ {
+ _Ty _Tmp = (this->_Val[0] * _Wr + this->_Val[1]) / _Wd;
+ this->_Val[1] = (this->_Val[1] * _Wr
+ - this->_Val[0]) / _Wd;
+ this->_Val[0] = _Tmp;
+ }
+ }
+ }
+ };
+
+
+template<> class complex<float>
+ : public _Complex_base<float, _Fcomplex_value>
+ {
+public:
+ typedef float _Ty;
+ typedef complex<_Ty> _Myt;
+
+ explicit complex(const complex<double>&);
+
+ explicit complex(const complex<long double>&);
+
+ complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
+ : _Complex_base<float, _Fcomplex_value>(_Realval, _Imagval)
+ {
+ }
+
+ complex(const _Fcomplex_value& _Right)
+ : _Complex_base<float, _Fcomplex_value>(_Right._Val[0],
+ _Right._Val[1])
+ {
+ }
+
+ complex<_Ty>& operator=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Right;
+ this->_Val[1] = 0;
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] + _Right;
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] - _Right;
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] * _Right;
+ this->_Val[1] = _Val[1] * _Right;
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] / _Right;
+ this->_Val[1] = _Val[1] / _Right;
+ return (*this);
+ }
+
+ _Myt& operator=(const _Myt& _Right)
+ {
+ this->_Val[0] = _Right.real();
+ this->_Val[1] = _Right.imag();
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Myt& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Myt& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Myt& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Myt& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator=(const complex<_Other>& _Right)
+ {
+ _Val[0] = (_Ty)_Right._Val[0];
+ _Val[1] = (_Ty)_Right._Val[1];
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator+=(const complex<_Other>& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator-=(const complex<_Other>& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator*=(const complex<_Other>& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator/=(const complex<_Other>& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+ };
+
+
+template<> class complex<double>
+ : public _Complex_base<double, _Dcomplex_value>
+ {
+public:
+ typedef double _Ty;
+ typedef complex<_Ty> _Myt;
+
+ complex(const complex<float>&);
+
+ explicit complex(const complex<long double>&);
+
+ complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
+ : _Complex_base<double, _Dcomplex_value>(_Realval, _Imagval)
+ {
+ }
+
+ complex(const _Dcomplex_value& _Right)
+ : _Complex_base<double, _Dcomplex_value>(_Right._Val[0],
+ _Right._Val[1])
+ {
+ }
+
+ complex<_Ty>& operator=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Right;
+ this->_Val[1] = 0;
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] + _Right;
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] - _Right;
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] * _Right;
+ this->_Val[1] = _Val[1] * _Right;
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] / _Right;
+ this->_Val[1] = _Val[1] / _Right;
+ return (*this);
+ }
+
+ _Myt& operator=(const _Myt& _Right)
+ {
+ this->_Val[0] = _Right.real();
+ this->_Val[1] = _Right.imag();
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Myt& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Myt& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Myt& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Myt& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator=(const complex<_Other>& _Right)
+ {
+ _Val[0] = (_Ty)_Right._Val[0];
+ _Val[1] = (_Ty)_Right._Val[1];
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator+=(const complex<_Other>& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator-=(const complex<_Other>& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator*=(const complex<_Other>& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator/=(const complex<_Other>& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+ };
+
+
+template<> class complex<long double>
+ : public _Complex_base<long double, _Lcomplex_value>
+ {
+public:
+ typedef long double _Ty;
+ typedef complex<_Ty> _Myt;
+
+ complex(const complex<float>&);
+
+ complex(const complex<double>&);
+
+ complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
+ : _Complex_base<long double, _Lcomplex_value>(_Realval, _Imagval)
+ {
+ }
+
+ complex(const _Lcomplex_value& _Right)
+ : _Complex_base<long double, _Lcomplex_value>(_Right._Val[0],
+ _Right._Val[1])
+ {
+ }
+
+ complex<_Ty>& operator=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Right;
+ this->_Val[1] = 0;
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] + _Right;
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] - _Right;
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] * _Right;
+ this->_Val[1] = _Val[1] * _Right;
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Val[0] / _Right;
+ this->_Val[1] = _Val[1] / _Right;
+ return (*this);
+ }
+
+ _Myt& operator=(const _Myt& _Right)
+ {
+ this->_Val[0] = _Right.real();
+ this->_Val[1] = _Right.imag();
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Myt& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Myt& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Myt& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Myt& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator=(const complex<_Other>& _Right)
+ {
+ _Val[0] = (_Ty)_Right._Val[0];
+ _Val[1] = (_Ty)_Right._Val[1];
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator+=(const complex<_Other>& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator-=(const complex<_Other>& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator*=(const complex<_Other>& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator/=(const complex<_Other>& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+ };
+
+
+inline
+ complex<float>::complex(const complex<double>& _Right)
+ : _Complex_base<float, _Fcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+inline
+ complex<float>::complex(const complex<long double>& _Right)
+ : _Complex_base<float, _Fcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+inline
+ complex<double>::complex(const complex<float>& _Right)
+ : _Complex_base<double, _Dcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+inline
+ complex<double>::complex(const complex<long double>& _Right)
+ : _Complex_base<double, _Dcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+inline
+ complex<long double>::complex(const complex<float>& _Right)
+ : _Complex_base<long double, _Lcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+inline
+ complex<long double>::complex(const complex<double>& _Right)
+ : _Complex_base<long double, _Lcomplex_value>(
+ (_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+
+template<class _Ty>
+ class complex
+ : public _Complex_base<_Ty, _Complex_value<_Ty> >
+ {
+public:
+ typedef complex<_Ty> _Myt;
+ typedef _Complex_base<_Ty, _Complex_value<_Ty> > _Mybase;
+
+ complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
+ : _Mybase(_Realval, _Imagval)
+ {
+ }
+
+ _Myt& operator=(const _Ty& _Right)
+ {
+ this->_Val[0] = _Right;
+ this->_Val[1] = 0;
+ return (*this);
+ }
+
+ template<class _Other>
+ complex(const complex<_Other>& _Right)
+ : _Mybase((_Ty)_Right.real(), (_Ty)_Right.imag())
+ {
+ }
+
+ template<class _Other>
+ _Myt& operator=(const complex<_Other>& _Right)
+ {
+ this->_Val[0] = (_Ty)_Right.real();
+ this->_Val[1] = (_Ty)_Right.imag();
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Ty& _Right)
+ {
+ this->_Val[0] = this->_Val[0] + _Right;
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Ty& _Right)
+ {
+ this->_Val[0] = this->_Val[0] - _Right;
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Ty& _Right)
+ {
+ this->_Val[0] = this->_Val[0] * _Right;
+ this->_Val[1] = this->_Val[1] * _Right;
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Ty& _Right)
+ {
+ this->_Val[0] = this->_Val[0] / _Right;
+ this->_Val[1] = this->_Val[1] / _Right;
+ return (*this);
+ }
+
+ _Myt& operator+=(const _Myt& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ _Myt& operator-=(const _Myt& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ _Myt& operator*=(const _Myt& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ _Myt& operator/=(const _Myt& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator+=(const complex<_Other>& _Right)
+ {
+ this->_Add(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator-=(const complex<_Other>& _Right)
+ {
+ this->_Sub(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator*=(const complex<_Other>& _Right)
+ {
+ this->_Mul(_Right);
+ return (*this);
+ }
+
+ template<class _Other> inline
+ _Myt& operator/=(const complex<_Other>& _Right)
+ {
+ this->_Div(_Right);
+ return (*this);
+ }
+ };
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+template<class _Ty > inline
+ _Ty __cdecl imag(const complex<_Ty >& _Left)
+ {
+ return (_Left.imag());
+ }
+
+
+template<class _Ty > inline
+ _Ty __cdecl real(const complex<_Ty >& _Left)
+ {
+ return (_Left.real());
+ }
+
+
+template<class _Ty > inline
+ _Ty __cdecl _Fabs(const complex<_Ty >& _Left, int *_Pexp)
+ {
+ *_Pexp = 0;
+ _Ty _Av = real(_Left);
+ _Ty _Bv = imag(_Left);
+
+ if (_Ctraits<_Ty >::_Isinf(_Av) || _Ctraits<_Ty >::_Isinf(_Bv))
+ return (_Ctraits<_Ty >::_Infv(_Bv));
+ else if (_Ctraits<_Ty >::_Isnan(_Av))
+ return (_Av);
+ else if (_Ctraits<_Ty >::_Isnan(_Bv))
+ return (_Bv);
+ else
+ {
+ if (_Av < 0)
+ _Av = -_Av;
+ if (_Bv < 0)
+ _Bv = -_Bv;
+ if (_Av < _Bv)
+ {
+ _Ty _Tmp = _Av;
+ _Av = _Bv;
+ _Bv = _Tmp;
+ }
+
+ if (_Av == 0)
+ return (_Av);
+ if (1 <= _Av)
+ *_Pexp = 2, _Av = _Av * (_Ty)0.25, _Bv = _Bv * (_Ty)0.25;
+ else
+ *_Pexp = -2, _Av = _Av * 4, _Bv = _Bv * 4;
+
+ _Ty _Tmp = _Av - _Bv;
+ if (_Tmp == _Av)
+ return (_Av);
+ else if (_Bv < _Tmp)
+ {
+ const _Ty _Qv = _Av / _Bv;
+ return (_Av + _Bv / (_Qv + _Ctraits<_Ty >::sqrt(_Qv * _Qv + 1)));
+ }
+ else
+ {
+ static const _Ty _Root2 =
+ (_Ty)1.4142135623730950488016887242096981L;
+ static const _Ty _Oneplusroot2high =
+ (_Ty)(10125945.0 / 4194304.0);
+ static const _Ty _Oneplusroot2low =
+ (_Ty)1.4341252375973918872420969807856967e-7L;
+
+ const _Ty _Qv = _Tmp / _Bv;
+ const _Ty _Rv = (_Qv + 2) * _Qv;
+ const _Ty _Sv = _Rv / (_Root2 + _Ctraits<_Ty >::sqrt(_Rv + 2))
+ + _Oneplusroot2low + _Qv + _Oneplusroot2high;
+ return (_Av + _Bv / _Sv);
+ }
+ }
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator+(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp += _Right);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator+(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ _Tmp.real(_Tmp.real() + _Right);
+ return (_Tmp);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator+(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp += _Right);
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator-(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp -= _Right);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator-(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ _Tmp.real(_Tmp.real() - _Right);
+ return (_Tmp);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator-(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp -= _Right);
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator*(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp *= _Right);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator*(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ _Tmp.real(_Tmp.real() * _Right);
+ _Tmp.imag(_Tmp.imag() * _Right);
+ return (_Tmp);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator*(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp *= _Right);
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator/(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp /= _Right);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator/(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ _Tmp.real(_Tmp.real() / _Right);
+ _Tmp.imag(_Tmp.imag() / _Right);
+ return (_Tmp);
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator/(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ complex<_Ty > _Tmp(_Left);
+ return (_Tmp /= _Right);
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator+(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(_Left));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl operator-(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(-real(_Left), -imag(_Left)));
+ }
+
+
+template<class _Ty > inline
+ bool __cdecl operator==(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ return (real(_Left) == real(_Right) && imag(_Left) == imag(_Right));
+ }
+
+template<class _Ty > inline
+ bool __cdecl operator==(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ return (real(_Left) == _Right && imag(_Left) == 0);
+ }
+
+template<class _Ty > inline
+ bool __cdecl operator==(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ return (_Left == real(_Right) && 0 == imag(_Right));
+ }
+
+
+template<class _Ty > inline
+ bool __cdecl operator!=(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Ty > inline
+ bool __cdecl operator!=(const complex<_Ty >& _Left,
+ const _Ty& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Ty > inline
+ bool __cdecl operator!=(const _Ty& _Left,
+ const complex<_Ty >& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+
+template<class _Ty > inline
+ _Ty __cdecl abs(const complex<_Ty >& _Left)
+ {
+ int _Leftexp;
+ _Ty _Rho = _Fabs(_Left, &_Leftexp);
+
+ if (_Leftexp == 0)
+ return (_Rho);
+ else
+ return (_Ctraits<_Ty >::ldexp(_Rho, _Leftexp));
+ }
+
+
+template<class _Ty > inline
+ _Ty __cdecl arg(const complex<_Ty >& _Left)
+ {
+ return (_Ctraits<_Ty >::atan2(imag(_Left), real(_Left)));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl conj(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(real(_Left), -imag(_Left)));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl cos(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(
+ _Ctraits<_Ty >::_Cosh(imag(_Left), _Ctraits<_Ty >::cos(real(_Left))),
+ -_Ctraits<_Ty >::_Sinh(imag(_Left),
+ _Ctraits<_Ty >::sin(real(_Left)))));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl cosh(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(
+ _Ctraits<_Ty >::_Cosh(real(_Left), _Ctraits<_Ty >::cos(imag(_Left))),
+ _Ctraits<_Ty >::_Sinh(real(_Left), _Ctraits<_Ty >::sin(imag(_Left)))));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl exp(const complex<_Ty >& _Left)
+ {
+ _Ty _Real(real(_Left)), _Imag(real(_Left));
+ _Ctraits<_Ty >::_Exp(&_Real, _Ctraits<_Ty >::cos(imag(_Left)), 0);
+ _Ctraits<_Ty >::_Exp(&_Imag, _Ctraits<_Ty >::sin(imag(_Left)), 0);
+ return (complex<_Ty >(_Real, _Imag));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl log(const complex<_Ty >& _Left)
+ {
+ _Ty _Theta = _Ctraits<_Ty >::atan2(imag(_Left), real(_Left));
+
+ if (_Ctraits<_Ty >::_Isnan(_Theta))
+ return (complex<_Ty >(_Theta, _Theta));
+ else
+ {
+ static const _Ty _Cm = (_Ty)(22713.0L / 32768.0L);
+ static const _Ty _Cl =
+ (_Ty)1.4286068203094172321214581765680755e-6L;
+ int _Leftexp;
+ _Ty _Rho = _Fabs(_Left, &_Leftexp);
+
+ _Ty _Leftn = (_Ty)_Leftexp;
+ complex<_Ty > _Tmp(
+ _Rho == 0 ? -_Ctraits<_Ty >::_Infv(_Rho)
+ : _Ctraits<_Ty >::_Isinf(_Rho) ? _Rho
+ : _Ctraits<_Ty >::log(_Rho) + _Leftn * _Cl + _Leftn * _Cm,
+ _Theta);
+ return (_Tmp);
+ }
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl log10(const complex<_Ty >& _Left)
+ {
+ return (log(_Left) * (_Ty)0.43429448190325182765112891891660508L);
+ }
+
+
+template<class _Ty > inline
+ _Ty __cdecl norm(const complex<_Ty >& _Left)
+ {
+ return (real(_Left) * real(_Left) + imag(_Left) * imag(_Left));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl polar(const _Ty& _Rho, const _Ty& _Theta)
+ {
+ return (complex<_Ty >(_Rho * _Ctraits<_Ty >::cos(_Theta),
+ _Rho * _Ctraits<_Ty >::sin(_Theta)));
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl polar(const _Ty& _Rho)
+ {
+ return (complex<_Ty >(_Rho, (_Ty)0));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl pow(const complex<_Ty >& _Left, const _Ty& _Right)
+ {
+ if (imag(_Left) == 0 && 0 < real(_Left))
+ return (complex<_Ty >(_Ctraits<_Ty >::pow(real(_Left), _Right)));
+ else
+ return (exp(_Right * log(_Left)));
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl pow(const complex<_Ty >& _Left, int _Right)
+ {
+ complex<_Ty > _Tmp = _Left;
+ unsigned int _Count = _Right;
+
+ if (_Right < 0)
+ _Count = 0 - _Count;
+
+ for (complex<_Ty > _Zv = complex<_Ty >(1); ; _Tmp *= _Tmp)
+ {
+ if ((_Count & 1) != 0)
+ _Zv *= _Tmp;
+ if ((_Count >>= 1) == 0)
+ return (_Right < 0 ? complex<_Ty >(1) / _Zv : _Zv);
+ }
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl pow(const _Ty& _Left, const complex<_Ty >& _Right)
+ {
+ if (imag(_Right) == 0)
+ return (complex<_Ty >(_Ctraits<_Ty >::pow(_Left, real(_Right))));
+ else if (0 < _Left)
+ return (exp(_Right * _Ctraits<_Ty >::log(_Left)));
+ else
+ return (exp(_Right * log(complex<_Ty >(_Left))));
+ }
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl pow(const complex<_Ty >& _Left,
+ const complex<_Ty >& _Right)
+ {
+ if (imag(_Right) == 0)
+ return (pow(_Left, real(_Right)));
+ else if (imag(_Left) == 0)
+ return (complex<_Ty >(pow(real(_Left), _Right)));
+ else
+ return (exp(_Right * log(_Left)));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl sin(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(
+ _Ctraits<_Ty >::_Cosh(imag(_Left), _Ctraits<_Ty >::sin(real(_Left))),
+ _Ctraits<_Ty >::_Sinh(imag(_Left), _Ctraits<_Ty >::cos(real(_Left)))));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl sinh(const complex<_Ty >& _Left)
+ {
+ return (complex<_Ty >(
+ _Ctraits<_Ty >::_Sinh(real(_Left), _Ctraits<_Ty >::cos(imag(_Left))),
+ _Ctraits<_Ty >::_Cosh(real(_Left), _Ctraits<_Ty >::sin(imag(_Left)))));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl sqrt(const complex<_Ty >& _Left)
+ {
+ int _Leftexp;
+ _Ty _Rho = _Fabs(_Left, &_Leftexp);
+
+ if (_Leftexp == 0)
+ return (complex<_Ty >(_Rho, _Rho));
+ else
+ {
+ _Ty _Realmag = _Ctraits<_Ty >::ldexp(real(_Left) < 0
+ ? - real(_Left) : real(_Left), -_Leftexp);
+ _Rho = _Ctraits<_Ty >::ldexp(_Ctraits<_Ty >::sqrt(
+ 2 * (_Realmag + _Rho)), _Leftexp / 2 - 1);
+
+ if (0 <= real(_Left))
+ return (complex<_Ty >(_Rho, imag(_Left) / (2 * _Rho)));
+ else if (imag(_Left) < 0)
+ return (complex<_Ty >(-imag(_Left) / (2 * _Rho), -_Rho));
+ else
+ return (complex<_Ty >(imag(_Left) / (2 * _Rho), _Rho));
+ }
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl tanh(const complex<_Ty >& _Left)
+ {
+ _Ty _Tv = _Ctraits<_Ty >::tan(imag(_Left));
+ _Ty _Sv = _Ctraits<_Ty >::_Sinh(real(_Left), (_Ty)(1));
+ _Ty _Bv = _Sv *((_Ty)(1) + _Tv * _Tv);
+ _Ty _Dv = (_Ty)(1) + _Bv * _Sv;
+ return (complex<_Ty >((_Ctraits<_Ty >::sqrt((_Ty)(1) + _Sv * _Sv))
+ * _Bv / _Dv, _Tv / _Dv));
+ }
+
+
+template<class _Ty > inline
+ complex<_Ty > __cdecl tan(const complex<_Ty >& _Left)
+ {
+ complex<_Ty > _Zv(tanh(complex<_Ty >(-imag(_Left), real(_Left))));
+ return (complex<_Ty >(imag(_Zv), -real(_Zv)));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _Ty,
+ class _Elem,
+ class _Tr> inline
+ basic_istream<_Elem, _Tr>& __cdecl operator>>(
+ basic_istream<_Elem, _Tr>& _Istr, complex<_Ty>& _Right)
+ {
+ typedef complex<_Ty> _Myt;
+ const ctype<_Elem>& _Ctype_fac = use_facet<ctype<_Elem> >(_Istr.getloc());
+ _Elem _Ch;
+ long double _Real, _Imag = 0;
+
+ if (_Istr >> _Ch && _Ch != _Ctype_fac.widen('('))
+ {
+ _Istr.putback(_Ch);
+ _Istr >> _Real;
+ _Imag = 0;
+ }
+ else if (_Istr >> _Real >> _Ch && _Ch != _Ctype_fac.widen(','))
+ if (_Ch == _Ctype_fac.widen(')'))
+ _Imag = 0;
+ else
+ {
+ _Istr.putback(_Ch);
+ _Istr.setstate(ios_base::failbit);
+ }
+ else if (_Istr >> _Imag >> _Ch && _Ch != _Ctype_fac.widen(')'))
+ {
+ _Istr.putback(_Ch);
+ _Istr.setstate(ios_base::failbit);
+ }
+
+ if (!_Istr.fail())
+ {
+ _Ty _Tyreal((_Ty)_Real), _Tyimag((_Ty)_Imag);
+ _Right = _Myt(_Tyreal, _Tyimag);
+ }
+ return (_Istr);
+ }
+
+
+template<class _Ty,
+ class _Elem,
+ class _Tr> inline
+ basic_ostream<_Elem, _Tr>& __cdecl operator<<(
+ basic_ostream<_Elem, _Tr>& _Ostr, const complex<_Ty>& _Right)
+ {
+ const ctype<_Elem>& _Ctype_fac = use_facet<ctype<_Elem> >(_Ostr.getloc());
+ basic_ostringstream<_Elem, _Tr, allocator<_Elem> > _Sstr;
+
+ _Sstr.flags(_Ostr.flags());
+ _Sstr.imbue(_Ostr.getloc());
+ _Sstr.precision(_Ostr.precision());
+ _Sstr << _Ctype_fac.widen('(') << real(_Right)
+ << _Ctype_fac.widen(',') << imag(_Right)
+ << _Ctype_fac.widen(')');
+
+ basic_string<_Elem, _Tr, allocator<_Elem> > _Str = _Sstr.str();
+ return (_Ostr << _Str.c_str());
+ }
+
+
+
+
+}
+
+
+ #pragma warning(default: 4244)
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace detail{
+
+struct is_convertible_from_tester
+{
+ template <class T>
+ is_convertible_from_tester(const std::complex<T>&);
+};
+
+}
+
+template< typename T > struct is_complex : ::boost::integral_constant<bool,(::boost::is_convertible<T, boost::detail::is_convertible_from_tester>::value)> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_fundamental_impl
+ : ::boost::type_traits::ice_or<
+ ::boost::is_arithmetic<T>::value
+ , ::boost::is_void<T>::value
+ >
+{
+};
+
+}
+
+
+
+
+
+template< typename T > struct is_fundamental : ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+namespace detail {
+
+template <typename T>
+struct is_compound_impl
+{
+ static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value);
+};
+
+}
+
+
+
+
+
+template< typename T > struct is_compound : ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+#pragma warning(push)
+#pragma warning(disable:4624)
+
+
+template <typename T>
+struct empty_helper_t1 : public T
+{
+ empty_helper_t1();
+ int i[256];
+private:
+
+ empty_helper_t1(const empty_helper_t1&);
+ empty_helper_t1& operator=(const empty_helper_t1&);
+};
+
+
+#pragma warning(pop)
+
+
+struct empty_helper_t2 { int i[256]; };
+
+
+
+template <typename T, bool is_a_class = false>
+struct empty_helper
+{
+ static const bool value = false;
+};
+
+template <typename T>
+struct empty_helper<T, true>
+{
+ static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));
+};
+
+template <typename T>
+struct is_empty_impl
+{
+ typedef typename remove_cv<T>::type cvt;
+ static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , __is_empty(cvt) >::value );
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct is_empty_impl< void > { static const bool value = (false); };
+
+template<> struct is_empty_impl< void const > { static const bool value = (false); };
+template<> struct is_empty_impl< void volatile > { static const bool value = (false); };
+template<> struct is_empty_impl< void const volatile > { static const bool value = (false); };
+
+
+}
+
+template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+template< typename T > struct is_floating_point : ::boost::integral_constant<bool,false> { };
+template<> struct is_floating_point< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_floating_point< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_floating_point< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const volatile > : ::boost::integral_constant<bool,true> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+
+template <typename T>
+struct is_member_object_pointer_impl
+{
+ static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value );
+};
+
+}
+
+template< typename T > struct is_member_object_pointer : ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_object_impl
+{
+
+ static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value);
+
+
+
+
+
+
+
+};
+
+}
+
+template< typename T > struct is_object : ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost{
+
+
+
+namespace detail{
+
+template <class T>
+struct is_polymorphic_imp1
+{
+
+
+
+ typedef typename remove_cv<T>::type ncvT;
+ struct d1 : public ncvT
+ {
+ d1();
+
+ ~d1()throw();
+
+ char padding[256];
+ private:
+
+ d1(const d1&);
+ d1& operator=(const d1&);
+ };
+ struct d2 : public ncvT
+ {
+ d2();
+ virtual ~d2()throw();
+
+
+
+
+
+
+ char padding[256];
+ private:
+
+ d2(const d2&);
+ d2& operator=(const d2&);
+ };
+
+ static const bool value = (sizeof(d2) == sizeof(d1));
+};
+
+template <class T>
+struct is_polymorphic_imp2
+{
+ static const bool value = false;
+};
+
+template <bool is_class>
+struct is_polymorphic_selector
+{
+ template <class T>
+ struct rebind
+ {
+ typedef is_polymorphic_imp2<T> type;
+ };
+};
+
+template <>
+struct is_polymorphic_selector<true>
+{
+ template <class T>
+ struct rebind
+ {
+ typedef is_polymorphic_imp1<T> type;
+ };
+};
+
+template <class T>
+struct is_polymorphic_imp
+{
+ typedef is_polymorphic_selector< ::boost::is_class<T>::value> selector;
+ typedef typename selector::template rebind<T> binder;
+ typedef typename binder::type imp_type;
+ static const bool value = imp_type::value;
+};
+
+}
+
+template< typename T > struct is_polymorphic : ::boost::integral_constant<bool,::boost::detail::is_polymorphic_imp<T>::value> { };
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail{
+
+
+
+template <class T>
+struct is_signed_values
+{
+
+
+
+
+
+ typedef typename remove_cv<T>::type no_cv_t;
+ static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+ static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+
+template <class T>
+struct is_signed_helper
+{
+ typedef typename remove_cv<T>::type no_cv_t;
+ static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
+};
+
+template <bool integral_type>
+struct is_signed_select_helper
+{
+ template <class T>
+ struct rebind
+ {
+ typedef is_signed_helper<T> type;
+ };
+};
+
+template <>
+struct is_signed_select_helper<false>
+{
+ template <class T>
+ struct rebind
+ {
+ typedef false_type type;
+ };
+};
+
+template <class T>
+struct is_signed_imp
+{
+ typedef is_signed_select_helper<
+ ::boost::type_traits::ice_or<
+ ::boost::is_integral<T>::value,
+ ::boost::is_enum<T>::value>::value
+ > selector;
+ typedef typename selector::template rebind<T> binder;
+ typedef typename binder::type type;
+
+
+
+ static const bool value = type::value;
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+template< typename T > struct is_signed : ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_stateless_impl
+{
+ static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value);
+};
+
+}
+
+template< typename T > struct is_stateless : ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <typename T> struct is_union_impl
+{
+ typedef typename remove_cv<T>::type cvt;
+ static const bool value = __is_union(cvt);
+};
+
+
+
+
+
+
+
+
+
+
+
+}
+
+template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail{
+
+
+
+template <class T>
+struct is_unsigned_values
+{
+
+
+
+
+
+ typedef typename remove_cv<T>::type no_cv_t;
+ static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+ static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+
+template <class T>
+struct is_ununsigned_helper
+{
+ static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
+};
+
+template <bool integral_type>
+struct is_ununsigned_select_helper
+{
+ template <class T>
+ struct rebind
+ {
+ typedef is_ununsigned_helper<T> type;
+ };
+};
+
+template <>
+struct is_ununsigned_select_helper<false>
+{
+ template <class T>
+ struct rebind
+ {
+ typedef false_type type;
+ };
+};
+
+template <class T>
+struct is_unsigned_imp
+{
+ typedef is_ununsigned_select_helper<
+ ::boost::type_traits::ice_or<
+ ::boost::is_integral<T>::value,
+ ::boost::is_enum<T>::value>::value
+ > selector;
+ typedef typename selector::template rebind<T> binder;
+ typedef typename binder::type type;
+ static const bool value = type::value;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+template< typename T > struct is_unsigned : ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct and_impl
+ : false_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct and_impl< true,T1,T2,T3,T4 >
+ : and_impl<
+ T1::type::value
+ , T2, T3, T4
+ , true_
+ >
+{
+};
+
+template<>
+struct and_impl<
+ true
+ , true_, true_, true_, true_
+ >
+ : true_
+{
+};
+
+}
+
+template<
+ typename T1 = na
+ , typename T2 = na
+ , typename T3 = true_, typename T4 = true_, typename T5 = true_
+ >
+struct and_
+
+ : aux::and_impl<
+ T1::type::value
+ , T2, T3, T4, T5
+ >
+
+{
+};
+
+template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< long C_ >
+struct not_impl
+ : bool_<!C_>
+{
+};
+
+}
+
+
+template<
+ typename T = na
+ >
+struct not_
+ : aux::not_impl<
+ T::type::value
+ >
+{
+
+};
+
+template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; };
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+namespace detail {
+
+
+
+#pragma warning( push )
+#pragma warning( disable : 4584 )
+
+
+
+
+template<typename Base, typename Derived, typename tag>
+struct is_virtual_base_of_impl
+{
+ static const bool value = false;
+};
+
+template<typename Base, typename Derived>
+struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
+{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ struct boost_type_traits_internal_struct_X : Derived, virtual Base
+ {
+ boost_type_traits_internal_struct_X();
+ boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+ boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+ ~boost_type_traits_internal_struct_X()throw();
+ };
+ struct boost_type_traits_internal_struct_Y : Derived
+ {
+ boost_type_traits_internal_struct_Y();
+ boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+ boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+ ~boost_type_traits_internal_struct_Y()throw();
+ };
+
+ static const bool value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y));
+};
+
+template<typename Base, typename Derived>
+struct is_virtual_base_of_impl2
+{
+ typedef typename mpl::and_<is_base_of<Base, Derived>, mpl::not_<is_same<Base, Derived> > >::type tag_type;
+ typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
+ static const bool value = imp::value;
+};
+
+
+#pragma warning( pop )
+
+
+}
+
+template< typename Base, typename Derived > struct is_virtual_base_of : ::boost::integral_constant<bool,(::boost::detail::is_virtual_base_of_impl2<Base,Derived>::value)> { };
+
+
+template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_virtual_base_of< Base,Derived& > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived& > : ::boost::integral_constant<bool,false> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <class T>
+struct make_unsigned_imp
+{
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) >)> boost_static_assert_typedef_5;
+
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) >)> boost_static_assert_typedef_6;
+
+
+ typedef typename remove_cv<T>::type t_no_cv;
+ typedef typename mpl::if_c<
+ (::boost::type_traits::ice_and<
+ ::boost::is_unsigned<T>::value,
+ ::boost::is_integral<T>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+ T,
+ typename mpl::if_c<
+ (::boost::type_traits::ice_and<
+ ::boost::is_integral<T>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+ ::value),
+ typename mpl::if_<
+ is_same<t_no_cv, signed char>,
+ unsigned char,
+ typename mpl::if_<
+ is_same<t_no_cv, short>,
+ unsigned short,
+ typename mpl::if_<
+ is_same<t_no_cv, int>,
+ unsigned int,
+ typename mpl::if_<
+ is_same<t_no_cv, long>,
+ unsigned long,
+
+ boost::ulong_long_type
+
+
+
+
+
+ >::type
+ >::type
+ >::type
+ >::type,
+
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned char),
+ unsigned char,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned short),
+ unsigned short,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned int),
+ unsigned int,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned long),
+ unsigned long,
+
+ boost::ulong_long_type
+
+
+
+
+
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type base_integer_type;
+
+
+ typedef typename mpl::if_<
+ is_const<T>,
+ typename add_const<base_integer_type>::type,
+ base_integer_type
+ >::type const_base_integer_type;
+
+
+ typedef typename mpl::if_<
+ is_volatile<T>,
+ typename add_volatile<const_base_integer_type>::type,
+ const_base_integer_type
+ >::type type;
+};
+
+
+}
+
+template< typename T > struct make_unsigned { typedef typename boost::detail::make_unsigned_imp<T>::type type; };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template <class T>
+struct make_signed_imp
+{
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) >)> boost_static_assert_typedef_7;
+
+ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) >)> boost_static_assert_typedef_8;
+
+
+ typedef typename remove_cv<T>::type t_no_cv;
+ typedef typename mpl::if_c<
+ (::boost::type_traits::ice_and<
+ ::boost::is_signed<T>::value,
+ ::boost::is_integral<T>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+ T,
+ typename mpl::if_c<
+ (::boost::type_traits::ice_and<
+ ::boost::is_integral<T>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+ ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+ ::value),
+ typename mpl::if_<
+ is_same<t_no_cv, unsigned char>,
+ signed char,
+ typename mpl::if_<
+ is_same<t_no_cv, unsigned short>,
+ signed short,
+ typename mpl::if_<
+ is_same<t_no_cv, unsigned int>,
+ int,
+ typename mpl::if_<
+ is_same<t_no_cv, unsigned long>,
+ long,
+
+ boost::long_long_type
+
+
+
+
+
+ >::type
+ >::type
+ >::type
+ >::type,
+
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned char),
+ signed char,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned short),
+ signed short,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned int),
+ int,
+ typename mpl::if_c<
+ sizeof(t_no_cv) == sizeof(unsigned long),
+ long,
+
+ boost::long_long_type
+
+
+
+
+
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type base_integer_type;
+
+
+ typedef typename mpl::if_<
+ is_const<T>,
+ typename add_const<base_integer_type>::type,
+ base_integer_type
+ >::type const_base_integer_type;
+
+
+ typedef typename mpl::if_<
+ is_volatile<T>,
+ typename add_volatile<const_base_integer_type>::type,
+ const_base_integer_type
+ >::type type;
+};
+
+
+}
+
+template< typename T > struct make_signed { typedef typename boost::detail::make_signed_imp<T>::type type; };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail{
+
+template <class T, std::size_t N>
+struct rank_imp
+{
+ static const std::size_t value = N;
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T[R], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T const[R], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T volatile[R], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T const volatile[R], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+
+template <class T, std::size_t N>
+struct rank_imp<T[], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T const[], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T volatile[], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T const volatile[], N>
+{
+ static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+
+}
+
+
+
+
+
+
+template< typename T > struct rank : ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { };
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct remove_extent { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_extent<T[N]> { typedef T type; };
+template< typename T, std::size_t N > struct remove_extent<T const[N]> { typedef T const type; };
+template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { typedef T volatile type; };
+template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { typedef T const volatile type; };
+
+template< typename T > struct remove_extent<T[]> { typedef T type; };
+template< typename T > struct remove_extent<T const[]> { typedef T const type; };
+template< typename T > struct remove_extent<T volatile[]> { typedef T volatile type; };
+template< typename T > struct remove_extent<T const volatile[]> { typedef T const volatile type; };
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+template< typename T > struct remove_all_extents { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_all_extents<T[N]> { typedef typename boost::remove_all_extents<T>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { typedef typename boost::remove_all_extents<T const>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };
+
+template< typename T > struct remove_all_extents<T[]> { typedef typename boost::remove_all_extents<T>::type type; };
+template< typename T > struct remove_all_extents<T const[]> { typedef typename boost::remove_all_extents<T const>::type type; };
+template< typename T > struct remove_all_extents<T volatile[]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
+template< typename T > struct remove_all_extents<T const volatile[]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+template <typename T, bool is_vol>
+struct remove_const_helper
+{
+ typedef T type;
+};
+
+template <typename T>
+struct remove_const_helper<T, true>
+{
+ typedef T volatile type;
+};
+
+
+template <typename T>
+struct remove_const_impl
+{
+ typedef typename remove_const_helper<
+ typename cv_traits_imp<T*>::unqualified_type
+ , ::boost::is_volatile<T>::value
+ >::type type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+template< typename T > struct remove_const { typedef typename boost::detail::remove_const_impl<T>::type type; };
+template< typename T > struct remove_const<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+template< typename T > struct remove_pointer { typedef T type; };
+template< typename T > struct remove_pointer<T*> { typedef T type; };
+template< typename T > struct remove_pointer<T* const> { typedef T type; };
+template< typename T > struct remove_pointer<T* volatile> { typedef T type; };
+template< typename T > struct remove_pointer<T* const volatile> { typedef T type; };
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+template <typename T, bool is_const>
+struct remove_volatile_helper
+{
+ typedef T type;
+};
+
+template <typename T>
+struct remove_volatile_helper<T,true>
+{
+ typedef T const type;
+};
+
+template <typename T>
+struct remove_volatile_impl
+{
+ typedef typename remove_volatile_helper<
+ typename cv_traits_imp<T*>::unqualified_type
+ , ::boost::is_const<T>::value
+ >::type type;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+template< typename T > struct remove_volatile { typedef typename boost::detail::remove_volatile_impl<T>::type type; };
+template< typename T > struct remove_volatile<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { typedef T const type[N]; };
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace type_traits { namespace detail {
+
+
+template <class T> struct need_promotion : boost::is_enum<T> {};
+
+
+template<> struct need_promotion<char > : true_type {};
+template<> struct need_promotion<signed char > : true_type {};
+template<> struct need_promotion<unsigned char > : true_type {};
+template<> struct need_promotion<signed short int > : true_type {};
+template<> struct need_promotion<unsigned short int> : true_type {};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> struct need_promotion<boost::ulong_long_type> : integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
+template<> struct need_promotion<boost::long_long_type> : integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};
+
+
+
+
+
+
+
+
+
+
+template<> struct need_promotion<wchar_t> : true_type {};
+
+
+
+
+
+template<> struct need_promotion<bool> : true_type {};
+
+
+
+
+template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
+
+
+
+
+
+
+
+
+template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
+template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
+template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
+template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
+
+
+
+
+
+
+
+
+template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
+template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+char (&promoted_index_tester(int))[1];
+char (&promoted_index_tester(unsigned int))[2];
+char (&promoted_index_tester(long))[3];
+char (&promoted_index_tester(unsigned long))[4];
+
+
+char (&promoted_index_tester(boost::long_long_type))[5];
+char (&promoted_index_tester(boost::ulong_long_type))[6];
+
+
+
+
+
+
+
+
+
+
+template<class T>
+struct promoted_index
+{
+ static T testee;
+ static const int value = sizeof(promoted_index_tester(+testee));
+
+};
+
+template<class T>
+struct integral_promotion_impl
+{
+ typedef typename promote_from_index<
+ (boost::type_traits::detail::promoted_index<T>::value)
+ , (boost::is_const<T>::value)
+ , (boost::is_volatile<T>::value)
+ >::type type;
+};
+
+template<class T>
+struct integral_promotion
+ : boost::mpl::eval_if<
+ need_promotion<typename remove_cv<T>::type>
+ , integral_promotion_impl<T>
+ , boost::mpl::identity<T>
+ >
+{
+};
+
+} }
+
+template< typename T > struct integral_promotion { typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+template<class T>
+struct promote_impl
+ : integral_promotion<
+ typename floating_point_promotion<T>::type
+ >
+{
+};
+
+}
+
+template< typename T > struct promote { typedef typename boost::detail::promote_impl<T>::type type; };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local { namespace aux {
+
+template<typename F, unsigned int defaults_count = 0>
+struct function_base {};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+
+ >
+struct function_base<
+ R (),
+ 0> {
+
+ virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0>
+struct function_base<
+ R ( A0),
+ 0> {
+
+ virtual R operator()( A0) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0>
+struct function_base<
+ R ( A0),
+ 1> {
+
+ virtual R operator()( A0) = 0; virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+struct function_base<
+ R ( A0 , A1),
+ 0> {
+
+ virtual R operator()( A0 , A1) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+struct function_base<
+ R ( A0 , A1),
+ 1> {
+
+ virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+struct function_base<
+ R ( A0 , A1),
+ 2> {
+
+ virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0; virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+struct function_base<
+ R ( A0 , A1 , A2),
+ 0> {
+
+ virtual R operator()( A0 , A1 , A2) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+struct function_base<
+ R ( A0 , A1 , A2),
+ 1> {
+
+ virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+struct function_base<
+ R ( A0 , A1 , A2),
+ 2> {
+
+ virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+struct function_base<
+ R ( A0 , A1 , A2),
+ 3> {
+
+ virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0; virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+struct function_base<
+ R ( A0 , A1 , A2 , A3),
+ 0> {
+
+ virtual R operator()( A0 , A1 , A2 , A3) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+struct function_base<
+ R ( A0 , A1 , A2 , A3),
+ 1> {
+
+ virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+struct function_base<
+ R ( A0 , A1 , A2 , A3),
+ 2> {
+
+ virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+struct function_base<
+ R ( A0 , A1 , A2 , A3),
+ 3> {
+
+ virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+struct function_base<
+ R ( A0 , A1 , A2 , A3),
+ 4> {
+
+ virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0; virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 0> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 1> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0; virtual R operator()( A0 , A1 , A2 , A3) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 2> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0; virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 3> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0; virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 4> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0; virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+struct function_base<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 5> {
+
+ virtual R operator()( A0 , A1 , A2 , A3 , A4) = 0; virtual R operator()( A0 , A1 , A2 , A3) = 0; virtual R operator()( A0 , A1 , A2) = 0; virtual R operator()( A0 , A1) = 0; virtual R operator()( A0) = 0; virtual R operator()() = 0;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<typename F, size_t defaults = 0>
+struct function_ref {};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+
+ void __cdecl _wassert( const wchar_t * _Message, const wchar_t *_File, unsigned _Line);
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+
+ >
+class function_ref<
+ R (),
+ 0> {
+ typedef aux::function_base<
+ R (
+
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0>
+class function_ref<
+ R ( A0),
+ 0> {
+ typedef aux::function_base<
+ R (
+ A0
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0>
+class function_ref<
+ R ( A0),
+ 1> {
+ typedef aux::function_base<
+ R (
+ A0
+ )
+ , 1
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); } inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+class function_ref<
+ R ( A0 , A1),
+ 0> {
+ typedef aux::function_base<
+ R (
+ A0 , A1
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+class function_ref<
+ R ( A0 , A1),
+ 1> {
+ typedef aux::function_base<
+ R (
+ A0 , A1
+ )
+ , 1
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1>
+class function_ref<
+ R ( A0 , A1),
+ 2> {
+ typedef aux::function_base<
+ R (
+ A0 , A1
+ )
+ , 2
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); } inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+class function_ref<
+ R ( A0 , A1 , A2),
+ 0> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+class function_ref<
+ R ( A0 , A1 , A2),
+ 1> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2
+ )
+ , 1
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+class function_ref<
+ R ( A0 , A1 , A2),
+ 2> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2
+ )
+ , 2
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2>
+class function_ref<
+ R ( A0 , A1 , A2),
+ 3> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2
+ )
+ , 3
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); } inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+class function_ref<
+ R ( A0 , A1 , A2 , A3),
+ 0> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+class function_ref<
+ R ( A0 , A1 , A2 , A3),
+ 1> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3
+ )
+ , 1
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+class function_ref<
+ R ( A0 , A1 , A2 , A3),
+ 2> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3
+ )
+ , 2
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+class function_ref<
+ R ( A0 , A1 , A2 , A3),
+ 3> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3
+ )
+ , 3
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3>
+class function_ref<
+ R ( A0 , A1 , A2 , A3),
+ 4> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3
+ )
+ , 4
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); } inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 0> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 0
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 1> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 1
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); } inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 2> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 2
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); } inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 3> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 3
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); } inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 4> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 4
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); } inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace local {
+
+template<typename R
+ ,
+ typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+class function_ref<
+ R ( A0 , A1 , A2 , A3 , A4),
+ 5> {
+ typedef aux::function_base<
+ R (
+ A0 , A1 , A2 , A3 , A4
+ )
+ , 5
+ > base;
+
+public:
+ function_ref(): ptr_(0) {}
+ function_ref(base& ref): ptr_(&ref) {}
+
+ function_ref& operator=(base& ref) {
+ ptr_ = &ref;
+ return *this;
+ }
+
+
+
+
+ inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3 , a4); } inline R operator()( A0 a0 , A1 a1 , A2 a2 , A3 a3) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2 , a3); } inline R operator()( A0 a0 , A1 a1 , A2 a2) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1 , a2); } inline R operator()( A0 a0 , A1 a1) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0 , a1); } inline R operator()( A0 a0) { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref.hpp", 108), 0) ); return (*ptr_)( a0); } inline R operator()() { (void)( (!!(ptr_)) || (_wassert(L"ptr_", L"..\\..\\..\\boost/local/aux_/function_ref
.hpp", 108), 0) ); return (*ptr_)(); }
+
+private:
+ base* ptr_;
+};
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+typedef char (&no_tag)[1];
+typedef char (&yes_tag)[2];
+
+template< bool C_ > struct yes_no_tag
+{
+ typedef no_tag type;
+};
+
+template<> struct yes_no_tag<true>
+{
+ typedef yes_tag type;
+};
+
+
+template< long n > struct weighted_tag
+{
+
+ typedef char (&type)[n];
+
+
+
+
+};
+
+
+
+
+
+
+
+
+}}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+struct failed {};
+
+
+
+
+
+
+
+
+
+
+template< bool C > struct assert { typedef void* type; };
+template<> struct assert<false> { typedef assert type; };
+
+template< bool C >
+int assertion_failed( typename assert<C>::type );
+
+template< bool C >
+struct assertion
+{
+ static int failed( assert<false> );
+};
+
+template<>
+struct assertion<true>
+{
+ static int failed( void* );
+};
+
+struct assert_
+{
+
+ template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
+
+ static assert_ const arg;
+ enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
+};
+
+
+
+
+bool operator==( failed, failed );
+bool operator!=( failed, failed );
+bool operator>( failed, failed );
+bool operator>=( failed, failed );
+bool operator<( failed, failed );
+bool operator<=( failed, failed );
+
+
+
+
+
+template< long x, long y, bool (*)(failed, failed) >
+struct assert_relation {};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template< bool > struct assert_arg_pred_impl { typedef int type; };
+template<> struct assert_arg_pred_impl<true> { typedef void* type; };
+
+template< typename P > struct assert_arg_pred
+{
+ typedef typename P::type p_type;
+ typedef typename assert_arg_pred_impl< p_type::value >::type type;
+};
+
+template< typename P > struct assert_arg_pred_not
+{
+ typedef typename P::type p_type;
+ static const bool p = !p_type::value;
+ typedef typename assert_arg_pred_impl::type type;
+};
+
+template< typename Pred >
+failed ************ (Pred::************
+ assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
+ );
+
+template< typename Pred >
+failed ************ (boost::mpl::not_<Pred>::************
+ assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
+ );
+
+template< typename Pred >
+assert<false>
+assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
+
+template< typename Pred >
+assert<false>
+assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern boost::scope_exit::aux::undeclared
+ boost_local_auxXargs;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+namespace std {
+
+
+
+ extern istream *_Ptr_cin;
+ extern ostream *_Ptr_cout;
+ extern ostream *_Ptr_cerr;
+ extern ostream *_Ptr_clog;
+
+
+
+
+class _Winit {
+public:
+ __thiscall _Winit();
+ __thiscall ~_Winit();
+private:
+ static int _Init_cnt;
+ };
+
+
+
+
+ extern wistream *_Ptr_wcin;
+ extern wostream *_Ptr_wcout;
+ extern wostream *_Ptr_wcerr;
+ extern wostream *_Ptr_wclog;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ extern istream cin;
+ extern ostream cout;
+ extern ostream cerr;
+ extern ostream clog;
+
+ extern wistream wcin;
+ extern wostream wcout;
+ extern wostream wcerr;
+ extern wostream wclog;
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+template<class _Container>
+ class back_insert_iterator
+ : public _Outit
+ {
+public:
+ typedef _Container container_type;
+ typedef typename _Container::reference reference;
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+ explicit back_insert_iterator(_Container& _Cont)
+ : container(&_Cont)
+ {
+ }
+
+ back_insert_iterator<_Container>& operator=(
+ typename _Container::const_reference _Val)
+ {
+ container->push_back(_Val);
+ return (*this);
+ }
+
+ back_insert_iterator<_Container>& operator*()
+ {
+ return (*this);
+ }
+
+ back_insert_iterator<_Container>& operator++()
+ {
+ return (*this);
+ }
+
+ back_insert_iterator<_Container> operator++(int)
+ {
+ return (*this);
+ }
+
+protected:
+ _Container *container;
+ };
+
+
+template<class _Container> inline
+ back_insert_iterator<_Container> back_inserter(_Container& _Cont)
+ {
+ return (std::back_insert_iterator<_Container>(_Cont));
+ }
+
+
+template<class _Container>
+ class front_insert_iterator
+ : public _Outit
+ {
+public:
+ typedef _Container container_type;
+ typedef typename _Container::reference reference;
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+ explicit front_insert_iterator(_Container& _Cont)
+ : container(&_Cont)
+ {
+ }
+
+ front_insert_iterator<_Container>& operator=(
+ typename _Container::const_reference _Val)
+ {
+ container->push_front(_Val);
+ return (*this);
+ }
+
+ front_insert_iterator<_Container>& operator*()
+ {
+ return (*this);
+ }
+
+ front_insert_iterator<_Container>& operator++()
+ {
+ return (*this);
+ }
+
+ front_insert_iterator<_Container> operator++(int)
+ {
+ return (*this);
+ }
+
+protected:
+ _Container *container;
+ };
+
+
+template<class _Container> inline
+ front_insert_iterator<_Container> front_inserter(_Container& _Cont)
+ {
+ return (std::front_insert_iterator<_Container>(_Cont));
+ }
+
+
+template<class _Container>
+ class insert_iterator
+ : public _Outit
+ {
+public:
+ typedef _Container container_type;
+ typedef typename _Container::reference reference;
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+ insert_iterator(_Container& _Cont, typename _Container::iterator _Where)
+ : container(&_Cont), iter(_Where)
+ {
+ }
+
+ insert_iterator<_Container>& operator=(
+ typename _Container::const_reference _Val)
+ {
+ iter = container->insert(iter, _Val);
+ ++iter;
+ return (*this);
+ }
+
+ insert_iterator<_Container>& operator*()
+ {
+ return (*this);
+ }
+
+ insert_iterator<_Container>& operator++()
+ {
+ return (*this);
+ }
+
+ insert_iterator<_Container>& operator++(int)
+ {
+ return (*this);
+ }
+
+protected:
+ _Container *container;
+ typename _Container::iterator iter;
+ };
+
+
+template<class _Container,
+ class _Iter> inline
+ insert_iterator<_Container> inserter(_Container& _Cont, _Iter _Where)
+ {
+ return (std::insert_iterator<_Container>(_Cont, _Where));
+ }
+
+
+template<class _Ty,
+ class _Elem = char,
+ class _Traits = char_traits<_Elem>,
+ class _Diff = ptrdiff_t>
+ class istream_iterator
+ : public iterator<input_iterator_tag, _Ty, _Diff,
+ const _Ty *, const _Ty&>
+ {
+ typedef istream_iterator<_Ty, _Elem, _Traits, _Diff> _Myt;
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef basic_istream<_Elem, _Traits> istream_type;
+
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+ istream_iterator()
+ : _Myistr(0)
+ {
+ }
+
+ istream_iterator(istream_type& _Istr)
+ : _Myistr(&_Istr)
+ {
+ _Getval();
+ }
+
+ const _Ty& operator*() const
+ {
+
+
+
+
+
+
+
+
+ { if (!(_Myistr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myval);
+ }
+
+ const _Ty *operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+
+
+
+
+
+
+
+
+ { if (!(_Myistr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ _Getval();
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ bool _Equal(const _Myt& _Right) const
+ {
+ return (_Myistr == _Right._Myistr);
+ }
+
+protected:
+ void _Getval()
+ {
+ if (_Myistr != 0 && !(*_Myistr >> _Myval))
+ _Myistr = 0;
+ }
+
+ static void _Xran()
+ {
+ throw out_of_range("invalid istream_iterator");
+ }
+
+ istream_type *_Myistr;
+ _Ty _Myval;
+ };
+
+
+template<class _Ty,
+ class _Elem,
+ class _Traits,
+ class _Diff> inline
+ bool operator==(
+ const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
+ const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right)
+ {
+ return (_Left._Equal(_Right));
+ }
+
+template<class _Ty,
+ class _Elem,
+ class _Traits,
+ class _Diff> inline
+ bool operator!=(
+ const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
+ const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+
+template<class _Ty,
+ class _Elem = char,
+ class _Traits = char_traits<_Elem> >
+ class ostream_iterator
+ : public _Outit
+ {
+public:
+ typedef _Elem char_type;
+ typedef _Traits traits_type;
+ typedef basic_ostream<_Elem, _Traits> ostream_type;
+
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+ ostream_iterator(ostream_type& _Ostr,
+ const _Elem *_Delim = 0)
+ : _Myostr(&_Ostr), _Mydelim(_Delim)
+ {
+ }
+
+ ostream_iterator<_Ty, _Elem, _Traits>& operator=(const _Ty& _Val)
+ {
+ *_Myostr << _Val;
+ if (_Mydelim != 0)
+ *_Myostr << _Mydelim;
+
+
+
+
+
+
+
+
+ { if (!(*_Myostr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (*this);
+ }
+
+ ostream_iterator<_Ty, _Elem, _Traits>& operator*()
+ {
+ return (*this);
+ }
+
+ ostream_iterator<_Ty, _Elem, _Traits>& operator++()
+ {
+ return (*this);
+ }
+
+ ostream_iterator<_Ty, _Elem, _Traits> operator++(int)
+ {
+ return (*this);
+ }
+
+protected:
+ static void _Xran()
+ {
+ throw out_of_range("invalid ostream_iterator");
+ }
+
+ const _Elem *_Mydelim;
+ ostream_type *_Myostr;
+ };
+
+}
+
+namespace stdext {
+
+
+template <class _Cont, class _Iter = typename _Cont::iterator>
+ class checked_iterator
+ : public ::std:: iterator<
+ typename ::std:: iterator_traits<_Iter>::iterator_category,
+ typename ::std:: iterator_traits<_Iter>::value_type,
+ typename ::std:: iterator_traits<_Iter>::difference_type,
+ typename ::std:: iterator_traits<_Iter>::pointer,
+ typename ::std:: iterator_traits<_Iter>::reference>
+ {
+ friend class checked_iterator;
+public:
+ typedef checked_iterator<_Cont, _Iter> _Myt;
+ typedef typename ::std:: iterator_traits<_Iter>::difference_type difference_type;
+ typedef typename ::std:: iterator_traits<_Iter>::pointer pointer;
+ typedef typename ::std:: iterator_traits<_Iter>::reference reference;
+
+ typedef ::std:: _Range_checked_iterator_tag _Checked_iterator_category;
+ typedef _Iter _Inner_type;
+
+ typedef _Iter _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return _Current;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ _Current = _Base;
+ }
+
+
+
+ checked_iterator()
+ : _Mycont(0)
+ {
+ }
+
+ checked_iterator(_Cont& _C, _Iter _Ptr)
+ : _Mycont(&_C), _Current(_Ptr)
+ {
+ }
+
+ checked_iterator(const _Myt &_Right)
+ : _Mycont(_Right._Mycont), _Current(_Right._Current)
+ {
+ }
+
+ template <class Iter2>
+ checked_iterator(const checked_iterator<_Cont, Iter2> &_Right)
+ : _Mycont(_Right._Mycont), _Current(_Right._Current)
+ {
+ }
+
+ _Iter base() const
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current;
+ }
+
+ template <class Iter2>
+ bool operator==(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ { if (!(_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current == _Right._Current;
+ }
+
+ template <class Iter2>
+ bool operator!=(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return !(*this == _Right);
+ }
+
+ template <class Iter2>
+ bool operator<(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ { if (!(_Mycont != 0 && _Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current < _Right._Current;
+ }
+
+ template <class Iter2>
+ bool operator>(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ return _Right < *this;
+ }
+
+ template <class Iter2>
+ bool operator<=(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ return !(_Right < *this);
+ }
+
+ template <class Iter2>
+ bool operator>=(const checked_iterator<_Cont, Iter2>& _Right) const
+ {
+ return !(*this < _Right);
+ }
+
+ reference operator*() const
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ { if (!(_Current != _Mycont->end())) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return *_Current;
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ { if (!(_Current != _Mycont->end())) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ ++_Current;
+ return *this;
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return _Tmp;
+ }
+
+ _Myt& operator--()
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ { if (!(_Current != _Mycont->begin())) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ --_Current;
+ return *this;
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ --*this;
+ return _Tmp;
+ }
+
+
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ { if (!((_Mycont->end() - _Current) >= _Off && (_Mycont->begin() - _Current) <= _Off)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ _Current += _Off;
+ return *this;
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Myt& _Right) const
+ {
+ { if (!(_Mycont != 0 && _Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current - _Right._Current;
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ { if (!(_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ { if (!((_Mycont->end() - _Current) > _Off && (_Mycont->begin() - _Current) <= _Off)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current[_Off];
+ }
+
+protected:
+ void _Xran() const
+ {
+ throw ::std:: out_of_range("invalid checked_iterator<T> subscript");
+ }
+
+ void _Xinvarg() const
+ {
+ throw ::std:: invalid_argument("invalid checked_iterator<T> argument");
+ }
+
+ _Cont *_Mycont;
+ _Iter _Current;
+ };
+
+
+template <class _Iterator>
+ class checked_array_iterator
+ : public ::std:: iterator<
+ typename ::std:: iterator_traits<_Iterator>::iterator_category,
+ typename ::std:: iterator_traits<_Iterator>::value_type,
+ typename ::std:: iterator_traits<_Iterator>::difference_type,
+ typename ::std:: iterator_traits<_Iterator>::pointer,
+ typename ::std:: iterator_traits<_Iterator>::reference>
+ {
+public:
+ typedef checked_array_iterator<_Iterator> _Myt;
+ typedef typename ::std:: iterator_traits<_Iterator>::difference_type difference_type;
+ typedef typename ::std:: iterator_traits<_Iterator>::pointer pointer;
+ typedef typename ::std:: iterator_traits<_Iterator>::reference reference;
+
+ typedef ::std:: _Range_checked_iterator_tag _Checked_iterator_category;
+ typedef _Iterator _Inner_type;
+
+ typedef _Iterator _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return _Mycont + _Current;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ _Current = _Base - _Mycont;
+ }
+
+
+
+ checked_array_iterator():
+ _Size(0), _Current(0)
+ {
+ }
+
+ checked_array_iterator(_Iterator _Cont, size_t _S, size_t _Index = 0)
+ {
+ { if (!(_Index <= _S)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ _Mycont = _Cont;
+ _Size = _S;
+ _Current =_Index;
+ }
+
+ _Iterator base() const
+ {
+ return _Mycont + _Current;
+ }
+
+ size_t __Size() const
+ {
+ return _Size;
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+ { if (!(_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current == _Right._Current;
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return !(*this == _Right);
+ }
+
+ bool operator<(const _Myt& _Right) const
+ {
+ { if (!(_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current < _Right._Current;
+ }
+
+ bool operator>(const _Myt& _Right) const
+ {
+ return _Right < *this;
+ }
+
+ bool operator<=(const _Myt& _Right) const
+ {
+ return !(_Right < *this);
+ }
+
+ bool operator>=(const _Myt& _Right) const
+ {
+ return !(*this < _Right);
+ }
+
+ reference operator*() const
+ {
+ { if (!(_Current < _Size)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return *(_Mycont + _Current);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ checked_array_iterator& operator++()
+ {
+ { if (!(_Current < _Size)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ ++_Current;
+ return *this;
+ }
+
+ _Myt operator++(int)
+ {
+ checked_array_iterator _Tmp = *this;
+ ++*this;
+ return _Tmp;
+ }
+
+ _Myt& operator--()
+ {
+ { if (!(_Current > 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ --_Current;
+ return *this;
+ }
+
+ _Myt operator--(int)
+ {
+ checked_array_iterator _Tmp = *this;
+ --*this;
+ return _Tmp;
+ }
+
+
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ { if (!(_Current + _Off <= _Size && _Current + _Off >= 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ _Current += _Off;
+ return *this;
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ checked_array_iterator _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ checked_array_iterator _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const checked_array_iterator& _Right) const
+ {
+ { if (!(_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return _Current - _Right._Current;
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ { if (!(_Current + _Off < _Size && _Current + _Off > 0)) { ((void)0); ::_invalid_parameter_noinfo(); } };
+ return *(_Mycont + _Current + _Off);
+ }
+
+protected:
+ void _Xran() const
+ {
+ throw ::std:: out_of_range("invalid checked_array_iterator<T> subscript");
+ }
+
+ void _Xinvarg() const
+ {
+ throw ::std:: invalid_argument("invalid checked_array_iterator<T> argument");
+ }
+
+ _Iterator _Mycont;
+ size_t _Current;
+ size_t _Size;
+ };
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace std {
+
+
+template<class _Ty> inline
+ pair<_Ty *, ptrdiff_t>
+ get_temporary_buffer(ptrdiff_t _Count)
+ {
+ _Ty *_Pbuf;
+
+ if (_Count <= 0)
+ _Count = 0;
+ else if (((size_t)(-1) / _Count) < sizeof (_Ty))
+ throw std::bad_alloc(0);
+
+ for (_Pbuf = 0; 0 < _Count; _Count /= 2)
+ if ((_Pbuf = (_Ty *)operator new(
+ (size_t)_Count * sizeof (_Ty), nothrow)) != 0)
+ break;
+
+ return (pair<_Ty *, ptrdiff_t>(_Pbuf, _Count));
+ }
+
+
+template<class _Ty> inline
+ void return_temporary_buffer(_Ty *_Pbuf)
+ {
+ operator delete(_Pbuf);
+ }
+
+
+template<class _InIt,
+ class _FwdIt> inline
+ _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt _Next = _Dest;
+
+ try {
+ for (; _First != _Last; ++_Dest, ++_First)
+ _Construct(&*_Dest, *_First);
+ } catch (...) {
+ for (; _Next != _Dest; ++_Next)
+ _Destroy(&*_Next);
+ throw;
+ }
+ return (_Dest);
+ }
+
+template<class _Ty1,
+ class _Ty2> inline
+ _Ty2 _Uninit_copy(_Ty1 _First, _Ty1 _Last, _Ty2 _Dest,
+ _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ size_t _Count = (size_t)(_Last - _First);
+ _Ty2 _Result = _Dest + _Count;
+ if (_Count > 0)
+ ::memmove_s((&*_Dest), (_Count * sizeof (*_First)), (&*_First), (_Count * sizeof (*_First)));
+ return _Result;
+ }
+
+
+template<class _Ty1, class _Ty2, class _Ty3>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _Ty2 _Uninit_copy(_Ty1 _First, _Ty1 _Last, _Ty2 _Dest, _Ty3 _Ptr_cat, _Unchecked_iterator_tag)
+ {
+ return _Uninit_copy(_First, _Last, _Dest, _Ptr_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _FwdIt> inline
+ _FwdIt uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest)
+ {
+ return (_Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt _Next = _Dest;
+
+ try {
+ for (; _First != _Last; ++_Dest, ++_First)
+ _Al.construct(_Dest, *_First);
+ } catch (...) {
+ for (; _Next != _Dest; ++_Next)
+ _Al.destroy(_Next);
+ throw;
+ }
+ return (_Dest);
+ }
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc&, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ size_t _Count = (size_t)(_Last - _First);
+ _FwdIt _Result = _Dest + _Count;
+ if (_Count > 0)
+ ::memmove_s((&*_Dest), (_Count * sizeof (*_First)), (&*_First), (_Count * sizeof (*_First)));
+ return _Result;
+ }
+
+
+template<class _InIt, class _FwdIt, class _Alloc, class _Ty>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc _Al, _Ty _Ptr_cat, _Unchecked_iterator_tag)
+ {
+ return _Uninit_copy(_First, _Last, _Dest, _Al, _Ptr_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (_Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _InIt, class _FwdIt, class _Alloc, class _MoveCatTy>
+inline
+ _FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al, _MoveCatTy, _Range_checked_iterator_tag)
+ {
+ return ::stdext:: unchecked_uninitialized_copy(_First, _Last, _Dest, _Al);
+ }
+
+template<class _InIt, class _FwdIt, class _Alloc>
+inline
+ _FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al, _Swap_move_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt _Next = _Dest;
+
+ typename _Alloc::value_type _Val;
+
+ try {
+ for (; _First != _Last; ++_Dest, ++_First)
+ {
+ _Al.construct(_Dest, _Val);
+ ::std:: swap(*_Dest, *_First);
+ }
+ } catch (...) {
+ for (; _Next != _Dest; ++_Next)
+ _Al.destroy(_Next);
+ throw;
+ }
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _FwdIt, class _Alloc, class _MoveCatTy>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc _Al, _MoveCatTy _Move_cat, _Unchecked_iterator_tag)
+ {
+ return _Uninit_move(_First, _Last, _Dest, _Al, _Move_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt, class _FwdIt, class _Alloc>
+inline
+ _FwdIt _Uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (_Uninit_move(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ _Move_cat(_Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _FwdIt,
+ class _Tval> inline
+ void _Uninit_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val,
+ _Nonscalar_ptr_iterator_tag)
+ {
+ ;
+ _FwdIt _Next = _First;
+
+ try {
+ for (; _First != _Last; ++_First)
+ _Construct(&*_First, _Val);
+ } catch (...) {
+ for (; _Next != _First; ++_Next)
+ _Destroy(&*_Next);
+ throw;
+ }
+ }
+
+template<class _Ty,
+ class _Tval> inline
+ void _Uninit_fill(_Ty *_First, _Ty *_Last, const _Tval& _Val,
+ _Scalar_ptr_iterator_tag)
+ {
+ std::fill(_First, _Last, _Val);
+ }
+
+template<class _FwdIt,
+ class _Tval> inline
+ void uninitialized_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val)
+ {
+ _Uninit_fill(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val, _Ptr_cat(_First, _First));
+ }
+
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval> inline
+ void _Uninit_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val,
+ _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ _FwdIt _Next = _First;
+
+ try {
+ for (; 0 < _Count; --_Count, ++_First)
+ _Construct(&*_First, _Val);
+ } catch (...) {
+ for (; _Next != _First; ++_Next)
+ _Destroy(&*_Next);
+ throw;
+ }
+ }
+
+template<class _Ty,
+ class _Diff,
+ class _Tval> inline
+ void _Uninit_fill_n(_Ty *_First, _Diff _Count, const _Tval& _Val,
+ _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ::stdext:: unchecked_fill_n(_First, _Count, _Val);
+ }
+
+
+template<class _FwdIt, class _Diff, class _Tval, class _Ty2>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void _Uninit_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val,
+ _Ty2 _Ptr_cat, _Unchecked_iterator_tag)
+ {
+ _Uninit_fill_n(_First, _Count, _Val, _Ptr_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval> inline
+ void uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val)
+ {
+ _Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First), ::std:: _Checked_cat(_First));
+ }
+
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval,
+ class _Alloc> inline
+ void _Uninit_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc& _Al, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+
+
+
+
+
+ _FwdIt _Next = _First;
+
+ try {
+ for (; 0 < _Count; --_Count, ++_First)
+ _Al.construct(_First, _Val);
+ } catch (...) {
+ for (; _Next != _First; ++_Next)
+ _Al.destroy(_Next);
+ throw;
+ }
+ }
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval,
+ class _Alloc> inline
+ void _Uninit_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc&, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ::stdext:: unchecked_fill_n(_First, _Count, _Val);
+ }
+
+
+template<class _FwdIt, class _Diff, class _Tval, class _Alloc, class _Ty>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void _Uninit_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc& _Al, _Ty _Ptr_cat, _Unchecked_iterator_tag)
+ {
+ _Uninit_fill_n(_First, _Count, _Val, _Al, _Ptr_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval,
+ class _Alloc> inline
+ void _Uninitialized_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc& _Al)
+ {
+ _Uninit_fill_n(_First, _Count, _Val, _Al,
+ _Ptr_cat(_First, _First), ::std:: _Checked_cat(_First));
+ }
+
+
+template<class _FwdIt,
+ class _Ty>
+ class raw_storage_iterator
+ : public _Outit
+ {
+public:
+ typedef _FwdIt iterator_type;
+ typedef _FwdIt iter_type;
+ typedef _Ty element_type;
+
+ explicit raw_storage_iterator(_FwdIt _First)
+ : _Next(_First)
+ {
+ }
+
+ raw_storage_iterator<_FwdIt, _Ty>& operator*()
+ {
+ return (*this);
+ }
+
+ raw_storage_iterator<_FwdIt, _Ty>& operator=(const _Ty& _Val)
+ {
+ _Construct(&*_Next, _Val);
+ return (*this);
+ }
+
+ raw_storage_iterator<_FwdIt, _Ty>& operator++()
+ {
+ ++_Next;
+ return (*this);
+ }
+
+ raw_storage_iterator<_FwdIt, _Ty> operator++(int)
+ {
+ raw_storage_iterator<_FwdIt, _Ty> _Ans = *this;
+ ++_Next;
+ return (_Ans);
+ }
+
+private:
+ _FwdIt _Next;
+ };
+
+
+template<class _Ty>
+ class _Temp_iterator
+ : public _Outit
+ {
+public:
+ typedef _Ty *_Pty;
+
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+ _Temp_iterator(ptrdiff_t _Count = 0)
+ {
+ _Buf._Begin = 0;
+ _Buf._Current = 0;
+ _Buf._Hiwater = 0;
+ _Buf._Size = _Count;
+ _Pbuf = &_Buf;
+ }
+
+ _Temp_iterator(const _Temp_iterator<_Ty>& _Right)
+ {
+ _Buf._Begin = 0;
+ _Buf._Current = 0;
+ _Buf._Hiwater = 0;
+ _Buf._Size = 0;
+ *this = _Right;
+ }
+
+ ~_Temp_iterator()
+ {
+ if (_Buf._Begin != 0)
+ {
+ for (_Pty _Next = _Buf._Begin;
+ _Next != _Buf._Hiwater; ++_Next)
+ _Destroy(&*_Next);
+ std::return_temporary_buffer(_Buf._Begin);
+ }
+ }
+
+ _Temp_iterator<_Ty>& operator=(const _Temp_iterator<_Ty>& _Right)
+ {
+ _Pbuf = _Right._Pbuf;
+ return (*this);
+ }
+
+ _Temp_iterator<_Ty>& operator=(const _Ty& _Val)
+ {
+ if (_Pbuf->_Current < _Pbuf->_Hiwater)
+ *_Pbuf->_Current++ = _Val;
+ else
+ {
+ { if (!((_Pbuf->_Current - _Pbuf->_Begin) < _Pbuf->_Size)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ _Pty _Ptr = &*_Pbuf->_Current;
+ _Construct(_Ptr, _Val);
+ _Pbuf->_Hiwater = ++_Pbuf->_Current;
+ }
+ return (*this);
+ }
+
+ _Temp_iterator<_Ty>& operator*()
+ {
+ return (*this);
+ }
+
+ _Temp_iterator<_Ty>& operator++()
+ {
+ return (*this);
+ }
+
+ _Temp_iterator<_Ty>& operator++(int)
+ {
+ return (*this);
+ }
+
+ _Temp_iterator<_Ty>& _Init()
+ {
+ _Pbuf->_Current = _Pbuf->_Begin;
+ return (*this);
+ }
+
+ _Pty _First() const
+ {
+ return (_Pbuf->_Begin);
+ }
+
+ _Pty _Last() const
+ {
+ return (_Pbuf->_Current);
+ }
+
+ ptrdiff_t _Maxlen()
+ {
+ if (_Pbuf->_Begin == 0 && 0 < _Pbuf->_Size)
+ {
+ pair<_Pty, ptrdiff_t> _Pair =
+ std::get_temporary_buffer<_Ty>(_Pbuf->_Size);
+
+ _Pbuf->_Begin = _Pair.first;
+ _Pbuf->_Current = _Pair.first;
+ _Pbuf->_Hiwater = _Pair.first;
+ _Pbuf->_Size = _Pair.second;
+ }
+ return (_Pbuf->_Size);
+ }
+
+ static void _Xinvarg()
+ {
+ throw invalid_argument("invalid _Temp_iterator<T> argument");
+ }
+
+private:
+ struct _Bufpar
+ {
+ _Pty _Begin;
+ _Pty _Current;
+ _Pty _Hiwater;
+ ptrdiff_t _Size;
+ };
+ _Bufpar _Buf;
+ _Bufpar *_Pbuf;
+ };
+
+
+template<class _Ty>
+ class auto_ptr;
+
+template<class _Ty>
+ struct auto_ptr_ref
+ {
+ auto_ptr_ref(void *_Right)
+ : _Ref(_Right)
+ {
+ }
+
+ void *_Ref;
+ };
+
+template<class _Ty>
+ class auto_ptr
+ {
+public:
+ typedef _Ty element_type;
+
+ explicit auto_ptr(_Ty *_Ptr = 0) throw ()
+ : _Myptr(_Ptr)
+ {
+ }
+
+ auto_ptr(auto_ptr<_Ty>& _Right) throw ()
+ : _Myptr(_Right.release())
+ {
+ }
+
+ auto_ptr(auto_ptr_ref<_Ty> _Right) throw ()
+ {
+ _Ty **_Pptr = (_Ty **)_Right._Ref;
+ _Ty *_Ptr = *_Pptr;
+ *_Pptr = 0;
+ _Myptr = _Ptr;
+ }
+
+ template<class _Other>
+ operator auto_ptr<_Other>() throw ()
+ {
+ return (auto_ptr<_Other>(*this));
+ }
+
+ template<class _Other>
+ operator auto_ptr_ref<_Other>() throw ()
+ {
+ _Other *_Testptr = (_Ty *)_Myptr;
+ auto_ptr_ref<_Other> _Ans(&_Myptr);
+ return (_Testptr != 0 ? _Ans : _Ans);
+ }
+
+ template<class _Other>
+ auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) throw ()
+ {
+ reset(_Right.release());
+ return (*this);
+ }
+
+ template<class _Other>
+ auto_ptr(auto_ptr<_Other>& _Right) throw ()
+ : _Myptr(_Right.release())
+ {
+ }
+
+ auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) throw ()
+ {
+ reset(_Right.release());
+ return (*this);
+ }
+
+ auto_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) throw ()
+ {
+ _Ty **_Pptr = (_Ty **)_Right._Ref;
+ _Ty *_Ptr = *_Pptr;
+ *_Pptr = 0;
+ reset(_Ptr);
+ return (*this);
+ }
+
+ ~auto_ptr()
+ {
+ delete (_Ty *)_Myptr;
+ }
+
+ _Ty& operator*() const throw ()
+ {
+
+
+
+
+
+
+ ;
+
+ return (*(_Ty *)_Myptr);
+ }
+
+ _Ty *operator->() const throw ()
+ {
+ return (&**this);
+ }
+
+ _Ty *get() const throw ()
+ {
+ return ((_Ty *)_Myptr);
+ }
+
+ _Ty *release() throw ()
+ {
+ _Ty *_Tmp = (_Ty *)_Myptr;
+ _Myptr = 0;
+ return (_Tmp);
+ }
+
+ void reset(_Ty* _Ptr = 0)
+ {
+ if (_Ptr != _Myptr)
+ delete (_Ty *)_Myptr;
+ _Myptr = _Ptr;
+ }
+
+private:
+ const _Ty *_Myptr;
+ };
+}
+
+namespace stdext {
+
+template<class _InIt,
+ class _FwdIt> inline
+ _FwdIt unchecked_uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest)
+ {
+ return (::std:: _Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Ptr_cat(_First, _Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _FwdIt> inline
+ _FwdIt checked_uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest)
+ {
+ return (::std:: _Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt unchecked_uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (::std:: _Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ ::std:: _Ptr_cat(_First, _Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt checked_uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (::std:: _Uninit_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ ::std:: _Ptr_cat(_First, _Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt _Unchecked_uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (::std:: _Uninit_move(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ ::std:: _Move_cat(_Dest), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _FwdIt,
+ class _Alloc> inline
+ _FwdIt _Checked_uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest,
+ _Alloc& _Al)
+ {
+ return (::std:: _Uninit_move(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Al,
+ ::std:: _Move_cat(_Dest), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval> inline
+ void unchecked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val)
+ {
+ ::std:: _Uninit_fill_n(_First, _Count, _Val, ::std:: _Ptr_cat(_First, _First), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval> inline
+ void checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val)
+ {
+ ::std:: _Uninit_fill_n(_First, _Count, _Val, ::std:: _Ptr_cat(_First, _First), ::std:: _Checked_cat(_First));
+ }
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval,
+ class _Alloc> inline
+ void unchecked_uninitialized_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc& _Al)
+ {
+ ::std:: _Uninit_fill_n(_First, _Count, _Val, _Al,
+ ::std:: _Ptr_cat(_First, _First), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _FwdIt,
+ class _Diff,
+ class _Tval,
+ class _Alloc> inline
+ void checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count,
+ const _Tval& _Val, _Alloc& _Al)
+ {
+ ::std:: _Uninit_fill_n(_First, _Count, _Val, _Al,
+ ::std:: _Ptr_cat(_First, _First), ::std:: _Checked_cat(_First));
+ }
+
+}
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+ #pragma warning(disable: 4244)
+
+
+namespace std {
+
+
+const int _ISORT_MAX = 32;
+
+
+template<class _InIt,
+ class _Fn1> inline
+ _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
+ {
+ ;
+ ;
+ typename ::std:: _Checked_iterator_base_helper<_InIt>::_Checked_iterator_base_type _ChkFirst(::std:: _Checked_base(_First));
+ typename ::std:: _Checked_iterator_base_helper<_InIt>::_Checked_iterator_base_type _ChkLast(::std:: _Checked_base(_Last));
+ for (; _ChkFirst != _ChkLast; ++_ChkFirst)
+ _Func(*_ChkFirst);
+ return (_Func);
+ }
+
+
+template<class _InIt, class _Ty>
+inline
+ _InIt _Find(_InIt _First, _InIt _Last, const _Ty& _Val)
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ if (*_First == _Val)
+ break;
+ return (_First);
+ }
+
+inline const char *_Find(const char *_First, const char *_Last, int _Val)
+ {
+ ;
+ _First = (const char *)::memchr(_First, _Val, _Last - _First);
+ return (_First == 0 ? _Last : _First);
+ }
+
+inline const signed char *_Find(const signed char *_First,
+ const signed char *_Last, int _Val)
+ {
+ ;
+ _First = (const signed char *)::memchr(_First, _Val,
+ _Last - _First);
+ return (_First == 0 ? _Last : _First);
+ }
+
+inline const unsigned char *_Find(const unsigned char *_First,
+ const unsigned char *_Last, int _Val)
+ {
+ ;
+ _First = (const unsigned char *)::memchr(_First, _Val,
+ _Last - _First);
+ return (_First == 0 ? _Last : _First);
+ }
+
+template<class _InIt, class _Ty>
+inline
+ _InIt find(_InIt _First, _InIt _Last, const _Ty& _Val)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Find(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val));
+ return (_First);
+ }
+
+
+template<class _InIt,
+ class _Pr> inline
+ _InIt _Find_if(_InIt _First, _InIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First)
+ if (_Pred(*_First))
+ break;
+ return (_First);
+ }
+
+template<class _InIt,
+ class _Pr> inline
+ _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Find_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_First);
+ }
+
+
+template<class _FwdIt> inline
+ _FwdIt _Adjacent_find(_FwdIt _First, _FwdIt _Last)
+ {
+ ;
+ for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
+ if (*_Firstb == *_First)
+ return (_Firstb);
+ return (_Last);
+ }
+
+template<class _FwdIt> inline
+ _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Adjacent_find(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last)));
+ return (_First);
+ }
+
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt _Adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
+ if (_Pred(*_Firstb, *_First))
+ return (_Firstb);
+ return (_Last);
+ }
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Adjacent_find(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_First);
+ }
+
+
+template<class _InIt,
+ class _Ty> inline
+ typename iterator_traits<_InIt>::difference_type
+ _Count(_InIt _First, _InIt _Last, const _Ty& _Val)
+ {
+ ;
+ typename iterator_traits<_InIt>::difference_type _Cnt = 0;
+
+ for (; _First != _Last; ++_First)
+ if (*_First == _Val)
+ ++_Cnt;
+ return (_Cnt);
+ }
+
+template<class _InIt,
+ class _Ty> inline
+ typename iterator_traits<_InIt>::difference_type
+ count(_InIt _First, _InIt _Last, const _Ty& _Val)
+ {
+ return _Count(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val);
+ }
+
+
+template<class _InIt,
+ class _Pr> inline
+ typename iterator_traits<_InIt>::difference_type
+ _Count_if(_InIt _First, _InIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ typename iterator_traits<_InIt>::difference_type _Count = 0;
+
+ for (; _First != _Last; ++_First)
+ if (_Pred(*_First))
+ ++_Count;
+ return (_Count);
+ }
+
+template<class _InIt,
+ class _Pr> inline
+ typename iterator_traits<_InIt>::difference_type
+ count_if(_InIt _First, _InIt _Last, _Pr _Pred)
+ {
+ return _Count_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred);
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Diff1,
+ class _Diff2> inline
+ _FwdIt1 _Search(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Diff1 *, _Diff2 *)
+ {
+ ;
+ ;
+ _Diff1 _Count1 = 0;
+ _Distance(_First1, _Last1, _Count1);
+ _Diff2 _Count2 = 0;
+ _Distance(_First2, _Last2, _Count2);
+
+ for (; _Count2 <= _Count1; ++_First1, --_Count1)
+ {
+ _FwdIt1 _Mid1 = _First1;
+ for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
+ if (_Mid2 == _Last2)
+ return (_First1);
+ else if (!(*_Mid1 == *_Mid2))
+ break;
+ }
+ return (_Last1);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2> inline
+ _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Search(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dist_type(_First1), _Dist_type(_First2)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Diff1,
+ class _Diff2,
+ class _Pr> inline
+ _FwdIt1 _Search(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred, _Diff1 *, _Diff2 *)
+ {
+ ;
+ ;
+ ;
+ _Diff1 _Count1 = 0;
+ _Distance(_First1, _Last1, _Count1);
+ _Diff2 _Count2 = 0;
+ _Distance(_First2, _Last2, _Count2);
+
+ for (; _Count2 <= _Count1; ++_First1, --_Count1)
+ {
+ _FwdIt1 _Mid1 = _First1;
+ for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
+ if (_Mid2 == _Last2)
+ return (_First1);
+ else if (!_Pred(*_Mid1, *_Mid2))
+ break;
+ }
+ return (_Last1);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Pr> inline
+ _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Search(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred, _Dist_type(_First1), _Dist_type(_First2)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty> inline
+ _FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val, forward_iterator_tag)
+ {
+ ;
+ _FwdIt1 _Mid1;
+
+ if (_Count == 0)
+ return (_First1);
+
+ for (;; _First1 = ++_Mid1)
+ {
+ _Diff2 _Count1 = _Count;
+
+ for (; _First1 != _Last1; ++_First1)
+ if (*_First1 == _Val)
+ break;
+
+ for (_Mid1 = _First1;; )
+ if (--_Count1 == 0)
+ return (_First1);
+ else if (_Mid1 == _Last1 || !(*++_Mid1 == _Val))
+ break;
+ if (_Mid1 == _Last1)
+ return (_Last1);
+ }
+ }
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty> inline
+ _FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val, random_access_iterator_tag)
+ {
+ ;
+ _FwdIt1 _Mid1;
+
+ if (_Count == 0)
+ return (_First1);
+
+ for (;; _First1 = ++_Mid1)
+ {
+ _FwdIt1 _Oldfirst1 = _First1;
+ _Diff2 _Count1 = _Count;
+
+ for (;; _First1 += _Count)
+ if (_First1 == _Last1)
+ return (_Last1);
+ else if (*_First1 == _Val)
+ break;
+ else if (_Last1 - _First1 < _Count)
+ return (_Last1);
+
+ if (_Oldfirst1 != _First1)
+ for (++_Oldfirst1; _Oldfirst1 != _First1; --_First1, --_Count1)
+ if (!(_First1[-1] == _Val))
+ break;
+
+ for (_Mid1 = _First1;; )
+ if (--_Count1 == 0)
+ return (_First1);
+ else if (_Mid1 == _Last1 || !(*++_Mid1 == _Val))
+ break;
+ if (_Mid1 == _Last1)
+ return (_Last1);
+ }
+ }
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty> inline
+ _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Search_n(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _Count, _Val, _Iter_cat(_First1)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty,
+ class _Pr> inline
+ _FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val, _Pr _Pred, forward_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt1 _Mid1;
+
+ if (_Count == 0)
+ return (_First1);
+
+ for (;; _First1 = ++_Mid1)
+ {
+ _Diff2 _Count1 = _Count;
+
+ for (; _First1 != _Last1; ++_First1)
+ if (_Pred(*_First1, _Val))
+ break;
+
+ for (_Mid1 = _First1;; )
+ if (--_Count1 == 0)
+ return (_First1);
+ else if (_Mid1 == _Last1 || !_Pred(*++_Mid1, _Val))
+ break;
+ if (_Mid1 == _Last1)
+ return (_Last1);
+ }
+ }
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty,
+ class _Pr> inline
+ _FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val, _Pr _Pred, random_access_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt1 _Mid1;
+
+ if (_Count == 0)
+ return (_First1);
+
+ for (;; _First1 = ++_Mid1)
+ {
+ _FwdIt1 _Oldfirst1 = _First1;
+ _Diff2 _Count1 = _Count;
+
+ for (;; _First1 += _Count)
+ if (_First1 == _Last1)
+ return (_Last1);
+ else if (_Pred(*_First1, _Val))
+ break;
+ else if (_Last1 - _First1 < _Count)
+ return (_Last1);
+
+ if (_Oldfirst1 != _First1)
+ for (++_Oldfirst1; _Oldfirst1 != _First1; --_First1, --_Count1)
+ if (!_Pred(_First1[-1], _Val))
+ break;
+
+ for (_Mid1 = _First1;; )
+ if (--_Count1 == 0)
+ return (_First1);
+ else if (_Mid1 == _Last1 || !_Pred(*++_Mid1, _Val))
+ break;
+ if (_Mid1 == _Last1)
+ return (_Last1);
+ }
+ }
+
+template<class _FwdIt1,
+ class _Diff2,
+ class _Ty,
+ class _Pr> inline
+ _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _Diff2 _Count, const _Ty& _Val, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Search_n(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _Count, _Val, _Pred, _Iter_cat(_First1)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Diff1,
+ class _Diff2> inline
+ _FwdIt1 _Find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Diff1 *, _Diff2 *)
+ {
+ ;
+ ;
+ _Diff1 _Count1 = 0;
+ _Distance(_First1, _Last1, _Count1);
+ _Diff2 _Count2 = 0;
+ _Distance(_First2, _Last2, _Count2);
+ _FwdIt1 _Ans = _Last1;
+
+ if (0 < _Count2)
+ for (; _Count2 <= _Count1; ++_First1, --_Count1)
+ {
+ _FwdIt1 _Mid1 = _First1;
+ for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
+ if (!(*_Mid1 == *_Mid2))
+ break;
+ else if (++_Mid2 == _Last2)
+ {
+ _Ans = _First1;
+ break;
+ }
+ }
+ return (_Ans);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2> inline
+ _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Find_end(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dist_type(_First1), _Dist_type(_First2)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Diff1,
+ class _Diff2,
+ class _Pr> inline
+ _FwdIt1 _Find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred, _Diff1 *, _Diff2 *)
+ {
+ ;
+ ;
+ ;
+ _Diff1 _Count1 = 0;
+ _Distance(_First1, _Last1, _Count1);
+ _Diff2 _Count2 = 0;
+ _Distance(_First2, _Last2, _Count2);
+ _FwdIt1 _Ans = _Last1;
+
+ if (0 < _Count2)
+ for (; _Count2 <= _Count1; ++_First1, --_Count1)
+ {
+ _FwdIt1 _Mid1 = _First1;
+ for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
+ if (!_Pred(*_Mid1, *_Mid2))
+ break;
+ else if (++_Mid2 == _Last2)
+ {
+ _Ans = _First1;
+ break;
+ }
+ }
+ return (_Ans);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Pr> inline
+ _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Find_end(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred, _Dist_type(_First1), _Dist_type(_First2)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2> inline
+ _FwdIt1 _Find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2)
+ {
+ ;
+ ;
+ for (; _First1 != _Last1; ++_First1)
+ for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
+ if (*_First1 == *_Mid2)
+ return (_First1);
+ return (_First1);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2> inline
+ _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2)
+ {
+ ;
+ ;
+ ::std:: _Checked_assign_from_base(_First1, _Find_first_of(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2)));
+ return _First1;
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Pr> inline
+ _FwdIt1 _Find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
+ {
+ ;
+ for (; _First1 != _Last1; ++_First1)
+ for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
+ if (_Pred(*_First1, *_Mid2))
+ return (_First1);
+ return (_First1);
+ }
+
+template<class _FwdIt1,
+ class _FwdIt2,
+ class _Pr> inline
+ _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
+ _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First1, _Find_first_of(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred));
+ return (_First1);
+ }
+
+
+template<class _FwdIt1,
+ class _FwdIt2> inline
+ void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
+ {
+ std::swap(*_Left, *_Right);
+ }
+
+
+template<class _FwdIt1, class _FwdIt2, class _FwdItCats>
+inline
+ _FwdIt2 _Swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
+ _FwdItCats, _Range_checked_iterator_tag)
+ {
+ ;
+ for (; _First1 != _Last1; ++_First1, ++_First2)
+ std::iter_swap(_First1, _First2);
+ return (_First2);
+ }
+
+
+template<class _FwdIt1, class _FwdIt2>
+inline
+ _FwdIt2 _Swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _FwdIt2 _Result = _First2 + (_Last1 - _First1);
+ _Swap_ranges(_First1, _Last1, ::std:: _Checked_base(_First2),
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return (_Result);
+ }
+
+
+
+template<class _FwdIt1, class _FwdIt2, class _FwdItCats>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _FwdIt2 _Swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
+ _FwdItCats _Iter_cats, _Unchecked_iterator_tag)
+ {
+ return _Swap_ranges(_First1, _Last1, _First2, _Iter_cats, _Range_checked_iterator_tag());
+ }
+
+
+template<class _FwdIt1, class _FwdIt2>
+inline
+ _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
+ {
+ return _Swap_ranges(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ _Iter_random(_First1, _First2), ::std:: _Checked_cat(_First2));
+ }
+
+
+template<class _InIt, class _OutIt, class _Fn1, class _InOutItCat>
+inline
+ _OutIt _Transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func,
+ _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Func(*_First);
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _Fn1>
+inline
+ _OutIt _Transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Transform(_First, _Last, ::std:: _Checked_base(_Dest), _Func,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return (_Result);
+ }
+
+
+
+template<class _InIt, class _OutIt, class _Fn1, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func,
+ _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Transform(_First, _Last, _Dest, _Func,
+ _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt, class _OutIt, class _Fn1>
+inline
+ _OutIt transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
+ {
+ return _Transform(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Func,
+ _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InItCats, class _InOutItCat>
+inline
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ _InItCats, _InOutItCat,
+ _Range_checked_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
+ *_Dest = _Func(*_First1, *_First2);
+ return (_Dest);
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2>
+inline
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ random_access_iterator_tag, random_access_iterator_tag,
+ _Range_checked_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ _OutIt _Result = _Dest + (_Last1 - _First1);
+ _Transform(_First1, _Last1, ::std:: _Checked_base(_First2),
+ ::std:: _Checked_base(_Dest), _Func,
+ forward_iterator_tag(), forward_iterator_tag(),
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InOutItCat>
+inline
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ random_access_iterator_tag, _InOutItCat,
+ _Range_checked_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
+ return _Transform(_First1, _Last1, ::std:: _Checked_base(_First2),
+ _Dest, _Func,
+ forward_iterator_tag(), forward_iterator_tag(),
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InItCats>
+inline
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ _InItCats, random_access_iterator_tag,
+ _Range_checked_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last1 - _First1);
+ _Transform(_First1, _Last1, _First2,
+ ::std:: _Checked_base(_Dest), _Func,
+ forward_iterator_tag(), forward_iterator_tag(),
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InItCats, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ _InItCats _InIt_cats, _InOutItCat _First_dest_cat,
+ _Unchecked_iterator_tag, _Unchecked_iterator_tag)
+ {
+ return _Transform(_First1, _Last1, _First2, _Dest, _Func,
+ _InIt_cats, _First_dest_cat,
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InItCats, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ _InItCats _InIt_cats, _InOutItCat _First_dest_cat,
+ _Range_checked_iterator_tag, _Unchecked_iterator_tag)
+ {
+ return _Transform(_First1, _Last1, _First2, _Dest, _Func,
+ _InIt_cats, _First_dest_cat,
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2, class _InItCats, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func,
+ _InItCats _InIt_cats, _InOutItCat _First_dest_cat,
+ _Unchecked_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return _Transform(_First1, _Last1, _First2, _Dest, _Func,
+ _InIt_cats, _First_dest_cat,
+ _Range_checked_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2>
+inline
+ _OutIt transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func)
+ {
+ return _Transform(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Dest, _Func,
+ _Iter_random(_First1, _First2), _Iter_random(_First1, _Dest),
+ ::std:: _Checked_cat(_First2), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _FwdIt,
+ class _Ty> inline
+ void _Replace(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Oldval, const _Ty& _Newval)
+ {
+ ;
+ for (; _First != _Last; ++_First)
+ if (*_First == _Oldval)
+ *_First = _Newval;
+ }
+
+template<class _FwdIt,
+ class _Ty> inline
+ void replace(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Oldval, const _Ty& _Newval)
+ {
+ _Replace(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Oldval, _Newval);
+ }
+
+
+template<class _FwdIt,
+ class _Pr,
+ class _Ty> inline
+ void _Replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First)
+ if (_Pred(*_First))
+ *_First = _Val;
+ }
+
+template<class _FwdIt,
+ class _Pr,
+ class _Ty> inline
+ void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val)
+ {
+ _Replace_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred, _Val);
+ }
+
+
+template<class _InIt, class _OutIt, class _Ty, class _InOutItCat>
+inline
+ _OutIt _Replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval,
+ _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = *_First == _Oldval ? _Newval : *_First;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _Ty>
+inline
+ _OutIt _Replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Replace_copy(_First, _Last, ::std:: _Checked_base(_Dest),
+ _Oldval, _Newval,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return (_Result);
+ }
+
+
+
+template<class _InIt, class _OutIt, class _Ty, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval,
+ _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Replace_copy(_First, _Last, _Dest, _Oldval, _Newval,
+ _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval)
+ {
+ return _Replace_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Oldval, _Newval,
+ _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt, class _OutIt, class _Pr, class _Ty, class _InOutItCat>
+inline
+ _OutIt _Replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val, _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First != _Last; ++_First, ++_Dest)
+ *_Dest = _Pred(*_First) ? _Val : *_First;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _Pr, class _Ty>
+inline
+ _OutIt _Replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Replace_copy_if(_First, _Last, ::std:: _Checked_base(_Dest),
+ _Pred, _Val,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return (_Result);
+ }
+
+
+
+template<class _InIt, class _OutIt, class _Pr, class _Ty, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val,
+ _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Replace_copy_if(_First, _Last, _Dest, _Pred, _Val,
+ _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr,
+ class _Ty> inline
+ _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val)
+ {
+ return _Replace_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred, _Val,
+ _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _FwdIt,
+ class _Fn0> inline
+ void _Generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First)
+ *_First = _Func();
+ }
+
+template<class _FwdIt,
+ class _Fn0> inline
+ void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
+ {
+ _Generate(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Func);
+ }
+
+
+template<class _OutIt, class _Diff, class _Fn0, class _OutItCat>
+inline
+ void _Generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func,
+ _OutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ for (; 0 < _Count; --_Count, ++_Dest)
+ *_Dest = _Func();
+ }
+
+
+template<class _OutIt, class _Diff, class _Fn0>
+inline
+ void _Generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + _Count;
+ _Generate_n(::std:: _Checked_base(_Dest), _Count, _Func,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ }
+
+
+
+template<class _OutIt, class _Diff, class _Fn0, class _OutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void _Generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func,
+ _OutItCat _Dest_cat, _Unchecked_iterator_tag)
+ {
+ _Generate_n(_Dest, _Count, _Func, _Dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _OutIt,
+ class _Diff,
+ class _Fn0> inline
+ void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
+ {
+ _Generate_n(_Dest, _Count, _Func,
+ _Iter_cat(_Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt _Remove_copy(_InIt _First, _InIt _Last,
+ _OutIt _Dest, const _Ty& _Val, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_First)
+ if (!(*_First == _Val))
+ *_Dest++ = *_First;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _Ty>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Remove_copy(_InIt _First, _InIt _Last,
+ _OutIt _Dest, const _Ty& _Val, _Unchecked_iterator_tag)
+ {
+ return _Remove_copy(_First, _Last, _Dest, _Val, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt remove_copy(_InIt _First, _InIt _Last,
+ _OutIt _Dest, const _Ty& _Val)
+ {
+ return _Remove_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Val, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First != _Last; ++_First)
+ if (!_Pred(*_First))
+ *_Dest++ = *_First;
+ return (_Dest);
+ }
+
+
+template<class _InIt, class _OutIt, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Remove_copy_if(_First, _Last, _Dest, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Remove_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _FwdIt,
+ class _Ty> inline
+ _FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ _First = find(_First, _Last, _Val);
+ if (_First == _Last)
+ return (_First);
+ else
+ {
+ _FwdIt _First1 = _First;
+ return (::stdext:: unchecked_remove_copy(++_First1, _Last, _First, _Val));
+ }
+ }
+
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ _First = std::find_if(_First, _Last, _Pred);
+ if (_First == _Last)
+ return (_First);
+ else
+ {
+ _FwdIt _First1 = _First;
+ return (::stdext:: unchecked_remove_copy_if(++_First1, _Last, _First, _Pred));
+ }
+ }
+
+
+template<class _FwdIt> inline
+ _FwdIt _Unique(_FwdIt _First, _FwdIt _Last)
+ {
+ ;
+ for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
+ if (*_Firstb == *_First)
+ {
+ for (; ++_First != _Last; )
+ if (!(*_Firstb == *_First))
+ *++_Firstb = *_First;
+ return (++_Firstb);
+ }
+ return (_Last);
+ }
+
+template<class _FwdIt> inline
+ _FwdIt unique(_FwdIt _First, _FwdIt _Last)
+ {
+ ::std:: _Checked_assign_from_base(_Last, _Unique(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last)));
+ return (_Last);
+ }
+
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt _Unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
+ if (_Pred(*_Firstb, *_First))
+ {
+ for (; ++_First != _Last; )
+ if (!_Pred(*_Firstb, *_First))
+ *++_Firstb = *_First;
+ return (++_Firstb);
+ }
+ return (_Last);
+ }
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_Last, _Unique(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_Last);
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Ty *, _Range_checked_iterator_tag)
+ {
+ ;
+ _Ty _Val = *_First;
+
+ for (*_Dest++ = _Val; ++_First != _Last; )
+ if (!(_Val == *_First))
+ _Val = *_First, *_Dest++ = _Val;
+ return (_Dest);
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ input_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, _Val_type(_First), _Range_checked_iterator_tag()));
+ }
+
+template<class _FwdIt,
+ class _OutIt> inline
+ _OutIt _Unique_copy(_FwdIt _First, _FwdIt _Last, _OutIt _Dest,
+ forward_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ _FwdIt _Firstb = _First;
+ for (*_Dest++ = *_Firstb; ++_First != _Last; )
+ if (!(*_Firstb == *_First))
+ _Firstb = _First, *_Dest++ = *_Firstb;
+ return (_Dest);
+ }
+
+template<class _BidIt,
+ class _OutIt> inline
+ _OutIt _Unique_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ bidirectional_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, forward_iterator_tag(), _Range_checked_iterator_tag()));
+ }
+
+template<class _RanIt,
+ class _OutIt> inline
+ _OutIt _Unique_copy(_RanIt _First, _RanIt _Last, _OutIt _Dest,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, forward_iterator_tag(), _Range_checked_iterator_tag()));
+ }
+
+
+template<class _RanIt, class _OutIt, class _RanItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Unique_copy(_RanIt _First, _RanIt _Last, _OutIt _Dest,
+ _RanItCat _First_cat, _Unchecked_iterator_tag)
+ {
+ return _Unique_copy(_First, _Last, _Dest, _First_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (_First == _Last ? _Dest :
+ _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Iter_cat(_First), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty,
+ class _Pr> inline
+ _OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred,
+ _Ty *, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ _Ty _Val = *_First;
+
+ for (*_Dest++ = _Val; ++_First != _Last; )
+ if (!_Pred(_Val, *_First))
+ _Val = *_First, *_Dest++ = _Val;
+ return (_Dest);
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred,
+ input_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, _Pred, _Val_type(_First)), _Range_checked_iterator_tag());
+ }
+
+template<class _FwdIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Unique_copy(_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr _Pred,
+ forward_iterator_tag, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ _FwdIt _Firstb = _First;
+
+ for (*_Dest++ = *_Firstb; ++_First != _Last; )
+ if (!_Pred(*_Firstb, *_First))
+ _Firstb = _First, *_Dest++ = *_Firstb;
+ return (_Dest);
+ }
+
+template<class _BidIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Unique_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest, _Pr _Pred,
+ bidirectional_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag()));
+ }
+
+template<class _RanIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Unique_copy(_RanIt _First, _RanIt _Last, _OutIt _Dest, _Pr _Pred,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+ return (_Unique_copy(_First, _Last, _Dest, _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag()));
+ }
+
+
+template<class _RanIt, class _OutIt, class _Pr, class _RanItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Unique_copy(_RanIt _First, _RanIt _Last, _OutIt _Dest, _Pr _Pred,
+ _RanItCat _First_cat, _Unchecked_iterator_tag)
+ {
+ return _Unique_copy(_First, _Last, _Dest, _Pred, _First_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return (_First == _Last ? _Dest
+ : _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred, _Iter_cat(_First), ::std:: _Checked_cat(_Dest)));
+ }
+
+
+template<class _BidIt> inline
+ void _Reverse(_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
+ {
+ for (; _First != _Last && _First != --_Last; ++_First)
+ std::iter_swap(_First, _Last);
+ }
+
+template<class _RanIt> inline
+ void _Reverse(_RanIt _First, _RanIt _Last, random_access_iterator_tag)
+ {
+ ;
+ for (; _First < _Last; ++_First)
+ std::iter_swap(_First, --_Last);
+ }
+
+template<class _BidIt> inline
+ void reverse(_BidIt _First, _BidIt _Last)
+ {
+ _Reverse(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Iter_cat(_First));
+ }
+
+
+template<class _BidIt, class _OutIt, class _InOutItCat>
+inline
+ _OutIt _Reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ for (; _First != _Last; ++_Dest)
+ *_Dest = *--_Last;
+ return (_Dest);
+ }
+
+
+template<class _BidIt, class _OutIt>
+inline
+ _OutIt _Reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last - _First);
+ _Reverse_copy(_First, _Last, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return (_Result);
+ }
+
+
+
+template<class _BidIt, class _OutIt, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Reverse_copy(_First, _Last, _Dest,
+ _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt,
+ class _OutIt> inline
+ _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest)
+ {
+ return _Reverse_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _FwdIt> inline
+ void _Rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,
+ forward_iterator_tag)
+ {
+ for (_FwdIt _Next = _Mid; ; )
+ {
+ std::iter_swap(_First, _Next);
+ if (++_First == _Mid)
+ if (++_Next == _Last)
+ break;
+ else
+ _Mid = _Next;
+ else if (++_Next == _Last)
+ _Next = _Mid;
+ }
+ }
+
+template<class _BidIt> inline
+ void _Rotate(_BidIt _First, _BidIt _Mid, _BidIt _Last,
+ bidirectional_iterator_tag)
+ {
+ std::reverse(_First, _Mid);
+ std::reverse(_Mid, _Last);
+ std::reverse(_First, _Last);
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Rotate(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Diff *, _Ty *)
+ {
+ ;
+ ;
+ _Diff _Shift = _Mid - _First;
+ _Diff _Count = _Last - _First;
+
+ for (_Diff _Factor = _Shift; _Factor != 0; )
+ {
+ _Diff _Tmp = _Count % _Factor;
+ _Count = _Factor, _Factor = _Tmp;
+ }
+
+ if (_Count < _Last - _First)
+ for (; 0 < _Count; --_Count)
+ {
+ _RanIt _Hole = _First + _Count;
+ _RanIt _Next = _Hole;
+ _Ty _Holeval = *_Hole;
+ _RanIt _Next1 = _Next + _Shift == _Last ? _First : _Next + _Shift;
+ while (_Next1 != _Hole)
+ {
+ *_Next = *_Next1;
+ _Next = _Next1;
+ _Next1 = _Shift < _Last - _Next1 ? _Next1 + _Shift
+ : _First + (_Shift - (_Last - _Next1));
+ }
+ *_Next = _Holeval;
+ }
+ }
+
+template<class _RanIt> inline
+ void _Rotate(_RanIt _First, _RanIt _Mid, _RanIt _Last,
+ random_access_iterator_tag)
+ {
+ _Rotate(_First, _Mid, _Last, _Dist_type(_First), _Val_type(_First));
+ }
+
+template<class _FwdIt> inline
+ void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
+ {
+ if (_First != _Mid && _Mid != _Last)
+ _Rotate(::std:: _Checked_base(_First), ::std:: _Checked_base(_Mid), ::std:: _Checked_base(_Last), _Iter_cat(_First));
+ }
+
+
+template<class _FwdIt,
+ class _OutIt> inline
+ _OutIt _Rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest, _Range_checked_iterator_tag)
+ {
+ _Dest = ::stdext:: unchecked_copy(_Mid, _Last, _Dest);
+ return (::stdext:: unchecked_copy(_First, _Mid, _Dest));
+ }
+
+
+template<class _FwdIt, class _OutIt>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest, _Unchecked_iterator_tag)
+ {
+ return _Rotate_copy(_First, _Mid, _Last, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _FwdIt, class _OutIt>
+inline
+ _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
+ {
+ return _Rotate_copy(_First, _Mid, _Last, _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _RanIt,
+ class _Diff> inline
+ void _Random_shuffle(_RanIt _First, _RanIt _Last, _Diff *)
+ {
+ ;
+ const int _RANDOM_BITS = 15;
+ const int _RANDOM_MAX = (1U << _RANDOM_BITS) - 1;
+
+ _RanIt _Next = _First;
+ for (unsigned long _Index = 2; ++_Next != _Last; ++_Index)
+ {
+ unsigned long _Rm = _RANDOM_MAX;
+ unsigned long _Rn = ::rand() & _RANDOM_MAX;
+ for (; _Rm < _Index && _Rm != ~0UL;
+ _Rm = _Rm << _RANDOM_BITS | _RANDOM_MAX)
+ _Rn = _Rn << _RANDOM_BITS
+ | (::rand() & _RANDOM_MAX);
+
+ std::iter_swap(_Next, _First + _Diff(_Rn % _Index));
+ }
+ }
+
+template<class _RanIt> inline
+ void random_shuffle(_RanIt _First, _RanIt _Last)
+ {
+ if (_First != _Last)
+ _Random_shuffle(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dist_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Fn1,
+ class _Diff> inline
+ void _Random_shuffle(_RanIt _First, _RanIt _Last, _Fn1& _Func, _Diff *)
+ {
+ ;
+ ;
+ _RanIt _Next = _First;
+
+ for (_Diff _Index = 2; ++_Next != _Last; ++_Index)
+ std::iter_swap(_Next, _First + _Diff(_Func(_Index) % _Index));
+ }
+
+template<class _RanIt,
+ class _Fn1> inline
+ void random_shuffle(_RanIt _First, _RanIt _Last, _Fn1& _Func)
+ {
+ if (_First != _Last)
+ _Random_shuffle(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Func, _Dist_type(_First));
+ }
+
+
+template<class _BidIt,
+ class _Pr> inline
+ _BidIt _Partition(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ for (; ; ++_First)
+ {
+ for (; _First != _Last && _Pred(*_First); ++_First)
+ ;
+ if (_First == _Last)
+ break;
+
+ for (; _First != --_Last && !_Pred(*_Last); )
+ ;
+ if (_First == _Last)
+ break;
+
+ std::iter_swap(_First, _Last);
+ }
+ return (_First);
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ _BidIt partition(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Partition(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_First);
+ }
+
+
+template<class _BidIt,
+ class _Pr,
+ class _Diff,
+ class _Ty> inline
+ _BidIt _Stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred,
+ _Diff _Count, _Temp_iterator<_Ty>& _Tempbuf)
+ {
+ if (_Count == 0)
+ return (_First);
+ else if (_Count == 1)
+ return (_Pred(*_First) ? _Last : _First);
+ else if (_Count <= _Tempbuf._Maxlen())
+ {
+ _BidIt _Next = _First;
+ for (_Tempbuf._Init(); _First != _Last; ++_First)
+ if (_Pred(*_First))
+ *_Next++ = *_First;
+ else
+ *_Tempbuf++ = *_First;
+
+ ::stdext:: unchecked_copy(_Tempbuf._First(), _Tempbuf._Last(), _Next);
+ return (_Next);
+ }
+ else
+ {
+ _BidIt _Mid = _First;
+ std::advance(_Mid, _Count / 2);
+
+ _BidIt _Left = _Stable_partition(_First, _Mid, _Pred,
+ _Count / 2, _Tempbuf);
+ _BidIt _Right = _Stable_partition(_Mid, _Last, _Pred,
+ _Count - _Count / 2, _Tempbuf);
+
+ _Diff _Count1 = 0;
+ _Distance(_Left, _Mid, _Count1);
+ _Diff _Count2 = 0;
+ _Distance(_Mid, _Right, _Count2);
+
+ return (_Buffered_rotate(_Left, _Mid, _Right,
+ _Count1, _Count2, _Tempbuf));
+ }
+ }
+
+template<class _BidIt,
+ class _Pr,
+ class _Diff,
+ class _Ty> inline
+ _BidIt _Stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred,
+ _Diff *, _Ty *)
+ {
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ _Temp_iterator<_Ty> _Tempbuf(_Count);
+ return (_Stable_partition(_First, _Last, _Pred, _Count, _Tempbuf));
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ if (_First != _Last)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Stable_partition(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred, _Dist_type(_First), _Val_type(_First)));
+ }
+ return _First;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Push_heap(_RanIt _First, _Diff _Hole,
+ _Diff _Top, _Ty _Val)
+ {
+ for (_Diff _Idx = (_Hole - 1) / 2;
+ _Top < _Hole && ((*(_First + _Idx)) < (_Val));
+ _Idx = (_Hole - 1) / 2)
+ {
+ *(_First + _Hole) = *(_First + _Idx);
+ _Hole = _Idx;
+ }
+
+ *(_First + _Hole) = _Val;
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Push_heap_0(_RanIt _First, _RanIt _Last, _Diff *, _Ty *)
+ {
+ ;
+ _Diff _Count = _Last - _First;
+ if (0 < _Count)
+ _Push_heap(_First, _Count, _Diff(0), _Ty(*_Last));
+ }
+
+template<class _RanIt> inline
+ void push_heap(_RanIt _First, _RanIt _Last)
+ {
+
+
+
+
+
+
+
+ if (_First != _Last)
+
+
+ _Push_heap_0(::std:: _Checked_base(_First), ::std:: _Checked_base(--_Last),
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Push_heap(_RanIt _First, _Diff _Hole,
+ _Diff _Top, _Ty _Val, _Pr _Pred)
+ {
+ for (_Diff _Idx = (_Hole - 1) / 2;
+ _Top < _Hole && _Pred(*(_First + _Idx), _Val);
+ _Idx = (_Hole - 1) / 2)
+ {
+ *(_First + _Hole) = *(_First + _Idx);
+ _Hole = _Idx;
+ }
+
+ *(_First + _Hole) = _Val;
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Push_heap_0(_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *, _Ty *)
+ {
+ ;
+ _Diff _Count = _Last - _First;
+ if (0 < _Count)
+ _Push_heap(_First, _Count, _Diff(0), _Ty(*_Last), _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+
+
+
+
+
+
+
+ if (_First != _Last)
+
+
+ _Push_heap_0(::std:: _Checked_base(_First), ::std:: _Checked_base(--_Last), _Pred,
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Adjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
+ {
+ _Diff _Top = _Hole;
+ _Diff _Idx = 2 * _Hole + 2;
+
+ for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
+ {
+ if (((*(_First + _Idx)) < (*(_First + (_Idx - 1)))))
+ --_Idx;
+ *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
+ }
+
+ if (_Idx == _Bottom)
+ {
+ *(_First + _Hole) = *(_First + (_Bottom - 1));
+ _Hole = _Bottom - 1;
+ }
+ _Push_heap(_First, _Hole, _Top, _Val);
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Pop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest,
+ _Ty _Val, _Diff *)
+ {
+ *_Dest = *_First;
+ _Adjust_heap(_First, _Diff(0), _Diff(_Last - _First), _Val);
+ }
+
+template<class _RanIt,
+ class _Ty> inline
+ void _Pop_heap_0(_RanIt _First, _RanIt _Last, _Ty *)
+ {
+ _Pop_heap(_First, _Last - 1, _Last - 1,
+ _Ty(*(_Last - 1)), _Dist_type(_First));
+ }
+
+template<class _RanIt> inline
+ void pop_heap(_RanIt _First, _RanIt _Last)
+ {
+ ;
+ if (1 < _Last - _First)
+ _Pop_heap_0(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Adjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom,
+ _Ty _Val, _Pr _Pred)
+ {
+ _Diff _Top = _Hole;
+ _Diff _Idx = 2 * _Hole + 2;
+
+ for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
+ {
+ if (_Pred(*(_First + _Idx), *(_First + (_Idx - 1))))
+ --_Idx;
+ *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
+ }
+
+ if (_Idx == _Bottom)
+ {
+ *(_First + _Hole) = *(_First + (_Bottom - 1));
+ _Hole = _Bottom - 1;
+ }
+ _Push_heap(_First, _Hole, _Top, _Val, _Pred);
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Pop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest,
+ _Ty _Val, _Pr _Pred, _Diff *)
+ {
+ *_Dest = *_First;
+ _Adjust_heap(_First, _Diff(0), _Diff(_Last - _First), _Val, _Pred);
+ }
+
+template<class _RanIt,
+ class _Ty,
+ class _Pr> inline
+ void _Pop_heap_0(_RanIt _First, _RanIt _Last, _Pr _Pred, _Ty *)
+ {
+ _Pop_heap(_First, _Last - 1, _Last - 1,
+ _Ty(*(_Last - 1)), _Pred, _Dist_type(_First));
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+ ;
+ if (1 < _Last - _First)
+ _Pop_heap_0(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred, _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ void _Make_heap(_RanIt _First, _RanIt _Last, _Diff *, _Ty *)
+ {
+ _Diff _Bottom = _Last - _First;
+
+ for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
+ {
+ --_Hole;
+ _Adjust_heap(_First, _Hole, _Bottom, _Ty(*(_First + _Hole)));
+ }
+ }
+
+template<class _RanIt> inline
+ void make_heap(_RanIt _First, _RanIt _Last)
+ {
+ if (1 < _Last - _First)
+ _Make_heap(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last),
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *, _Ty *)
+ {
+ _Diff _Bottom = _Last - _First;
+ for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
+ {
+ --_Hole;
+ _Adjust_heap(_First, _Hole, _Bottom,
+ _Ty(*(_First + _Hole)), _Pred);
+ }
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+ if (1 < _Last - _First)
+ _Make_heap(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred,
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _RanIt> inline
+ void _Sort_heap(_RanIt _First, _RanIt _Last)
+ {
+ ;
+ for (; 1 < _Last - _First; --_Last)
+ std::pop_heap(_First, _Last);
+ }
+
+template<class _RanIt> inline
+ void sort_heap(_RanIt _First, _RanIt _Last)
+ {
+ ;
+ _Sort_heap(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last));
+ }
+
+
+template<class _RanIt,
+ class _Pr> inline
+ void _Sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+ for (; 1 < _Last - _First; --_Last)
+ std::pop_heap(_First, _Last, _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+ ;
+ _Sort_heap(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred);
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff> inline
+ _FwdIt _Lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Diff *)
+ {
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (((*_Mid) < (_Val)))
+ _First = ++_Mid, _Count -= _Count2 + 1;
+ else
+ _Count = _Count2;
+ }
+ return (_First);
+ }
+
+template<class _FwdIt,
+ class _Ty> inline
+ _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Lower_bound(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val, _Dist_type(_First)));
+ return _First;
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff,
+ class _Pr> inline
+ _FwdIt _Lower_bound(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred, _Diff *)
+ {
+ ;
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (_Pred(*_Mid, _Val))
+ _First = ++_Mid, _Count -= _Count2 + 1;
+ else
+ _Count = _Count2;
+ }
+ return (_First);
+ }
+
+template<class _FwdIt,
+ class _Ty,
+ class _Pr> inline
+ _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Lower_bound(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val, _Pred, _Dist_type(_First)));
+ return _First;
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff> inline
+ _FwdIt _Upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Diff *)
+ {
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (!((_Val) < (*_Mid)))
+ _First = ++_Mid, _Count -= _Count2 + 1;
+ else
+ _Count = _Count2;
+ }
+ return (_First);
+ }
+
+template<class _FwdIt,
+ class _Ty> inline
+ _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Upper_bound(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val, _Dist_type(_First)));
+ return _First;
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff,
+ class _Pr> inline
+ _FwdIt _Upper_bound(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred, _Diff *)
+ {
+ ;
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (!_Pred(_Val, *_Mid))
+ _First = ++_Mid, _Count -= _Count2 + 1;
+ else
+ _Count = _Count2;
+ }
+ return (_First);
+ }
+
+template<class _FwdIt,
+ class _Ty,
+ class _Pr> inline
+ _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Upper_bound(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Val, _Pred, _Dist_type(_First)));
+ return _First;
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff> inline
+ pair<_FwdIt, _FwdIt> _Equal_range(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Diff *)
+ {
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (((*_Mid) < (_Val)))
+ {
+ _First = ++_Mid;
+ _Count -= _Count2 + 1;
+ }
+ else if (_Val < *_Mid)
+ _Count = _Count2;
+ else
+ {
+ _FwdIt _First2 = lower_bound(_First, _Mid, _Val);
+ std::advance(_First, _Count);
+ _FwdIt _Last2 = upper_bound(++_Mid, _First, _Val);
+ return (pair<_FwdIt, _FwdIt>(_First2, _Last2));
+ }
+ }
+
+ return (pair<_FwdIt, _FwdIt>(_First, _First));
+ }
+
+template<class _FwdIt,
+ class _Ty> inline
+ pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val)
+ {
+ return (_Equal_range(_First, _Last, _Val, _Dist_type(_First)));
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Diff,
+ class _Pr> inline
+ pair<_FwdIt, _FwdIt> _Equal_range(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred, _Diff *)
+ {
+ ;
+ ;
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+
+ for (; 0 < _Count; )
+ {
+ _Diff _Count2 = _Count / 2;
+ _FwdIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+ ;
+
+ if (_Pred(*_Mid, _Val))
+ {
+ _First = ++_Mid;
+ _Count -= _Count2 + 1;
+ }
+ else if (_Pred(_Val, *_Mid))
+ _Count = _Count2;
+ else
+ {
+ _FwdIt _First2 = lower_bound(_First, _Mid, _Val, _Pred);
+ std::advance(_First, _Count);
+ _FwdIt _Last2 = upper_bound(++_Mid, _First, _Val, _Pred);
+ return (pair<_FwdIt, _FwdIt>(_First2, _Last2));
+ }
+ }
+
+ return (pair<_FwdIt, _FwdIt>(_First, _First));
+ }
+
+template<class _FwdIt,
+ class _Ty,
+ class _Pr> inline
+ pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred)
+ {
+ return (_Equal_range(_First, _Last, _Val, _Pred, _Dist_type(_First)));
+ }
+
+
+template<class _FwdIt,
+ class _Ty> inline
+ bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
+ {
+ _First = std::lower_bound(_First, _Last, _Val);
+ return (_First != _Last && !(_Val < *_First));
+ }
+
+
+template<class _FwdIt,
+ class _Ty,
+ class _Pr> inline
+ bool binary_search(_FwdIt _First, _FwdIt _Last,
+ const _Ty& _Val, _Pr _Pred)
+ {
+ _First = std::lower_bound(_First, _Last, _Val, _Pred);
+ return (_First != _Last && !_Pred(_Val, *_First));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _InOutItCat>
+inline
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest,
+ _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; ++_Dest)
+ if (((*_First2) < (*_First1)))
+ *_Dest = *_First2, ++_First2;
+ else
+ *_Dest = *_First1, ++_First1;
+
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt>
+inline
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last1 - _First1) + (_Last2 - _First2);
+ _Merge(_First1, _Last1, _First2, _Last2, ::std:: _Checked_base(_Dest),
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Merge(_First1, _Last1, _First2, _Last2, _Dest, _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return _Merge(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ _Iter_random(_First1, _First2, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr, class _InOutItCat>
+inline
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred,
+ _InOutItCat, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; ++_Dest)
+ if (_Pred(*_First2, *_First1))
+ *_Dest = *_First2, ++_First2;
+ else
+ *_Dest = *_First1, ++_First1;
+
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr>
+inline
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred,
+ random_access_iterator_tag, _Range_checked_iterator_tag)
+ {
+
+ _OutIt _Result = _Dest + (_Last1 - _First1) + (_Last2 - _First2);
+ _Merge(_First1, _Last1, _First2, _Last2, ::std:: _Checked_base(_Dest), _Pred,
+ forward_iterator_tag(), _Range_checked_iterator_tag());
+ return _Result;
+ }
+
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr, class _InOutItCat>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _InOutItCat _First_dest_cat, _Unchecked_iterator_tag)
+ {
+ return _Merge(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _First_dest_cat, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Merge(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, _Pred,
+ _Iter_random(_First1, _First2, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ _BidIt _Buffered_rotate(_BidIt _First, _BidIt _Mid, _BidIt _Last,
+ _Diff _Count1, _Diff _Count2, _Temp_iterator<_Ty>& _Tempbuf)
+ {
+ if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_First, _Mid, _Tempbuf._Init());
+ ::stdext:: unchecked_copy(_Mid, _Last, _First);
+ return (::stdext:: unchecked_copy_backward(_Tempbuf._First(), _Tempbuf._Last(),
+ _Last));
+ }
+ else if (_Count2 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_Mid, _Last, _Tempbuf._Init());
+ ::stdext:: unchecked_copy_backward(_First, _Mid, _Last);
+ return (::stdext:: unchecked_copy(_Tempbuf._First(), _Tempbuf._Last(), _First));
+ }
+ else
+ {
+ std::rotate(_First, _Mid, _Last);
+ std::advance(_First, _Count2);
+ return (_First);
+ }
+ }
+
+template<class _BidIt1,
+ class _BidIt2,
+ class _BidIt3> inline
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Range_checked_iterator_tag)
+ {
+ for (; ; )
+ if (_First1 == _Last1)
+ return (::stdext:: unchecked_copy_backward(_First2, _Last2, _Dest));
+ else if (_First2 == _Last2)
+ return (::stdext:: unchecked_copy_backward(_First1, _Last1, _Dest));
+ else if (((*--_Last2) < (*--_Last1)))
+ *--_Dest = *_Last1, ++_Last2;
+ else
+ *--_Dest = *_Last2, ++_Last1;
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _BidIt3>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Unchecked_iterator_tag)
+ {
+ return _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _BidIt3>
+inline
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
+ {
+ return _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ void _Buffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
+ _Diff _Count1, _Diff _Count2,
+ _Temp_iterator<_Ty>& _Tempbuf)
+ {
+ if (_Count1 + _Count2 == 2)
+ {
+ if (((*_Mid) < (*_First)))
+ std::iter_swap(_First, _Mid);
+ }
+ else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_First, _Mid, _Tempbuf._Init());
+ ::stdext:: unchecked_merge(_Tempbuf._First(), _Tempbuf._Last(), _Mid, _Last, _First);
+ }
+ else if (_Count2 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_Mid, _Last, _Tempbuf._Init());
+ ::stdext:: _Unchecked_merge_backward(_First, _Mid,
+ _Tempbuf._First(), _Tempbuf._Last(), _Last);
+ }
+ else
+ {
+ _BidIt _Firstn, _Lastn;
+ _Diff _Count1n, _Count2n;
+
+ if (_Count2 < _Count1)
+ {
+ _Count1n = _Count1 / 2, _Count2n = 0;
+ _Firstn = _First;
+ std::advance(_Firstn, _Count1n);
+ _Lastn = std::lower_bound(_Mid, _Last, *_Firstn);
+ _Distance(_Mid, _Lastn, _Count2n);
+ }
+ else
+ {
+ _Count1n = 0, _Count2n = _Count2 / 2;
+ _Lastn = _Mid;
+ std::advance(_Lastn, _Count2n);
+ _Firstn = std::upper_bound(_First, _Mid, *_Lastn);
+ _Distance(_First, _Firstn, _Count1n);
+ }
+
+ _BidIt _Midn = _Buffered_rotate(_Firstn, _Mid, _Lastn,
+ _Count1 - _Count1n, _Count2n, _Tempbuf);
+ _Buffered_merge(_First, _Firstn, _Midn,
+ _Count1n, _Count2n, _Tempbuf);
+ _Buffered_merge(_Midn, _Lastn, _Last,
+ _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ void _Inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
+ _Diff *, _Ty *)
+ {
+ ;
+ ;
+ _Diff _Count1 = 0;
+ _Distance(_First, _Mid, _Count1);
+ _Diff _Count2 = 0;
+ _Distance(_Mid, _Last, _Count2);
+ _Temp_iterator<_Ty> _Tempbuf(_Count1 < _Count2 ? _Count1 : _Count2);
+ _Buffered_merge(_First, _Mid, _Last,
+ _Count1, _Count2, _Tempbuf);
+ }
+
+template<class _BidIt> inline
+ void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last)
+ {
+ if (_First != _Mid && _Mid != _Last)
+ _Inplace_merge(::std:: _Checked_base(_First), ::std:: _Checked_base(_Mid), ::std:: _Checked_base(_Last),
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _BidIt1,
+ class _BidIt2,
+ class _BidIt3,
+ class _Pr> inline
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ for (; ; )
+ if (_First1 == _Last1)
+ return (::stdext:: unchecked_copy_backward(_First2, _Last2, _Dest));
+ else if (_First2 == _Last2)
+ return (::stdext:: unchecked_copy_backward(_First1, _Last1, _Dest));
+ else if (_Pred(*--_Last2, *--_Last1))
+ *--_Dest = *_Last1, ++_Last2;
+ else
+ *--_Dest = *_Last2, ++_Last1;
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _BidIt3, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _Unchecked_iterator_tag);
+ }
+
+
+template<class _BidIt1, class _BidIt2, class _BidIt3, class _Pr>
+inline
+ _BidIt3 _Merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
+ {
+ return _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Buffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
+ _Diff _Count1, _Diff _Count2,
+ _Temp_iterator<_Ty>& _Tempbuf, _Pr _Pred)
+ {
+ if (_Count1 + _Count2 == 2)
+ {
+ if (_Pred(*_Mid, *_First))
+ std::iter_swap(_First, _Mid);
+ }
+ else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_First, _Mid, _Tempbuf._Init());
+ ::stdext:: unchecked_merge(_Tempbuf._First(), _Tempbuf._Last(),
+ _Mid, _Last, _First, _Pred);
+ }
+ else if (_Count2 <= _Tempbuf._Maxlen())
+ {
+ ::stdext:: unchecked_copy(_Mid, _Last, _Tempbuf._Init());
+ ::stdext:: _Unchecked_merge_backward(_First, _Mid, _Tempbuf._First(), _Tempbuf._Last(),
+ _Last, _Pred);
+ }
+ else
+ {
+ _BidIt _Firstn, _Lastn;
+ _Diff _Count1n, _Count2n;
+ if (_Count2 < _Count1)
+ {
+ _Count1n = _Count1 / 2, _Count2n = 0;
+ _Firstn = _First;
+ std::advance(_Firstn, _Count1n);
+ _Lastn = lower_bound(_Mid, _Last, *_Firstn, _Pred);
+ _Distance(_Mid, _Lastn, _Count2n);
+ }
+ else
+ {
+ _Count1n = 0, _Count2n = _Count2 / 2;
+ _Lastn = _Mid;
+ std::advance(_Lastn, _Count2n);
+ _Firstn = upper_bound(_First, _Mid, *_Lastn, _Pred);
+ _Distance(_First, _Firstn, _Count1n);
+ }
+ _BidIt _Midn = _Buffered_rotate(_Firstn, _Mid, _Lastn,
+ _Count1 - _Count1n, _Count2n, _Tempbuf);
+ _Buffered_merge(_First, _Firstn, _Midn,
+ _Count1n, _Count2n, _Tempbuf, _Pred);
+ _Buffered_merge(_Midn, _Lastn, _Last,
+ _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf, _Pred);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred,
+ _Diff *, _Ty *)
+ {
+ ;
+ ;
+ _Diff _Count1 = 0;
+ _Distance(_First, _Mid, _Count1);
+ _Diff _Count2 = 0;
+ _Distance(_Mid, _Last, _Count2);
+ _Temp_iterator<_Ty> _Tempbuf(_Count1 < _Count2 ? _Count1 : _Count2);
+ _Buffered_merge(_First, _Mid, _Last,
+ _Count1, _Count2, _Tempbuf, _Pred);
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
+ {
+ if (_First != _Mid && _Mid != _Last)
+ _Inplace_merge(::std:: _Checked_base(_First), ::std:: _Checked_base(_Mid), ::std:: _Checked_base(_Last), _Pred,
+ _Dist_type(_First), _Val_type(_First));
+ }
+
+
+template<class _BidIt,
+ class _Ty> inline
+ void _Insertion_sort1(_BidIt _First, _BidIt _Last, _Ty *)
+ {
+ if (_First != _Last)
+ for (_BidIt _Next = _First; ++_Next != _Last; )
+ {
+ _BidIt _Next1 = _Next;
+ _Ty _Val = *_Next;
+
+ if (((_Val) < (*_First)))
+ {
+ ::stdext:: unchecked_copy_backward(_First, _Next, ++_Next1);
+ *_First = _Val;
+ }
+ else
+ {
+ for (_BidIt _First1 = _Next1;
+ ((_Val) < (*--_First1));
+ _Next1 = _First1)
+ *_Next1 = *_First1;
+ *_Next1 = _Val;
+ }
+ }
+ }
+
+template<class _BidIt> inline
+ void _Insertion_sort(_BidIt _First, _BidIt _Last)
+ {
+ _Insertion_sort1(_First, _Last, _Val_type(_First));
+ }
+
+template<class _RanIt> inline
+ void _Med3(_RanIt _First, _RanIt _Mid, _RanIt _Last)
+ {
+ if (((*_Mid) < (*_First)))
+ std::iter_swap(_Mid, _First);
+ if (((*_Last) < (*_Mid)))
+ std::iter_swap(_Last, _Mid);
+ if (((*_Mid) < (*_First)))
+ std::iter_swap(_Mid, _First);
+ }
+
+template<class _RanIt> inline
+ void _Median(_RanIt _First, _RanIt _Mid, _RanIt _Last)
+ {
+ if (40 < _Last - _First)
+ {
+ size_t _Step = (_Last - _First + 1) / 8;
+ _Med3(_First, _First + _Step, _First + 2 * _Step);
+ _Med3(_Mid - _Step, _Mid, _Mid + _Step);
+ _Med3(_Last - 2 * _Step, _Last - _Step, _Last);
+ _Med3(_First + _Step, _Mid, _Last - _Step);
+ }
+ else
+ _Med3(_First, _Mid, _Last);
+ }
+
+template<class _RanIt> inline
+ pair<_RanIt, _RanIt> _Unguarded_partition(_RanIt _First, _RanIt _Last)
+ {
+ _RanIt _Mid = _First + (_Last - _First) / 2;
+ _Median(_First, _Mid, _Last - 1);
+ _RanIt _Pfirst = _Mid;
+ _RanIt _Plast = _Pfirst + 1;
+
+ while (_First < _Pfirst
+ && !((*(_Pfirst - 1)) < (*_Pfirst))
+ && !(*_Pfirst < *(_Pfirst - 1)))
+ --_Pfirst;
+ while (_Plast < _Last
+ && !((*_Plast) < (*_Pfirst))
+ && !(*_Pfirst < *_Plast))
+ ++_Plast;
+
+ _RanIt _Gfirst = _Plast;
+ _RanIt _Glast = _Pfirst;
+
+ for (; ; )
+ {
+ for (; _Gfirst < _Last; ++_Gfirst)
+ if (((*_Pfirst) < (*_Gfirst)))
+ ;
+ else if (*_Gfirst < *_Pfirst)
+ break;
+ else
+ std::iter_swap(_Plast++, _Gfirst);
+ for (; _First < _Glast; --_Glast)
+ if (((*(_Glast - 1)) < (*_Pfirst)))
+ ;
+ else if (*_Pfirst < *(_Glast - 1))
+ break;
+ else
+ std::iter_swap(--_Pfirst, _Glast - 1);
+ if (_Glast == _First && _Gfirst == _Last)
+ return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));
+
+ if (_Glast == _First)
+ {
+ if (_Plast != _Gfirst)
+ std::iter_swap(_Pfirst, _Plast);
+ ++_Plast;
+ std::iter_swap(_Pfirst++, _Gfirst++);
+ }
+ else if (_Gfirst == _Last)
+ {
+ if (--_Glast != --_Pfirst)
+ std::iter_swap(_Glast, _Pfirst);
+ std::iter_swap(_Pfirst, --_Plast);
+ }
+ else
+ std::iter_swap(_Gfirst++, --_Glast);
+ }
+ }
+
+template<class _RanIt,
+ class _Diff> inline
+ void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
+ {
+ _Diff _Count;
+ for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
+ {
+ pair<_RanIt, _RanIt> _Mid = _Unguarded_partition(_First, _Last);
+ _Ideal /= 2, _Ideal += _Ideal / 2;
+
+ if (_Mid.first - _First < _Last - _Mid.second)
+ _Sort(_First, _Mid.first, _Ideal), _First = _Mid.second;
+ else
+ _Sort(_Mid.second, _Last, _Ideal), _Last = _Mid.first;
+ }
+
+ if (_ISORT_MAX < _Count)
+ {
+ std::make_heap(_First, _Last);
+ std::sort_heap(_First, _Last);
+ }
+ else if (1 < _Count)
+ _Insertion_sort(_First, _Last);
+ }
+
+template<class _RanIt> inline
+ void sort(_RanIt _First, _RanIt _Last)
+ {
+ ;
+ _Sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Last - _First);
+ }
+
+
+template<class _BidIt,
+ class _Pr> inline
+ void _Insertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ if (_First != _Last)
+ for (_BidIt _Next = _First; ++_Next != _Last; )
+ if (_Pred(*_Next, *_First))
+ {
+ _BidIt _Next1 = _Next;
+ std::rotate(_First, _Next, ++_Next1);
+ }
+ else
+ {
+ _BidIt _Dest = _Next;
+ for (_BidIt _Dest0 = _Dest;
+ _Pred(*_Next, *--_Dest0); )
+ _Dest = _Dest0;
+ if (_Dest != _Next)
+ {
+ _BidIt _Next1 = _Next;
+ std::rotate(_Dest, _Next, ++_Next1);
+ }
+ }
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void _Med3(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
+ {
+ if (_Pred(*_Mid, *_First))
+ std::iter_swap(_Mid, _First);
+ if (_Pred(*_Last, *_Mid))
+ std::iter_swap(_Last, _Mid);
+ if (_Pred(*_Mid, *_First))
+ std::iter_swap(_Mid, _First);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void _Median(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
+ {
+ if (40 < _Last - _First)
+ {
+ size_t _Step = (_Last - _First + 1) / 8;
+ _Med3(_First, _First + _Step, _First + 2 * _Step, _Pred);
+ _Med3(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
+ _Med3(_Last - 2 * _Step, _Last - _Step, _Last, _Pred);
+ _Med3(_First + _Step, _Mid, _Last - _Step, _Pred);
+ }
+ else
+ _Med3(_First, _Mid, _Last, _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ pair<_RanIt, _RanIt> _Unguarded_partition(_RanIt _First, _RanIt _Last,
+ _Pr _Pred)
+ {
+ _RanIt _Mid = _First + (_Last - _First) / 2;
+ _Median(_First, _Mid, _Last - 1, _Pred);
+ _RanIt _Pfirst = _Mid;
+ _RanIt _Plast = _Pfirst + 1;
+
+ while (_First < _Pfirst
+ && !_Pred(*(_Pfirst - 1), *_Pfirst)
+ && !_Pred(*_Pfirst, *(_Pfirst - 1)))
+ --_Pfirst;
+ while (_Plast < _Last
+ && !_Pred(*_Plast, *_Pfirst)
+ && !_Pred(*_Pfirst, *_Plast))
+ ++_Plast;
+
+ _RanIt _Gfirst = _Plast;
+ _RanIt _Glast = _Pfirst;
+
+ for (; ; )
+ {
+ for (; _Gfirst < _Last; ++_Gfirst)
+ if (_Pred(*_Pfirst, *_Gfirst))
+ ;
+ else if (_Pred(*_Gfirst, *_Pfirst))
+ break;
+ else
+ std::iter_swap(_Plast++, _Gfirst);
+ for (; _First < _Glast; --_Glast)
+ if (_Pred(*(_Glast - 1), *_Pfirst))
+ ;
+ else if (_Pred(*_Pfirst, *(_Glast - 1)))
+ break;
+ else
+ std::iter_swap(--_Pfirst, _Glast - 1);
+ if (_Glast == _First && _Gfirst == _Last)
+ return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));
+
+ if (_Glast == _First)
+ {
+ if (_Plast != _Gfirst)
+ std::iter_swap(_Pfirst, _Plast);
+ ++_Plast;
+ std::iter_swap(_Pfirst++, _Gfirst++);
+ }
+ else if (_Gfirst == _Last)
+ {
+ if (--_Glast != --_Pfirst)
+ std::iter_swap(_Glast, _Pfirst);
+ std::iter_swap(_Pfirst, --_Plast);
+ }
+ else
+ std::iter_swap(_Gfirst++, --_Glast);
+ }
+ }
+
+template<class _RanIt,
+ class _Diff,
+ class _Pr> inline
+ void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
+ {
+ _Diff _Count;
+ for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
+ {
+ pair<_RanIt, _RanIt> _Mid =
+ _Unguarded_partition(_First, _Last, _Pred);
+ _Ideal /= 2, _Ideal += _Ideal / 2;
+
+ if (_Mid.first - _First < _Last - _Mid.second)
+ _Sort(_First, _Mid.first, _Ideal, _Pred), _First = _Mid.second;
+ else
+ _Sort(_Mid.second, _Last, _Ideal, _Pred), _Last = _Mid.first;
+ }
+
+ if (_ISORT_MAX < _Count)
+ {
+ std::make_heap(_First, _Last, _Pred);
+ std::sort_heap(_First, _Last, _Pred);
+ }
+ else if (1 < _Count)
+ _Insertion_sort(_First, _Last, _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ _Sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Last - _First, _Pred);
+ }
+
+
+template<class _BidIt,
+ class _OutIt,
+ class _Diff> inline
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Range_checked_iterator_tag)
+ {
+ for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
+ {
+ _BidIt _Mid1 = _First;
+ std::advance(_Mid1, _Chunk);
+ _BidIt _Mid2 = _Mid1;
+ std::advance(_Mid2, _Chunk);
+
+ _Dest = ::stdext:: unchecked_merge(_First, _Mid1, _Mid1, _Mid2, _Dest);
+ _First = _Mid2;
+ }
+
+ if (_Count <= _Chunk)
+ ::stdext:: unchecked_copy(_First, _Last, _Dest);
+ else
+ {
+ _BidIt _Mid = _First;
+ std::advance(_Mid, _Chunk);
+
+ ::stdext:: unchecked_merge(_First, _Mid, _Mid, _Last, _Dest);
+ }
+ }
+
+
+template<class _BidIt, class _OutIt, class _Diff>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Unchecked_iterator_tag)
+ {
+ _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt, class _OutIt, class _Diff>
+inline
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count)
+ {
+ _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ void _Buffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
+ _Temp_iterator<_Ty>& _Tempbuf)
+ {
+ _BidIt _Mid = _First;
+ for (_Diff _Nleft = _Count; _ISORT_MAX <= _Nleft; _Nleft -= _ISORT_MAX)
+ {
+ _BidIt _Midend = _Mid;
+ std::advance(_Midend, (int)_ISORT_MAX);
+
+ _Insertion_sort(_Mid, _Midend);
+ _Mid = _Midend;
+ }
+ _Insertion_sort(_Mid, _Last);
+
+ for (_Diff _Chunk = _ISORT_MAX; _Chunk < _Count; _Chunk *= 2)
+ {
+ ::stdext:: _Unchecked_chunked_merge(_First, _Last, _Tempbuf._Init(),
+ _Chunk, _Count);
+ ::stdext:: _Unchecked_chunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
+ _Chunk *= 2, _Count);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ void _Stable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
+ _Temp_iterator<_Ty>& _Tempbuf)
+ {
+ if (_Count <= _ISORT_MAX)
+ _Insertion_sort(_First, _Last);
+ else
+ {
+ _Diff _Count2 = (_Count + 1) / 2;
+ _BidIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+
+ if (_Count2 <= _Tempbuf._Maxlen())
+ {
+ _Buffered_merge_sort(_First, _Mid, _Count2, _Tempbuf);
+ _Buffered_merge_sort(_Mid, _Last, _Count - _Count2, _Tempbuf);
+ }
+ else
+ {
+ _Stable_sort(_First, _Mid, _Count2, _Tempbuf);
+ _Stable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf);
+ }
+
+ _Buffered_merge(_First, _Mid, _Last,
+ _Count2, _Count - _Count2, _Tempbuf);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty> inline
+ void _Stable_sort(_BidIt _First, _BidIt _Last, _Diff *, _Ty *)
+ {
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ _Temp_iterator<_Ty> _Tempbuf((_Count + 1) / 2);
+ _Stable_sort(_First, _Last, _Count, _Tempbuf);
+ }
+
+template<class _BidIt> inline
+ void stable_sort(_BidIt _First, _BidIt _Last)
+ {
+ ;
+ if (_First != _Last)
+ {
+ _Stable_sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dist_type(_First), _Val_type(_First));
+ }
+ }
+
+
+template<class _BidIt,
+ class _OutIt,
+ class _Diff,
+ class _Pr> inline
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
+ {
+ _BidIt _Mid1 = _First;
+ std::advance(_Mid1, _Chunk);
+ _BidIt _Mid2 = _Mid1;
+ std::advance(_Mid2, _Chunk);
+
+ _Dest = ::stdext:: unchecked_merge(_First, _Mid1, _Mid1, _Mid2, _Dest, _Pred);
+ _First = _Mid2;
+ }
+
+ if (_Count <= _Chunk)
+ ::stdext:: unchecked_copy(_First, _Last, _Dest);
+ else
+ {
+ _BidIt _Mid1 = _First;
+ std::advance(_Mid1, _Chunk);
+
+ ::stdext:: unchecked_merge(_First, _Mid1, _Mid1, _Last, _Dest, _Pred);
+ }
+ }
+
+
+template<class _BidIt, class _OutIt, class _Diff, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _BidIt, class _OutIt, class _Diff, class _Pr>
+inline
+ void _Chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Pr _Pred)
+ {
+ _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Buffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
+ _Temp_iterator<_Ty>& _Tempbuf, _Pr _Pred)
+ {
+ _BidIt _Mid = _First;
+ for (_Diff _Nleft = _Count; _ISORT_MAX <= _Nleft; _Nleft -= _ISORT_MAX)
+ {
+ _BidIt _Midn = _Mid;
+ std::advance(_Midn, (int)_ISORT_MAX);
+
+ _Insertion_sort(_Mid, _Midn, _Pred);
+ _Mid = _Midn;
+ }
+ _Insertion_sort(_Mid, _Last, _Pred);
+
+ for (_Diff _Chunk = _ISORT_MAX; _Chunk < _Count; _Chunk *= 2)
+ {
+ ::stdext:: _Unchecked_chunked_merge(_First, _Last, _Tempbuf._Init(),
+ _Chunk, _Count, _Pred);
+ ::stdext:: _Unchecked_chunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
+ _Chunk *= 2, _Count, _Pred);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Stable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
+ _Temp_iterator<_Ty>& _Tempbuf, _Pr _Pred)
+ {
+ if (_Count <= _ISORT_MAX)
+ _Insertion_sort(_First, _Last, _Pred);
+ else
+ {
+ _Diff _Count2 = (_Count + 1) / 2;
+ _BidIt _Mid = _First;
+ std::advance(_Mid, _Count2);
+
+ if (_Count2 <= _Tempbuf._Maxlen())
+ {
+ _Buffered_merge_sort(_First, _Mid, _Count2, _Tempbuf, _Pred);
+ _Buffered_merge_sort(_Mid, _Last, _Count - _Count2,
+ _Tempbuf, _Pred);
+ }
+ else
+ {
+ _Stable_sort(_First, _Mid, _Count2, _Tempbuf, _Pred);
+ _Stable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf, _Pred);
+ }
+
+ _Buffered_merge(_First, _Mid, _Last,
+ _Count2, _Count - _Count2, _Tempbuf, _Pred);
+ }
+ }
+
+template<class _BidIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ void _Stable_sort(_BidIt _First, _BidIt _Last, _Diff *, _Ty *, _Pr _Pred)
+ {
+ _Diff _Count = 0;
+ _Distance(_First, _Last, _Count);
+ _Temp_iterator<_Ty> _Tempbuf((_Count + 1) / 2);
+ _Stable_sort(_First, _Last, _Count, _Tempbuf, _Pred);
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ void stable_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ if (_First != _Last)
+ {
+ _Stable_sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last),
+ _Dist_type(_First), _Val_type(_First), _Pred);
+ }
+ }
+
+
+template<class _RanIt,
+ class _Ty> inline
+ void _Partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Ty *)
+ {
+ ;
+ ;
+ std::make_heap(_First, _Mid);
+
+ for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
+ if (((*_Next) < (*_First)))
+ _Pop_heap(_First, _Mid, _Next, _Ty(*_Next),
+ _Dist_type(_First));
+ std::sort_heap(_First, _Mid);
+ }
+
+template<class _RanIt> inline
+ void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last)
+ {
+ _Partial_sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Mid), ::std:: _Checked_base(_Last), _Val_type(_First));
+ }
+
+
+template<class _RanIt,
+ class _Ty,
+ class _Pr> inline
+ void _Partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last,
+ _Pr _Pred, _Ty *)
+ {
+ ;
+ ;
+ ;
+ std::make_heap(_First, _Mid, _Pred);
+
+ for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
+ if (_Pred(*_Next, *_First))
+ _Pop_heap(_First, _Mid, _Next, _Ty(*_Next), _Pred,
+ _Dist_type(_First));
+ std::sort_heap(_First, _Mid, _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
+ {
+ _Partial_sort(::std:: _Checked_base(_First), ::std:: _Checked_base(_Mid), ::std:: _Checked_base(_Last), _Pred, _Val_type(_First));
+ }
+
+
+template<class _InIt,
+ class _RanIt,
+ class _Diff,
+ class _Ty> inline
+ _RanIt _Partial_sort_copy(_InIt _First1, _InIt _Last1,
+ _RanIt _First2, _RanIt _Last2, _Diff *, _Ty *)
+ {
+ ;
+ ;
+ _RanIt _Mid2 = _First2;
+ for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
+ *_Mid2 = *_First1;
+ std::make_heap(_First2, _Mid2);
+
+ for (; _First1 != _Last1; ++_First1)
+ if (((*_First1) < (*_First2)))
+ _Adjust_heap(_First2, _Diff(0), _Diff(_Mid2 - _First2),
+ _Ty(*_First1));
+
+ std::sort_heap(_First2, _Mid2);
+ return (_Mid2);
+ }
+
+template<class _InIt,
+ class _RanIt> inline
+ _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
+ _RanIt _First2, _RanIt _Last2)
+ {
+ if (_First1 != _Last1 && _First2 != _Last2)
+ ::std:: _Checked_assign_from_base(_First2, _Partial_sort_copy(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dist_type(_First2), _Val_type(_First1)));
+ return (_First2);
+ }
+
+
+template<class _InIt,
+ class _RanIt,
+ class _Diff,
+ class _Ty,
+ class _Pr> inline
+ _RanIt _Partial_sort_copy(_InIt _First1, _InIt _Last1,
+ _RanIt _First2, _RanIt _Last2, _Pr _Pred, _Diff *, _Ty *)
+ {
+ ;
+ ;
+ ;
+ _RanIt _Mid2 = _First2;
+ for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
+ *_Mid2 = *_First1;
+ std::make_heap(_First2, _Mid2, _Pred);
+
+ for (; _First1 != _Last1; ++_First1)
+ if (_Pred(*_First1, *_First2))
+ _Adjust_heap(_First2, _Diff(0), _Diff(_Mid2 - _First2),
+ _Ty(*_First1), _Pred);
+
+ std::sort_heap(_First2, _Mid2, _Pred);
+ return (_Mid2);
+ }
+
+template<class _InIt,
+ class _RanIt,
+ class _Pr> inline
+ _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
+ _RanIt _First2, _RanIt _Last2, _Pr _Pred)
+ {
+ if (_First1 != _Last1 && _First2 != _Last2)
+ ::std:: _Checked_assign_from_base(_First2, _Partial_sort_copy(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred, _Dist_type(_First2), _Val_type(_First1)));
+ return (_First2);
+ }
+
+
+template<class _RanIt> inline
+ void _Nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last)
+ {
+ ;
+ for (; _ISORT_MAX < _Last - _First; )
+ {
+ pair<_RanIt, _RanIt> _Mid =
+ _Unguarded_partition(_First, _Last);
+
+ if (_Mid.second <= _Nth)
+ _First = _Mid.second;
+ else if (_Mid.first <= _Nth)
+ return;
+ else
+ _Last = _Mid.first;
+ }
+
+ _Insertion_sort(_First, _Last);
+ }
+
+template<class _RanIt> inline
+ void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last)
+ {
+ _Nth_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Nth), ::std:: _Checked_base(_Last));
+ }
+
+
+template<class _RanIt,
+ class _Pr> inline
+ void _Nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ for (; _ISORT_MAX < _Last - _First; )
+ {
+ pair<_RanIt, _RanIt> _Mid =
+ _Unguarded_partition(_First, _Last, _Pred);
+
+ if (_Mid.second <= _Nth)
+ _First = _Mid.second;
+ else if (_Mid.first <= _Nth)
+ return;
+ else
+ _Last = _Mid.first;
+ }
+
+ _Insertion_sort(_First, _Last, _Pred);
+ }
+
+template<class _RanIt,
+ class _Pr> inline
+ void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
+ {
+ _Nth_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Nth), ::std:: _Checked_base(_Last), _Pred);
+ }
+
+
+template<class _InIt1,
+ class _InIt2> inline
+ bool _Includes(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2)
+ {
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (((*_First2) < (*_First1)))
+ return (false);
+ else if (*_First1 < *_First2)
+ ++_First1;
+ else
+ ++_First1, ++_First2;
+ return (_First2 == _Last2);
+ }
+
+template<class _InIt1,
+ class _InIt2> inline
+ bool includes(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2)
+ {
+ return _Includes(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _Pr> inline
+ bool _Includes(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
+ {
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (_Pred(*_First2, *_First1))
+ return (false);
+ else if (_Pred(*_First1, *_First2))
+ ++_First1;
+ else
+ ++_First1, ++_First2;
+ return (_First2 == _Last2);
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _Pr> inline
+ bool includes(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
+ {
+ return _Includes(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Pred);
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt _Set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (((*_First1) < (*_First2)))
+ *_Dest++ = *_First1, ++_First1;
+ else if (*_First2 < *_First1)
+ *_Dest++ = *_First2, ++_First2;
+ else
+ *_Dest++ = *_First1, ++_First1, ++_First2;
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Unchecked_iterator_tag)
+ {
+ return _Set_union(_First1, _Last1, _First2, _Last2, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (_Pred(*_First1, *_First2))
+ *_Dest++ = *_First1, ++_First1;
+ else if (_Pred(*_First2, *_First1))
+ *_Dest++ = *_First2, ++_First2;
+ else
+ *_Dest++ = *_First1, ++_First1, ++_First2;
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Set_union(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt _Set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (((*_First1) < (*_First2)))
+ ++_First1;
+ else if (*_First2 < *_First1)
+ ++_First2;
+ else
+ *_Dest++ = *_First1++, ++_First2;
+ return (_Dest);
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Unchecked_iterator_tag)
+ {
+ return _Set_intersection(_First1, _Last1, _First2, _Last2, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (_Pred(*_First1, *_First2))
+ ++_First1;
+ else if (_Pred(*_First2, *_First1))
+ ++_First2;
+ else
+ *_Dest++ = *_First1++, ++_First2;
+ return (_Dest);
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Set_intersection(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt _Set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (((*_First1) < (*_First2)))
+ *_Dest++ = *_First1, ++_First1;
+ else if (*_First2 < *_First1)
+ ++_First2;
+ else
+ ++_First1, ++_First2;
+ return (::stdext:: unchecked_copy(_First1, _Last1, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Unchecked_iterator_tag)
+ {
+ return _Set_difference(_First1, _Last1, _First2, _Last2, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (_Pred(*_First1, *_First2))
+ *_Dest++ = *_First1, ++_First1;
+ else if (_Pred(*_First2, *_First1))
+ ++_First2;
+ else
+ ++_First1, ++_First2;
+ return (::stdext:: unchecked_copy(_First1, _Last1, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Set_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt _Set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (((*_First1) < (*_First2)))
+ *_Dest++ = *_First1, ++_First1;
+ else if (*_First2 < *_First1)
+ *_Dest++ = *_First2, ++_First2;
+ else
+ ++_First1, ++_First2;
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Unchecked_iterator_tag)
+ {
+ return _Set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt _Set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Range_checked_iterator_tag)
+ {
+ ;
+ ;
+ ;
+ for (; _First1 != _Last1 && _First2 != _Last2; )
+ if (_Pred(*_First1, *_First2))
+ *_Dest++ = *_First1, ++_First1;
+ else if (_Pred(*_First2, *_First1))
+ *_Dest++ = *_First2, ++_First2;
+ else
+ ++_First1, ++_First2;
+ _Dest = ::stdext:: unchecked_copy(_First1, _Last1, _Dest);
+ return (::stdext:: unchecked_copy(_First2, _Last2, _Dest));
+ }
+
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Pr>
+inline
+__declspec(deprecated("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library"))
+ _OutIt _Set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred, _Unchecked_iterator_tag)
+ {
+ return _Set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pred, _Range_checked_iterator_tag());
+ }
+
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1),
+ ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2),
+ _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+
+template<class _FwdIt> inline
+ _FwdIt _Max_element(_FwdIt _First, _FwdIt _Last)
+ {
+ ;
+ _FwdIt _Found = _First;
+ if (_First != _Last)
+ for (; ++_First != _Last; )
+ if (((*_Found) < (*_First)))
+ _Found = _First;
+ return (_Found);
+ }
+
+template<class _FwdIt> inline
+ _FwdIt max_element(_FwdIt _First, _FwdIt _Last)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Max_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last)));
+ return (_First);
+ }
+
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt _Max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ _FwdIt _Found = _First;
+ if (_First != _Last)
+ for (; ++_First != _Last; )
+ if (_Pred(*_Found, *_First))
+ _Found = _First;
+ return (_Found);
+ }
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Max_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_First);
+ }
+
+
+template<class _FwdIt> inline
+ _FwdIt _Min_element(_FwdIt _First, _FwdIt _Last)
+ {
+ ;
+ _FwdIt _Found = _First;
+ if (_First != _Last)
+ for (; ++_First != _Last; )
+ if (((*_First) < (*_Found)))
+ _Found = _First;
+ return (_Found);
+ }
+
+template<class _FwdIt> inline
+ _FwdIt min_element(_FwdIt _First, _FwdIt _Last)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Min_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last)));
+ return (_First);
+ }
+
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt _Min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ _FwdIt _Found = _First;
+ if (_First != _Last)
+ for (; ++_First != _Last; )
+ if (_Pred(*_First, *_Found))
+ _Found = _First;
+ return (_Found);
+ }
+
+template<class _FwdIt,
+ class _Pr> inline
+ _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
+ {
+ ::std:: _Checked_assign_from_base(_First, _Min_element(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred));
+ return (_First);
+ }
+
+
+template<class _BidIt> inline
+ bool _Next_permutation(_BidIt _First, _BidIt _Last)
+ {
+ ;
+ _BidIt _Next = _Last;
+ if (_First == _Last || _First == --_Next)
+ return (false);
+
+ for (; ; )
+ {
+ _BidIt _Next1 = _Next;
+ if (((*--_Next) < (*_Next1)))
+ {
+ _BidIt _Mid = _Last;
+ for (; !((*_Next) < (*--_Mid)); )
+ ;
+ std::iter_swap(_Next, _Mid);
+ std::reverse(_Next1, _Last);
+ return (true);
+ }
+
+ if (_Next == _First)
+ {
+ std::reverse(_First, _Last);
+ return (false);
+ }
+ }
+ }
+
+template<class _BidIt> inline
+ bool next_permutation(_BidIt _First, _BidIt _Last)
+ {
+ return _Next_permutation(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last));
+ }
+
+
+template<class _BidIt,
+ class _Pr> inline
+ bool _Next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ _BidIt _Next = _Last;
+ if (_First == _Last || _First == --_Next)
+ return (false);
+
+ for (; ; )
+ {
+ _BidIt _Next1 = _Next;
+ if (_Pred(*--_Next, *_Next1))
+ {
+ _BidIt _Mid = _Last;
+ for (; !_Pred(*_Next, *--_Mid); )
+ ;
+ std::iter_swap(_Next, _Mid);
+ std::reverse(_Next1, _Last);
+ return (true);
+ }
+
+ if (_Next == _First)
+ {
+ std::reverse(_First, _Last);
+ return (false);
+ }
+ }
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ return _Next_permutation(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred);
+ }
+
+
+template<class _BidIt> inline
+ bool _Prev_permutation(_BidIt _First, _BidIt _Last)
+ {
+ ;
+ _BidIt _Next = _Last;
+ if (_First == _Last || _First == --_Next)
+ return (false);
+ for (; ; )
+ {
+ _BidIt _Next1 = _Next;
+ if (((*_Next1) < (*--_Next)))
+ {
+ _BidIt _Mid = _Last;
+ for (; !((*--_Mid) < (*_Next)); )
+ ;
+ std::iter_swap(_Next, _Mid);
+ std::reverse(_Next1, _Last);
+ return (true);
+ }
+
+ if (_Next == _First)
+ {
+ std::reverse(_First, _Last);
+ return (false);
+ }
+ }
+ }
+
+template<class _BidIt> inline
+ bool prev_permutation(_BidIt _First, _BidIt _Last)
+ {
+ return _Prev_permutation(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last));
+ }
+
+
+template<class _BidIt,
+ class _Pr> inline
+ bool _Prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ ;
+ ;
+ _BidIt _Next = _Last;
+ if (_First == _Last || _First == --_Next)
+ return (false);
+
+ for (; ; )
+ {
+ _BidIt _Next1 = _Next;
+ if (_Pred(*_Next1, *--_Next))
+ {
+ _BidIt _Mid = _Last;
+ for (; !_Pred(*--_Mid, *_Next); )
+ ;
+ std::iter_swap(_Next, _Mid);
+ std::reverse(_Next1, _Last);
+ return (true);
+ }
+
+ if (_Next == _First)
+ {
+ std::reverse(_First, _Last);
+ return (false);
+ }
+ }
+ }
+
+template<class _BidIt,
+ class _Pr> inline
+ bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred)
+ {
+ return _Prev_permutation(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Pred);
+ }
+
+}
+
+namespace stdext {
+
+template<class _InIt, class _OutIt, class _Fn1>
+inline
+ _OutIt unchecked_transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
+ {
+ return ::std:: _Transform(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Func,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt, class _OutIt, class _Fn1>
+inline
+ _OutIt checked_transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
+ {
+ return ::std:: _Transform(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Func,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2>
+inline
+ _OutIt unchecked_transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func)
+ {
+ return ::std:: _Transform(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Dest, _Func,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Iter_random(_First1, _Dest),
+ ::std:: _Range_checked_iterator_tag(), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1, class _InIt2, class _OutIt, class _Fn2>
+inline
+ _OutIt checked_transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
+ _OutIt _Dest, _Fn2 _Func)
+ {
+ return ::std:: _Transform(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2, _Dest, _Func,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Iter_random(_First1, _Dest),
+ ::std:: _Checked_cat(_First2), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _FwdIt1, class _FwdIt2>
+inline
+ _FwdIt2 unchecked_swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
+ {
+ return ::std:: _Swap_ranges(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _FwdIt1, class _FwdIt2>
+inline
+ _FwdIt2 checked_swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
+ {
+ return ::std:: _Swap_ranges(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), _First2,
+ ::std:: _Iter_random(_First1, _First2), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt unchecked_replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval)
+ {
+ return ::std:: _Replace_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Oldval, _Newval,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt checked_replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
+ const _Ty& _Oldval, const _Ty& _Newval)
+ {
+ return ::std:: _Replace_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Oldval, _Newval,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr,
+ class _Ty> inline
+ _OutIt unchecked_replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val)
+ {
+ return ::std:: _Replace_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred, _Val,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr,
+ class _Ty> inline
+ _OutIt checked_replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
+ _Pr _Pred, const _Ty& _Val)
+ {
+ return ::std:: _Replace_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred, _Val,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _OutIt,
+ class _Diff,
+ class _Fn0> inline
+ void unchecked_generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
+ {
+ ::std:: _Generate_n(_Dest, _Count, _Func,
+ _Iter_cat(_Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _OutIt,
+ class _Diff,
+ class _Fn0> inline
+ void checked_generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
+ {
+ ::std:: _Generate_n(_Dest, _Count, _Func,
+ _Iter_cat(_Dest),::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt unchecked_remove_copy(_InIt _First, _InIt _Last,
+ _OutIt _Dest, const _Ty& _Val)
+ {
+ return ::std:: _Remove_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Val,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Ty> inline
+ _OutIt checked_remove_copy(_InIt _First, _InIt _Last,
+ _OutIt _Dest, const _Ty& _Val)
+ {
+ return ::std:: _Remove_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Val,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Remove_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Remove_copy_if(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt unchecked_unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (_First == _Last ? _Dest :
+ ::std:: _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_cat(_First), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _OutIt> inline
+ _OutIt checked_unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
+ {
+ return (_First == _Last ? _Dest :
+ ::std:: _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ _Iter_cat(_First), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return (_First == _Last ? _Dest
+ : ::std:: _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred,
+ _Iter_cat(_First), ::std:: _Range_checked_iterator_tag()));
+ }
+
+template<class _InIt,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
+ {
+ return (_First == _Last ? _Dest
+ : ::std:: _Unique_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest, _Pred,
+ _Iter_cat(_First), ::std:: _Checked_cat(_Dest)));
+ }
+
+template<class _BidIt,
+ class _OutIt> inline
+ _OutIt unchecked_reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest)
+ {
+ return ::std:: _Reverse_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt,
+ class _OutIt> inline
+ _OutIt checked_reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest)
+ {
+ return ::std:: _Reverse_copy(::std:: _Checked_base(_First), ::std:: _Checked_base(_Last), _Dest,
+ ::std:: _Iter_random(_First, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _FwdIt,
+ class _OutIt> inline
+ _OutIt unchecked_rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
+ {
+ return ::std:: _Rotate_copy(_First, _Mid, _Last, _Dest, ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _FwdIt,
+ class _OutIt> inline
+ _OutIt checked_rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
+ {
+ return ::std:: _Rotate_copy(_First, _Mid, _Last, _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt unchecked_merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Merge(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Iter_random(_First1, _First2, _Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt checked_merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Merge(_First1, _Last1, _First2, _Last2, _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Merge(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Iter_random(_First1, _First2,_Dest), ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_merge(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Merge(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Iter_random(_First1, _First2, _Dest), ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt1, class _BidIt2, class _BidIt3>
+inline
+ _BidIt3 _Unchecked_merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
+ {
+ return ::std:: _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt1, class _BidIt2, class _BidIt3>
+inline
+ _BidIt3 _Checked_merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
+ {
+ return ::std:: _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt1, class _BidIt2, class _BidIt3, class _Pr>
+inline
+ _BidIt3 _Unchecked_merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
+ {
+ return ::std:: _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, _Pred, ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt1, class _BidIt2, class _BidIt3, class _Pr>
+inline
+ _BidIt3 _Checked_merge_backward(_BidIt1 _First1, _BidIt1 _Last1,
+ _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
+ {
+ return ::std:: _Merge_backward(_First1, _Last1, _First2, _Last2, _Dest, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt, class _OutIt, class _Diff>
+inline
+ void _Unchecked_chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count)
+ {
+ ::std:: _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt, class _OutIt, class _Diff>
+inline
+ void _Checked_chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count)
+ {
+ ::std:: _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _BidIt, class _OutIt, class _Diff, class _Pr>
+inline
+ void _Unchecked_chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Pr _Pred)
+ {
+ ::std:: _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, _Pred, ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _BidIt, class _OutIt, class _Diff, class _Pr>
+inline
+ void _Checked_chunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
+ _Diff _Chunk, _Diff _Count, _Pr _Pred)
+ {
+ ::std:: _Chunked_merge(_First, _Last, _Dest, _Chunk, _Count, _Pred, ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt unchecked_set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt checked_set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_set_union(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_union(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt unchecked_set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt checked_set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_set_intersection(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_intersection(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt unchecked_set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt checked_set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_set_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt unchecked_set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt> inline
+ _OutIt checked_set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
+ {
+ return ::std:: _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt unchecked_set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Range_checked_iterator_tag());
+ }
+
+template<class _InIt1,
+ class _InIt2,
+ class _OutIt,
+ class _Pr> inline
+ _OutIt checked_set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
+ _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
+ {
+ return ::std:: _Set_symmetric_difference(::std:: _Checked_base(_First1), ::std:: _Checked_base(_Last1), ::std:: _Checked_base(_First2), ::std:: _Checked_base(_Last2), _Dest, _Pred,
+ ::std:: _Checked_cat(_Dest));
+ }
+
+}
+
+
+ #pragma warning(default: 4244)
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma once
+
+
+
+
+
+
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4244)
+
+
+namespace std {
+template<class _Ty,
+ class _Ax = allocator<_Ty> >
+ class vector;
+
+
+template<class _Ty,
+ class _Alloc>
+ class _Vector_const_iterator
+ : public _Ranit<_Ty, typename _Alloc::difference_type,
+ typename _Alloc::const_pointer, typename _Alloc::const_reference>
+ {
+public:
+ typedef _Vector_const_iterator<_Ty, _Alloc> _Myt;
+ typedef vector<_Ty, _Alloc> _Myvec;
+ typedef typename _Alloc::pointer _Tptr;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef typename _Alloc::difference_type difference_type;
+ typedef typename _Alloc::const_pointer pointer;
+ typedef typename _Alloc::const_reference reference;
+
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+
+ typedef pointer _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return _Myptr;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ this->_Myptr = const_cast<_Tptr>(_Base);
+ }
+
+
+
+
+
+
+ typedef _Tptr _Inner_type;
+
+ _Vector_const_iterator()
+ {
+ _Myptr = 0;
+ }
+
+
+
+
+
+
+
+
+
+
+ _Vector_const_iterator(_Tptr _Ptr, const _Container_base *_Pvector)
+ {
+ { if (!(_Pvector != 0 && ((_Myvec *)_Pvector)->_Myfirst <= _Ptr && _Ptr <= ((_Myvec *)_Pvector)->_Mylast)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ this->_Mycont = _Pvector;
+ _Myptr = _Ptr;
+ }
+
+
+
+
+
+
+
+
+ reference operator*() const
+ {
+
+
+
+
+
+
+
+
+
+
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr < ((_Myvec *)(this->_Mycont))->_Mylast)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (*_Myptr);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr < ((_Myvec *)(this->_Mycont))->_Mylast)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ ++_Myptr;
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr > ((_Myvec *)(this->_Mycont))->_Myfirst)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ --_Myptr;
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ { if (!(this->_Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(_Myptr + _Off <= ((_Myvec *)(this->_Mycont))->_Mylast && _Myptr + _Off >= ((_Myvec *)(this->_Mycont))->_Myfirst)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ _Myptr += _Off;
+ return (*this);
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Myt& _Right) const
+ {
+
+
+
+
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myptr - _Right._Myptr);
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+
+ bool operator==(const _Myt& _Right) const
+ {
+
+
+
+
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myptr == _Right._Myptr);
+ }
+
+ bool operator!=(const _Myt& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+ bool operator<(const _Myt& _Right) const
+ {
+
+
+
+
+ { if (!(this->_Mycont != 0 && this->_Mycont == _Right._Mycont)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (_Myptr < _Right._Myptr);
+ }
+
+ bool operator>(const _Myt& _Right) const
+ {
+ return (_Right < *this);
+ }
+
+ bool operator<=(const _Myt& _Right) const
+ {
+ return (!(_Right < *this));
+ }
+
+ bool operator>=(const _Myt& _Right) const
+ {
+ return (!(*this < _Right));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+ static void _Xlen()
+ {
+ throw length_error("vector<T> too long");
+ }
+
+ static void _Xran()
+ {
+ throw out_of_range("invalid vector<T> subscript");
+ }
+
+ static void _Xinvarg()
+ {
+ throw invalid_argument("invalid vector<T> argument");
+ }
+
+ _Tptr _Myptr;
+ };
+
+template<class _Ty,
+ class _Alloc> inline
+ _Vector_const_iterator<_Ty, _Alloc> operator+(
+ typename _Vector_const_iterator<_Ty, _Alloc>::difference_type _Off,
+ _Vector_const_iterator<_Ty, _Alloc> _Next)
+ {
+ return (_Next += _Off);
+ }
+
+
+template<class _Ty,
+ class _Alloc>
+ class _Vector_iterator
+ : public _Vector_const_iterator<_Ty, _Alloc>
+ {
+public:
+ typedef _Vector_iterator<_Ty, _Alloc> _Myt;
+ typedef _Vector_const_iterator<_Ty, _Alloc> _Mybase;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Ty value_type;
+ typedef typename _Alloc::difference_type difference_type;
+ typedef typename _Alloc::pointer pointer;
+ typedef typename _Alloc::reference reference;
+
+
+ typedef pointer _Checked_iterator_base_type;
+
+ _Checked_iterator_base_type _Checked_iterator_base() const
+ {
+ return this->_Myptr;
+ }
+
+ void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Base)
+ {
+ this->_Myptr = _Base;
+ }
+
+
+ _Vector_iterator()
+ {
+ }
+
+
+
+
+
+
+
+
+ _Vector_iterator(pointer _Ptr, const _Container_base *_Pvector)
+ : _Mybase(_Ptr, _Pvector)
+ {
+ }
+
+
+
+
+
+
+
+
+ reference operator*() const
+ {
+ return ((reference)**(_Mybase *)this);
+ }
+
+ pointer operator->() const
+ {
+ return (&**this);
+ }
+
+ _Myt& operator++()
+ {
+ ++(*(_Mybase *)this);
+ return (*this);
+ }
+
+ _Myt operator++(int)
+ {
+ _Myt _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator--()
+ {
+ --(*(_Mybase *)this);
+ return (*this);
+ }
+
+ _Myt operator--(int)
+ {
+ _Myt _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Myt& operator+=(difference_type _Off)
+ {
+ (*(_Mybase *)this) += _Off;
+ return (*this);
+ }
+
+ _Myt operator+(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Myt& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Myt operator-(difference_type _Off) const
+ {
+ _Myt _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Mybase& _Right) const
+ {
+ return (*(_Mybase *)this - _Right);
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+ };
+
+template<class _Ty,
+ class _Alloc> inline
+ _Vector_iterator<_Ty, _Alloc> operator+(
+ typename _Vector_iterator<_Ty, _Alloc>::difference_type _Off,
+ _Vector_iterator<_Ty, _Alloc> _Next)
+ {
+ return (_Next += _Off);
+ }
+
+
+template<class _Ty,
+ class _Alloc>
+ class _Vector_val
+ : public _Container_base
+ {
+protected:
+ _Vector_val(_Alloc _Al = _Alloc())
+ : _Alval(_Al)
+ {
+ }
+
+ typedef typename _Alloc::template
+ rebind<_Ty>::other _Alty;
+
+ _Alty _Alval;
+ };
+
+
+template<class _Ty,
+ class _Ax>
+ class vector
+ : public _Vector_val<_Ty, _Ax>
+ {
+public:
+ typedef vector<_Ty, _Ax> _Myt;
+ typedef _Vector_val<_Ty, _Ax> _Mybase;
+ typedef typename _Mybase::_Alty _Alloc;
+ typedef _Alloc allocator_type;
+ typedef typename _Alloc::size_type size_type;
+ typedef typename _Alloc::difference_type _Dift;
+ typedef _Dift difference_type;
+ typedef typename _Alloc::pointer _Tptr;
+ typedef typename _Alloc::const_pointer _Ctptr;
+ typedef _Tptr pointer;
+ typedef _Ctptr const_pointer;
+ typedef typename _Alloc::reference _Reft;
+ typedef _Reft reference;
+ typedef typename _Alloc::const_reference const_reference;
+ typedef typename _Alloc::value_type value_type;
+
+
+
+ typedef _Vector_iterator<_Ty, _Alloc> iterator;
+ typedef _Vector_const_iterator<_Ty, _Alloc> const_iterator;
+
+
+ friend class _Vector_const_iterator<_Ty, _Alloc>;
+
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ vector()
+ : _Mybase()
+ {
+ _Buy(0);
+ }
+
+ explicit vector(const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Buy(0);
+ }
+
+ explicit vector(size_type _Count)
+ : _Mybase()
+ {
+ _Construct_n(_Count, _Ty());
+ }
+
+ vector(size_type _Count, const _Ty& _Val)
+ : _Mybase()
+ {
+ _Construct_n(_Count, _Val);
+ }
+
+ vector(size_type _Count, const _Ty& _Val, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Construct_n(_Count, _Val);
+ }
+
+ vector(const _Myt& _Right)
+ : _Mybase(_Right._Alval)
+ {
+ if (_Buy(_Right.size()))
+ try {
+ _Mylast = _Ucopy(_Right.begin(), _Right.end(), _Myfirst);
+ } catch (...) {
+ _Tidy();
+ throw;
+ }
+ }
+
+ template<class _Iter>
+ vector(_Iter _First, _Iter _Last)
+ : _Mybase()
+ {
+ _Construct(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ vector(_Iter _First, _Iter _Last, const _Alloc& _Al)
+ : _Mybase(_Al)
+ {
+ _Construct(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _Construct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
+ {
+ size_type _Size = (size_type)_Count;
+ _Construct_n(_Size, (_Ty)_Val);
+ }
+
+ template<class _Iter>
+ void _Construct(_Iter _First,
+ _Iter _Last, input_iterator_tag)
+ {
+ _Buy(0);
+ try {
+ insert(begin(), _First, _Last);
+ } catch (...) {
+ _Tidy();
+ throw;
+ }
+ }
+
+ void _Construct_n(size_type _Count, const _Ty& _Val)
+ {
+ if (_Buy(_Count))
+ {
+ try {
+ _Mylast = _Ufill(_Myfirst, _Count, _Val);
+ } catch (...) {
+ _Tidy();
+ throw;
+ }
+ }
+ }
+
+ ~vector()
+ {
+ _Tidy();
+ }
+
+ _Myt& operator=(const _Myt& _Right)
+ {
+ if (this != &_Right)
+ {
+
+
+
+
+
+ if (_Right.size() == 0)
+ clear();
+ else if (_Right.size() <= size())
+ {
+ pointer _Ptr = ::stdext:: unchecked_copy(_Right._Myfirst, _Right._Mylast,
+ _Myfirst);
+ _Destroy(_Ptr, _Mylast);
+ _Mylast = _Myfirst + _Right.size();
+ }
+ else if (_Right.size() <= capacity())
+ {
+ pointer _Ptr = _Right._Myfirst + size();
+ ::stdext:: unchecked_copy(_Right._Myfirst, _Ptr, _Myfirst);
+ _Mylast = _Ucopy(_Ptr, _Right._Mylast, _Mylast);
+ }
+ else
+ {
+ if (_Myfirst != 0)
+ {
+ _Destroy(_Myfirst, _Mylast);
+ this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
+ }
+ if (_Buy(_Right.size()))
+ _Mylast = _Ucopy(_Right._Myfirst, _Right._Mylast,
+ _Myfirst);
+ }
+ }
+ return (*this);
+ }
+
+ void reserve(size_type _Count)
+ {
+ if (max_size() < _Count)
+ _Xlen();
+ else if (capacity() < _Count)
+ {
+ pointer _Ptr = this->_Alval.allocate(_Count);
+
+ try {
+ _Umove(begin(), end(), _Ptr);
+ } catch (...) {
+ this->_Alval.deallocate(_Ptr, _Count);
+ throw;
+ }
+
+ size_type _Size = size();
+ if (_Myfirst != 0)
+ {
+ _Destroy(_Myfirst, _Mylast);
+ this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
+ }
+
+
+
+
+
+ _Myend = _Ptr + _Count;
+ _Mylast = _Ptr + _Size;
+ _Myfirst = _Ptr;
+ }
+ }
+
+ size_type capacity() const
+ {
+ return (_Myfirst == 0 ? 0 : _Myend - _Myfirst);
+ }
+
+
+ iterator begin()
+ {
+ return (iterator(_Myfirst, this));
+ }
+
+ const_iterator begin() const
+ {
+ return (const_iterator(_Myfirst, this));
+ }
+
+ iterator end()
+ {
+ return (iterator(_Mylast, this));
+ }
+
+ const_iterator end() const
+ {
+ return (const_iterator(_Mylast, this));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ reverse_iterator rbegin()
+ {
+ return (reverse_iterator(end()));
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return (const_reverse_iterator(end()));
+ }
+
+ reverse_iterator rend()
+ {
+ return (reverse_iterator(begin()));
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return (const_reverse_iterator(begin()));
+ }
+
+ void resize(size_type _Newsize)
+ {
+ resize(_Newsize, _Ty());
+ }
+
+ void resize(size_type _Newsize, _Ty _Val)
+ {
+ if (size() < _Newsize)
+ _Insert_n(end(), _Newsize - size(), _Val);
+ else if (_Newsize < size())
+ erase(begin() + _Newsize, end());
+ }
+
+ size_type size() const
+ {
+ return (_Myfirst == 0 ? 0 : _Mylast - _Myfirst);
+ }
+
+ size_type max_size() const
+ {
+ return (this->_Alval.max_size());
+ }
+
+ bool empty() const
+ {
+ return (size() == 0);
+ }
+
+ _Alloc get_allocator() const
+ {
+ return (this->_Alval);
+ }
+
+ const_reference at(size_type _Pos) const
+ {
+ if (size() <= _Pos)
+ _Xran();
+ return (*(begin() + _Pos));
+ }
+
+ reference at(size_type _Pos)
+ {
+ if (size() <= _Pos)
+ _Xran();
+ return (*(begin() + _Pos));
+ }
+
+ const_reference operator[](size_type _Pos) const
+ {
+
+
+
+
+
+
+
+
+ { if (!(_Pos < size())) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+ return (*(_Myfirst + _Pos));
+ }
+
+ reference operator[](size_type _Pos)
+ {
+
+
+
+
+
+
+
+
+ { if (!(_Pos < size())) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+ return (*(_Myfirst + _Pos));
+ }
+
+ reference front()
+ {
+ return (*begin());
+ }
+
+ const_reference front() const
+ {
+ return (*begin());
+ }
+
+ reference back()
+ {
+ return (*(end() - 1));
+ }
+
+ const_reference back() const
+ {
+ return (*(end() - 1));
+ }
+
+ void push_back(const _Ty& _Val)
+ {
+ if (size() < capacity())
+
+
+
+
+
+
+
+
+ _Mylast = _Ufill(_Mylast, 1, _Val);
+
+
+ else
+ insert(end(), _Val);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ void pop_back()
+ {
+ if (!empty())
+ {
+ _Destroy(_Mylast - 1, _Mylast);
+ --_Mylast;
+ }
+ }
+
+
+ template<class _Iter>
+ void assign(_Iter _First, _Iter _Last)
+ {
+ _Assign(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _Assign(_Iter _Count, _Iter _Val, _Int_iterator_tag)
+ {
+ _Assign_n((size_type)_Count, (_Ty)_Val);
+ }
+
+ template<class _Iter>
+ void _Assign(_Iter _First, _Iter _Last, input_iterator_tag)
+ {
+ erase(begin(), end());
+ insert(begin(), _First, _Last);
+ }
+
+ void assign(size_type _Count, const _Ty& _Val)
+ {
+ _Assign_n(_Count, _Val);
+ }
+
+ iterator insert(iterator _Where, const _Ty& _Val)
+ {
+ size_type _Off = size() == 0 ? 0 : _Where - begin();
+ _Insert_n(_Where, (size_type)1, _Val);
+ return (begin() + _Off);
+ }
+
+ void insert(iterator _Where, size_type _Count, const _Ty& _Val)
+ {
+ _Insert_n(_Where, _Count, _Val);
+ }
+
+ template<class _Iter>
+ void insert(iterator _Where, _Iter _First, _Iter _Last)
+ {
+ _Insert(_Where, _First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where, _Iter _First, _Iter _Last,
+ _Int_iterator_tag)
+ {
+ _Insert_n(_Where, (size_type)_First, (_Ty)_Last);
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where, _Iter _First, _Iter _Last,
+ input_iterator_tag)
+ {
+ for (; _First != _Last; ++_First, ++_Where)
+ _Where = insert(_Where, *_First);
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where,
+ _Iter _First, _Iter _Last, forward_iterator_tag)
+ {
+
+
+
+
+
+
+
+
+
+
+ size_type _Count = 0;
+ _Distance(_First, _Last, _Count);
+ size_type _Capacity = capacity();
+
+ if (_Count == 0)
+ ;
+ else if (max_size() - size() < _Count)
+ _Xlen();
+ else if (_Capacity < size() + _Count)
+ {
+ _Capacity = max_size() - _Capacity / 2 < _Capacity
+ ? 0 : _Capacity + _Capacity / 2;
+ if (_Capacity < size() + _Count)
+ _Capacity = size() + _Count;
+ pointer _Newvec = this->_Alval.allocate(_Capacity);
+ pointer _Ptr = _Newvec;
+
+ try {
+ _Ptr = _Umove(_Myfirst, (_Where)._Myptr,
+ _Newvec);
+ _Ptr = _Ucopy(_First, _Last, _Ptr);
+ _Umove((_Where)._Myptr, _Mylast, _Ptr);
+ } catch (...) {
+ _Destroy(_Newvec, _Ptr);
+ this->_Alval.deallocate(_Newvec, _Capacity);
+ throw;
+ }
+
+ _Count += size();
+ if (_Myfirst != 0)
+ {
+ _Destroy(_Myfirst, _Mylast);
+ this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
+ }
+
+
+
+
+
+ _Myend = _Newvec + _Capacity;
+ _Mylast = _Newvec + _Count;
+ _Myfirst = _Newvec;
+ }
+ else if ((size_type)(end() - _Where) < _Count)
+ {
+ _Umove((_Where)._Myptr, _Mylast,
+ (_Where)._Myptr + _Count);
+ _Iter _Mid = _First;
+ advance(_Mid, end() - _Where);
+
+ try {
+ _Ucopy(_Mid, _Last, _Mylast);
+ } catch (...) {
+ _Destroy((_Where)._Myptr + _Count, _Mylast + _Count);
+ throw;
+ }
+
+ _Mylast += _Count;
+
+
+
+
+
+ ::stdext:: unchecked_copy(_First, _Mid,
+ (_Where)._Myptr);
+ }
+ else
+ {
+ pointer _Oldend = _Mylast;
+ _Mylast = _Umove(_Oldend - _Count, _Oldend,
+ _Mylast);
+ ::stdext:: _Unchecked_move_backward((_Where)._Myptr, _Oldend - _Count,
+ _Oldend);
+
+
+
+
+
+ ::stdext:: unchecked_copy(_First, _Last,
+ (_Where)._Myptr);
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ iterator erase(iterator _Where)
+ {
+ ::stdext:: unchecked_copy((_Where)._Myptr + 1, _Mylast,
+ (_Where)._Myptr);
+ _Destroy(_Mylast - 1, _Mylast);
+ --_Mylast;
+ return (_Where);
+ }
+
+
+ iterator erase(iterator _First, iterator _Last)
+ {
+ if (_First != _Last)
+ {
+
+
+
+
+
+
+
+
+
+
+ pointer _Ptr = ::stdext:: unchecked_copy((_Last)._Myptr, _Mylast,
+ (_First)._Myptr);
+
+
+ _Destroy(_Ptr, _Mylast);
+ _Mylast = _Ptr;
+ }
+
+
+
+ return (_First);
+
+ }
+
+ void clear()
+ {
+ erase(begin(), end());
+ }
+
+ void swap(_Myt& _Right)
+ {
+ if (this->_Alval == _Right._Alval)
+ {
+
+
+
+
+
+ std::swap(_Myfirst, _Right._Myfirst);
+ std::swap(_Mylast, _Right._Mylast);
+ std::swap(_Myend, _Right._Myend);
+ }
+ else
+ {
+ _Myt _Ts = *this; *this = _Right, _Right = _Ts;
+ }
+ }
+
+protected:
+ void _Assign_n(size_type _Count, const _Ty& _Val)
+ {
+ _Ty _Tmp = _Val;
+ erase(begin(), end());
+ insert(begin(), _Count, _Tmp);
+ }
+
+ bool _Buy(size_type _Capacity)
+ {
+ _Myfirst = 0, _Mylast = 0, _Myend = 0;
+ if (_Capacity == 0)
+ return (false);
+ else if (max_size() < _Capacity)
+ _Xlen();
+ else
+ {
+ _Myfirst = this->_Alval.allocate(_Capacity);
+ _Mylast = _Myfirst;
+ _Myend = _Myfirst + _Capacity;
+ }
+ return (true);
+ }
+
+ void _Destroy(pointer _First, pointer _Last)
+ {
+ _Destroy_range(_First, _Last, this->_Alval);
+ }
+
+ void _Tidy()
+ {
+ if (_Myfirst != 0)
+ {
+
+
+
+
+
+ _Destroy(_Myfirst, _Mylast);
+ this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
+ }
+ _Myfirst = 0, _Mylast = 0, _Myend = 0;
+ }
+
+ template<class _Iter>
+ pointer _Ucopy(_Iter _First, _Iter _Last, pointer _Ptr)
+ {
+ return (::stdext:: unchecked_uninitialized_copy(_First, _Last,
+ _Ptr, this->_Alval));
+ }
+
+ template<class _Iter>
+ pointer _Umove(_Iter _First, _Iter _Last, pointer _Ptr)
+ {
+ return (::stdext:: _Unchecked_uninitialized_move(_First, _Last,
+ _Ptr, this->_Alval));
+ }
+
+ void _Insert_n(iterator _Where,
+ size_type _Count, const _Ty& _Val)
+ {
+
+
+
+
+
+
+
+ _Ty _Tmp = _Val;
+ size_type _Capacity = capacity();
+
+ if (_Count == 0)
+ ;
+ else if (max_size() - size() < _Count)
+ _Xlen();
+ else if (_Capacity < size() + _Count)
+ {
+ _Capacity = max_size() - _Capacity / 2 < _Capacity
+ ? 0 : _Capacity + _Capacity / 2;
+ if (_Capacity < size() + _Count)
+ _Capacity = size() + _Count;
+ pointer _Newvec = this->_Alval.allocate(_Capacity);
+ pointer _Ptr = _Newvec;
+
+ try {
+ _Ptr = _Umove(_Myfirst, (_Where)._Myptr,
+ _Newvec);
+ _Ptr = _Ufill(_Ptr, _Count, _Tmp);
+ _Umove((_Where)._Myptr, _Mylast, _Ptr);
+ } catch (...) {
+ _Destroy(_Newvec, _Ptr);
+ this->_Alval.deallocate(_Newvec, _Capacity);
+ throw;
+ }
+
+ _Count += size();
+ if (_Myfirst != 0)
+ {
+ _Destroy(_Myfirst, _Mylast);
+ this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
+ }
+
+
+
+
+
+ _Myend = _Newvec + _Capacity;
+ _Mylast = _Newvec + _Count;
+ _Myfirst = _Newvec;
+ }
+ else if ((size_type)(_Mylast - (_Where)._Myptr) < _Count)
+ {
+ _Umove((_Where)._Myptr, _Mylast,
+ (_Where)._Myptr + _Count);
+
+ try {
+ _Ufill(_Mylast, _Count - (_Mylast - (_Where)._Myptr),
+ _Tmp);
+ } catch (...) {
+ _Destroy((_Where)._Myptr + _Count, _Mylast + _Count);
+ throw;
+ }
+
+ _Mylast += _Count;
+
+
+
+
+
+ fill((_Where)._Myptr, _Mylast - _Count,
+ _Tmp);
+ }
+ else
+ {
+ pointer _Oldend = _Mylast;
+ _Mylast = _Umove(_Oldend - _Count, _Oldend,
+ _Mylast);
+
+
+
+
+
+ ::stdext:: _Unchecked_move_backward((_Where)._Myptr, _Oldend - _Count,
+ _Oldend);
+ fill((_Where)._Myptr, (_Where)._Myptr + _Count,
+ _Tmp);
+ }
+ }
+
+ pointer _Ufill(pointer _Ptr, size_type _Count, const _Ty &_Val)
+ {
+ ::stdext:: unchecked_uninitialized_fill_n(_Ptr, _Count, _Val, this->_Alval);
+ return (_Ptr + _Count);
+ }
+
+ static void _Xlen()
+ {
+ throw length_error("vector<T> too long");
+ }
+
+ static void _Xran()
+ {
+ throw out_of_range("invalid vector<T> subscript");
+ }
+
+ static void _Xinvarg()
+ {
+ throw invalid_argument("invalid vector<T> argument");
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ pointer _Myfirst;
+ pointer _Mylast;
+ pointer _Myend;
+ };
+
+
+template <class _Ty, class _Ax>
+ class _Move_operation_category<vector<_Ty, _Ax> >
+ {
+ public:
+ typedef _Swap_move_tag _Move_cat;
+ };
+
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator==(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (_Left.size() == _Right.size()
+ && equal(_Left.begin(), _Left.end(), _Right.begin()));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator!=(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (!(_Left == _Right));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator<(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (lexicographical_compare(_Left.begin(), _Left.end(),
+ _Right.begin(), _Right.end()));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator>(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (_Right < _Left);
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator<=(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (!(_Right < _Left));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ bool operator>=(const vector<_Ty, _Alloc>& _Left,
+ const vector<_Ty, _Alloc>& _Right)
+ {
+ return (!(_Left < _Right));
+ }
+
+template<class _Ty,
+ class _Alloc> inline
+ void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right)
+ {
+ _Left.swap(_Right);
+ }
+
+
+
+
+typedef unsigned _Vbase;
+const int _VBITS = 8 * sizeof (_Vbase);
+
+
+template<class _MycontTy>
+ class _Vb_iter_base
+ : public _Ranit<_Bool, typename _MycontTy::difference_type,
+ bool *, bool>
+ {
+public:
+
+ typedef _Range_checked_iterator_tag _Checked_iterator_category;
+
+
+ _Vb_iter_base()
+ : _Myptr(0), _Myoff(0)
+ {
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _Vb_iter_base(const _Vb_iter_base<_MycontTy>& _Right)
+ : _Myptr(_Right._Myptr), _Myoff(_Right._Myoff)
+ {
+ { if (!(_Right._Mycont != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ this->_Mycont = _Right._Mycont;
+ }
+
+ _Vb_iter_base(_Vbase *_Ptr, _MycontTy *_Mypvbool)
+ : _Myptr(_Ptr), _Myoff(0)
+ {
+ { if (!(_Mypvbool != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ this->_Mycont = _Mypvbool;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _Vbase *_Myptr;
+ typename _MycontTy::size_type _Myoff;
+
+ static void _Xlen()
+ {
+ throw length_error("vector<bool> too long");
+ }
+
+ static void _Xran()
+ {
+ throw out_of_range("invalid vector<bool> subscript");
+ }
+
+ static void _Xinvarg()
+ {
+ throw invalid_argument("invalid vector<bool> argument");
+ }
+
+
+ _Vbase * _My_cont_begin() const
+ {
+ return (((_MycontTy *)this->_Mycont)->_Myvec.begin())._Myptr;
+ }
+
+ typename _MycontTy::size_type _My_actual_offset() const
+ {
+ _MycontTy::size_type _Off = this->_Myoff;
+ _Off += _VBITS * (this->_Myptr - _My_cont_begin());
+ return _Off;
+ }
+
+ };
+
+
+template<class _MycontTy>
+ class _Vb_reference
+ : public _Vb_iter_base<_MycontTy>
+ {
+public:
+ _Vb_reference()
+ {
+ }
+
+ _Vb_reference(const _Vb_iter_base<_MycontTy>& _Right)
+ : _Vb_iter_base<_MycontTy>(_Right)
+ {
+ }
+
+ _Vb_reference& operator=(const _Vb_reference<_MycontTy>& _Right)
+ {
+ return (*this = bool(_Right));
+ }
+
+ _Vb_reference<_MycontTy>& operator=(bool _Val)
+ {
+ if (_Val)
+ *_Getptr() |= _Mask();
+ else
+ *_Getptr() &= ~_Mask();
+ return (*this);
+ }
+
+ void flip()
+ {
+ *_Getptr() ^= _Mask();
+ }
+
+ bool operator~() const
+ {
+ return (!bool(*this));
+ }
+
+ operator bool() const
+ {
+ return ((*_Getptr() & _Mask()) != 0);
+ }
+
+ _Vbase *_Getptr() const
+ {
+
+
+
+
+
+
+
+
+
+ { if (!(this->_Mycont != 0 && this->_Myptr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(this->_My_actual_offset() < ((_MycontTy *)this->_Mycont)->_Mysize)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+
+
+ return (this->_Myptr);
+ }
+
+protected:
+ _Vbase _Mask() const
+ {
+ return ((_Vbase)(1 << this->_Myoff));
+ }
+ };
+
+template<class _MycontTy>
+ void swap(_Vb_reference<_MycontTy> _Left, _Vb_reference<_MycontTy> _Right)
+ {
+ bool _Val = _Left;
+ _Left = _Right;
+ _Right = _Val;
+ }
+
+
+template<class _MycontTy>
+ class _Vb_const_iterator
+ : public _Vb_iter_base<_MycontTy>
+ {
+public:
+ typedef _Vb_reference<_MycontTy> _Reft;
+ typedef bool const_reference;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Bool value_type;
+ typedef typename _MycontTy::size_type size_type;
+ typedef typename _MycontTy::difference_type difference_type;
+ typedef const_reference *pointer;
+ typedef const_reference reference;
+
+ _Vb_const_iterator()
+ {
+ }
+
+
+ _Vb_const_iterator(const _Vbase *_Ptr, const _MycontTy *_Mypvbool)
+ : _Vb_iter_base<_MycontTy>((_Vbase *)_Ptr, (_MycontTy *)_Mypvbool)
+
+
+
+
+
+
+ {
+ }
+
+ const_reference operator*() const
+ {
+ return (_Reft(*this));
+ }
+
+ _Vb_const_iterator<_MycontTy>& operator++()
+ {
+ _Inc();
+ return (*this);
+ }
+
+ _Vb_const_iterator<_MycontTy> operator++(int)
+ {
+ _Vb_const_iterator<_MycontTy> _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Vb_const_iterator<_MycontTy>& operator--()
+ {
+ _Dec();
+ return (*this);
+ }
+
+ _Vb_const_iterator<_MycontTy> operator--(int)
+ {
+ _Vb_const_iterator<_MycontTy> _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Vb_const_iterator<_MycontTy>& operator+=(difference_type _Off)
+ {
+ if (_Off == 0)
+ return (*this);
+ { if (!(this->_Mycont != 0 && this->_Myptr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ if (_Off < 0)
+ {
+ { if (!(this->_My_actual_offset() >= ((size_type)-_Off))) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+ else
+ {
+ { if (!((this->_My_actual_offset() + _Off) <= ((_MycontTy *)this->_Mycont)->_Mysize)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ }
+ if (_Off < 0 && this->_Myoff < 0 - (size_type)_Off)
+ {
+ this->_Myoff += _Off;
+ this->_Myptr -= 1 + ((size_type)(-1) - this->_Myoff) / _VBITS;
+ this->_Myoff %= _VBITS;
+ }
+ else
+ {
+ this->_Myoff += _Off;
+ this->_Myptr += this->_Myoff / _VBITS;
+ this->_Myoff %= _VBITS;
+ }
+ return (*this);
+ }
+
+ _Vb_const_iterator<_MycontTy> operator+(difference_type _Off) const
+ {
+ _Vb_const_iterator<_MycontTy> _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Vb_const_iterator<_MycontTy>& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Vb_const_iterator<_MycontTy> operator-(difference_type _Off) const
+ {
+ _Vb_const_iterator<_MycontTy> _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(
+ const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+
+
+
+
+
+ return (_VBITS * (this->_Myptr - _Right._Myptr)
+ + (difference_type)this->_Myoff
+ - (difference_type)_Right._Myoff);
+ }
+
+ const_reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+
+ bool operator==(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+
+
+
+
+
+ return (this->_Myptr == _Right._Myptr
+ && this->_Myoff == _Right._Myoff);
+ }
+
+ bool operator!=(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+ return (!(*this == _Right));
+ }
+
+ bool operator<(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+
+
+
+
+
+ return (this->_Myptr < _Right._Myptr
+ || this->_Myptr == _Right._Myptr
+ && this->_Myoff < _Right._Myoff);
+ }
+
+ bool operator>(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+ return (_Right < *this);
+ }
+
+ bool operator<=(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+ return (!(_Right < *this));
+ }
+
+ bool operator>=(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+ return (!(*this < _Right));
+ }
+
+protected:
+
+
+
+
+
+
+
+
+
+ void _Dec()
+ {
+ if (this->_Myoff != 0)
+ {
+ --this->_Myoff;
+ }
+ else
+ {
+ { if (!(this->_Mycont != 0 && this->_Myptr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!(this->_Myptr > this->_My_cont_begin())) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ --this->_Myptr;
+ this->_Myoff = _VBITS - 1;
+ }
+ }
+
+ void _Inc()
+ {
+ { if (!(this->_Mycont != 0 && this->_Myptr != 0)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ { if (!((this->_My_actual_offset() + 1) <= ((_MycontTy *)this->_Mycont)->_Mysize)) { ((void)0); ::_invalid_parameter_noinfo(); } ; };
+ if (this->_Myoff < _VBITS - 1)
+ ++this->_Myoff;
+ else
+ this->_Myoff = 0, ++this->_Myptr;
+ }
+ };
+
+template<class _MycontTy>
+ _Vb_const_iterator<_MycontTy> operator+(
+ typename _Vb_const_iterator<_MycontTy>::difference_type _Off,
+ _Vb_const_iterator<_MycontTy> _Right)
+ {
+ return (_Right += _Off);
+ }
+
+
+template<class _MycontTy>
+ class _Vb_iterator
+ : public _Vb_const_iterator<_MycontTy>
+ {
+public:
+ typedef _Vb_reference<_MycontTy> _Reft;
+ typedef bool const_reference;
+
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Bool value_type;
+ typedef typename _MycontTy::size_type size_type;
+ typedef typename _MycontTy::difference_type difference_type;
+ typedef _Reft *pointer;
+ typedef _Reft reference;
+
+ _Vb_iterator()
+ {
+ }
+
+
+ _Vb_iterator(_Vbase *_Ptr, _MycontTy *_Mypvbool)
+ : _Vb_const_iterator<_MycontTy>(_Ptr, _Mypvbool)
+
+
+
+
+
+
+ {
+ }
+
+ reference operator*() const
+ {
+ return (_Reft(*this));
+ }
+
+ _Vb_iterator<_MycontTy>& operator++()
+ {
+ ++*(_Vb_const_iterator<_MycontTy> *)this;
+ return (*this);
+ }
+
+ _Vb_iterator<_MycontTy> operator++(int)
+ {
+ _Vb_iterator<_MycontTy> _Tmp = *this;
+ ++*this;
+ return (_Tmp);
+ }
+
+ _Vb_iterator<_MycontTy>& operator--()
+ {
+ --*(_Vb_const_iterator<_MycontTy> *)this;
+ return (*this);
+ }
+
+ _Vb_iterator<_MycontTy> operator--(int)
+ {
+ _Vb_iterator<_MycontTy> _Tmp = *this;
+ --*this;
+ return (_Tmp);
+ }
+
+ _Vb_iterator<_MycontTy>& operator+=(difference_type _Off)
+ {
+ *(_Vb_const_iterator<_MycontTy> *)this += _Off;
+ return (*this);
+ }
+
+ _Vb_iterator<_MycontTy> operator+(difference_type _Off) const
+ {
+ _Vb_iterator<_MycontTy> _Tmp = *this;
+ return (_Tmp += _Off);
+ }
+
+ _Vb_iterator<_MycontTy>& operator-=(difference_type _Off)
+ {
+ return (*this += -_Off);
+ }
+
+ _Vb_iterator<_MycontTy> operator-(difference_type _Off) const
+ {
+ _Vb_iterator<_MycontTy> _Tmp = *this;
+ return (_Tmp -= _Off);
+ }
+
+ difference_type operator-(const _Vb_const_iterator<_MycontTy>& _Right) const
+ {
+ return (*(_Vb_const_iterator<_MycontTy> *)this - _Right);
+ }
+
+ reference operator[](difference_type _Off) const
+ {
+ return (*(*this + _Off));
+ }
+ };
+
+template<class _MycontTy>
+ _Vb_iterator<_MycontTy> operator+(
+ typename _Vb_iterator<_MycontTy>::difference_type _Off,
+ _Vb_iterator<_MycontTy> _Right)
+ {
+ return (_Right += _Off);
+ }
+
+
+template<class _Alloc>
+ class vector<_Bool, _Alloc>
+ : public _Container_base
+ {
+public:
+ typedef typename _Alloc::size_type size_type;
+ typedef typename _Alloc::difference_type _Dift;
+ typedef std::vector<_Vbase,
+ typename _Alloc::template rebind<_Vbase>::other>
+ _Vbtype;
+ typedef std::vector<_Bool, _Alloc> _Myt;
+ typedef _Dift difference_type;
+ typedef _Bool _Ty;
+ typedef _Alloc allocator_type;
+
+ typedef _Vb_reference<_Myt> reference;
+ typedef bool const_reference;
+ typedef bool value_type;
+
+ typedef reference _Reft;
+ typedef _Vb_const_iterator<_Myt> const_iterator;
+ typedef _Vb_iterator<_Myt> iterator;
+
+ friend class _Vb_reference<_Myt>;
+ friend class _Vb_iter_base<_Myt>;
+ friend class _Vb_const_iterator<_Myt>;
+
+ typedef iterator pointer;
+ typedef const_iterator const_pointer;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ vector()
+ : _Mysize(0), _Myvec()
+ {
+ }
+
+ explicit vector(const _Alloc& _Al)
+ : _Mysize(0), _Myvec(_Al)
+ {
+ }
+
+ explicit vector(size_type _Count, bool _Val = false)
+ : _Mysize(0), _Myvec(_Nw(_Count), (_Vbase)(_Val ? -1 : 0))
+ {
+ _Trim(_Count);
+ }
+
+ vector(size_type _Count, bool _Val, const _Alloc& _Al)
+ : _Mysize(0), _Myvec(_Nw(_Count), (_Vbase)(_Val ? -1 : 0), _Al)
+ {
+ _Trim(_Count);
+ }
+
+ template<class _Iter>
+ vector(_Iter _First, _Iter _Last)
+ : _Mysize(0), _Myvec()
+ {
+ _BConstruct(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ vector(_Iter _First, _Iter _Last, const _Alloc& _Al)
+ : _Mysize(0), _Myvec(_Al)
+ {
+ _BConstruct(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _BConstruct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
+ {
+ size_type _Num = (size_type)_Count;
+ _Myvec.assign(_Num, (_Ty)_Val ? -1 : 0);
+ _Trim(_Num);
+ }
+
+ template<class _Iter>
+ void _BConstruct(_Iter _First, _Iter _Last, input_iterator_tag)
+ {
+ insert(begin(), _First, _Last);
+ }
+
+ ~vector()
+ {
+ _Mysize = 0;
+ }
+
+ void reserve(size_type _Count)
+ {
+ _Myvec.reserve(_Nw(_Count));
+ }
+
+ size_type capacity() const
+ {
+ return (_Myvec.capacity() * _VBITS);
+ }
+
+
+ iterator begin()
+ {
+ return (iterator((_Myvec.begin())._Myptr, this));
+ }
+
+ const_iterator begin() const
+ {
+ return (const_iterator((_Myvec.begin())._Myptr, this));
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ iterator end()
+ {
+ iterator _Tmp = begin();
+ if (0 < _Mysize)
+ _Tmp += _Mysize;
+ return (_Tmp);
+ }
+
+ const_iterator end() const
+ {
+ const_iterator _Tmp = begin();
+ if (0 < _Mysize)
+ _Tmp += _Mysize;
+ return (_Tmp);
+ }
+
+ reverse_iterator rbegin()
+ {
+ return (reverse_iterator(end()));
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return (const_reverse_iterator(end()));
+ }
+
+ reverse_iterator rend()
+ {
+ return (reverse_iterator(begin()));
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return (const_reverse_iterator(begin()));
+ }
+
+ void resize(size_type _Newsize, bool _Val = false)
+ {
+ if (size() < _Newsize)
+ _Insert_n(end(), _Newsize - size(), _Val);
+ else if (_Newsize < size())
+ erase(begin() + _Newsize, end());
+ }
+
+ size_type size() const
+ {
+ return (_Mysize);
+ }
+
+ size_type max_size() const
+ {
+ const size_type _Maxsize = _Myvec.max_size();
+ return (_Maxsize < (size_type)(-1) / _VBITS
+ ? _Maxsize * _VBITS : (size_type)(-1));
+ }
+
+ bool empty() const
+ {
+ return (size() == 0);
+ }
+
+ _Alloc get_allocator() const
+ {
+ return (_Myvec.get_allocator());
+ }
+
+ const_reference at(size_type _Off) const
+ {
+ if (size() <= _Off)
+ _Xran();
+ return (*(begin() + _Off));
+ }
+
+ reference at(size_type _Off)
+ {
+ if (size() <= _Off)
+ _Xran();
+ return (*(begin() + _Off));
+ }
+
+ const_reference operator[](size_type _Off) const
+ {
+ return (*(begin() + _Off));
+ }
+
+ reference operator[](size_type _Off)
+ {
+ return (*(begin() + _Off));
+ }
+
+ reference front()
+ {
+ return (*begin());
+ }
+
+ const_reference front() const
+ {
+ return (*begin());
+ }
+
+ reference back()
+ {
+ return (*(end() - 1));
+ }
+
+ const_reference back() const
+ {
+ return (*(end() - 1));
+ }
+
+ void push_back(bool _Val)
+ {
+ insert(end(), _Val);
+ }
+
+ void pop_back()
+ {
+ if (!empty())
+ erase(end() - 1);
+ }
+
+ template<class _Iter>
+ void assign(_Iter _First, _Iter _Last)
+ {
+ _Assign(_First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _Assign(_Iter _Count, _Iter _Val, _Int_iterator_tag)
+ {
+ _Assign_n((size_type)_Count, (bool)_Val);
+ }
+
+ template<class _Iter>
+ void _Assign(_Iter _First, _Iter _Last, input_iterator_tag)
+ {
+ erase(begin(), end());
+ insert(begin(), _First, _Last);
+ }
+
+ void assign(size_type _Count, bool _Val)
+ {
+ _Assign_n(_Count, _Val);
+ }
+
+ iterator insert(iterator _Where, bool _Val)
+ {
+ size_type _Off = _Where - begin();
+ _Insert_n(_Where, (size_type)1, _Val);
+ return (begin() + _Off);
+ }
+
+ void insert(iterator _Where, size_type _Count, bool _Val)
+ {
+ _Insert_n(_Where, _Count, _Val);
+ }
+
+ template<class _Iter>
+ void insert(iterator _Where, _Iter _First, _Iter _Last)
+ {
+ _Insert(_Where, _First, _Last, _Iter_cat(_First));
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where, _Iter _Count, _Iter _Val,
+ _Int_iterator_tag)
+ {
+ _Insert_n(_Where, (size_type)_Count, (bool)_Val);
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where, _Iter _First, _Iter _Last,
+ input_iterator_tag)
+ {
+ size_type _Off = _Where - begin();
+
+ for (; _First != _Last; ++_First, ++_Off)
+ insert(begin() + _Off, *_First);
+ }
+
+ template<class _Iter>
+ void _Insert(iterator _Where,
+ _Iter _First, _Iter _Last,
+ forward_iterator_tag)
+ {
+
+
+
+
+
+
+
+ size_type _Count = 0;
+ _Distance(_First, _Last, _Count);
+
+ size_type _Off = _Insert_x(_Where, _Count);
+ std::copy(_First, _Last, begin() + _Off);
+ }
+
+ iterator erase(iterator _Where)
+ {
+ size_type _Off = _Where - begin();
+
+
+
+
+
+
+
+
+ std::copy(_Where + 1, end(), _Where);
+
+
+ _Trim(_Mysize - 1);
+ return (begin() + _Off);
+ }
+
+ iterator erase(iterator _First, iterator _Last)
+ {
+ size_type _Off = _First - begin();
+
+
+
+
+
+
+
+
+
+
+ iterator _Next = std::copy(_Last, end(), _First);
+ _Trim(_Next - begin());
+
+
+ return (begin() + _Off);
+ }
+
+ void clear()
+ {
+ erase(begin(), end());
+ }
+
+ void flip()
+ {
+ for (_Vbtype::iterator _Next = _Myvec.begin();
+ _Next != _Myvec.end(); ++_Next)
+ *_Next = (_Vbase)~*_Next;
+ _Trim(_Mysize);
+ }
+
+ void swap(_Myt& _Right)
+ {
+
+
+
+
+
+ std::swap(_Mysize, _Right._Mysize);
+ _Myvec.swap(_Right._Myvec);
+ }
+
+ static void swap(reference _Left, reference _Right)
+ {
+ bool _Val = _Left;
+ _Left = _Right;
+ _Right = _Val;
+ }
+
+
+protected:
+ void _Assign_n(size_type _Count, bool _Val)
+ {
+ erase(begin(), end());
+ _Insert_n(begin(), _Count, _Val);
+ }
+
+ void _Insert_n(iterator _Where,
+ size_type _Count, bool _Val)
+ {
+ size_type _Off = _Insert_x(_Where, _Count);
+ fill(begin() + _Off, begin() + (_Off + _Count), _Val);
+ }
+
+ size_type _Insert_x(iterator _Where, size_type _Count)
+ {
+ size_type _Off = _Where - begin();
+
+
+
+
+
+
+
+ if (_Count == 0)
+ ;
+ else if (max_size() - size() < _Count)
+ _Xlen();
+ else
+ {
+ _Myvec.resize(_Nw(size() + _Count), 0);
+ if (size() == 0)
+ _Mysize += _Count;
+ else
+ {
+ iterator _Oldend = end();
+ _Mysize += _Count;
+ copy_backward(begin() + _Off, _Oldend, end());
+ }
+
+
+
+
+
+ }
+ return (_Off);
+ }
+
+ static size_type _Nw(size_type _Count)
+ {
+ return ((_Count + _VBITS - 1) / _VBITS);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ void _Trim(size_type _Size)
+ {
+ if (max_size() < _Size)
+ _Xlen();
+ size_type _Words = _Nw(_Size);
+
+ if (_Words < _Myvec.size())
+ _Myvec.erase(_Myvec.begin() + _Words, _Myvec.end());
+ _Mysize = _Size;
+ _Size %= _VBITS;
+ if (0 < _Size)
+ _Myvec[_Words - 1] &= (_Vbase)((1 << _Size) - 1);
+ }
+
+ void _Xlen() const
+ {
+ throw length_error("vector<bool> too long");
+ }
+
+ void _Xran() const
+ {
+ throw out_of_range("invalid vector<bool> subscript");
+ }
+
+ size_type _Mysize;
+ _Vbtype _Myvec;
+ };
+
+typedef vector<bool, allocator<bool> > _Bvector;
+}
+
+
+ #pragma warning(default: 4244)
+#pragma warning(pop)
+#pragma pack(pop)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+int main () {
+ std::vector<int> v;
+ v.resize(3);
+ v[0] = 1; v[1] = 4; v[2] = 7;
+ std::ostringstream factorials;
+
+ typedef void (*boost_se_tag_0_factorial29)(int &factorials ); typedef boost::type_of::msvc_typeid_wrapper<sizeof(*boost::type_of::encode_start(boost::scope_exit::aux::wrap( boost::scope_exit::aux::deref(&factorials, (boost_se_tag_0_factorial29)0))))>::type boost_se_wrapped_t_0_factorial29; typedef boost_se_wrapped_t_0_factorial29::type boost_se_capture_t_0_factorial29; struct boost_se_params_t_factorial29 { typedef boost_se_capture_t_0_factorial29 boost_se_param_t_0_factorial29; boost::scope_exit::aux::member< boost_se_param_t_0_factorial29, boost_se_tag_0_factorial29 > boost_se_param_0_factorial29; } boost_local_auxXparams_factorial29 = { boost::scope_exit::aux::deref(&factorials, (boost_se_tag_0_factorial29)0) }; boost::scope_exit::aux::declared< boost::scope_exit::aux::resolve< sizeof(boost_local_auxXargs) >::cmp1<0>::cmp2 > boost_local_auxXargs; boost_local_auxXargs.value = &boost_local_auxXparams_factorial29; typedef ::boost::local::function_ref< int ( int , bool ) , 1 > boost_loca
l_auxXfactorialXref; struct boost_local_auxXfunctorXfactorial : ::boost::local::aux::function_base< int ( int , bool ), 1> { explicit boost_local_auxXfunctorXfactorial(void* bind_params) : boost_local_auxXparams( (boost_se_params_t_factorial29*) bind_params) {} int operator()( int n , bool recursion ) { return boost_local_auxXbody( *this , boost_local_auxXparams-> boost_se_param_0_factorial29.value , n , recursion ); } int operator()( int n ) { return boost_local_auxXbody( *this , boost_local_auxXparams-> boost_se_param_0_factorial29.value , n ); } private: boost_se_params_t_factorial29* boost_local_auxXparams; static int boost_local_auxXbody( boost_local_auxXfunctorXfactorial& factorial , boost_se_params_t_factorial29:: boost_se_param_t_0_factorial29 &factorials , int n , bool recursion = false ) {
+ int result = 0;
+
+ if (n < 2 ) result = 1;
+ else result = n * factorial(n - 1, true);
+
+ if (!recursion) factorials << result << " ";
+ return result;
+ } }; boost_local_auxXfunctorXfactorial boost_local_auxXobjectXfactorial( boost_local_auxXargs.value); boost_local_auxXfactorialXref factorial( boost_local_auxXobjectXfactorial);
+
+ std::for_each(v.begin(), v.end(), factorial);
+ std::cout << factorials.str() << std::endl;
+
+ return 0;
+}
+
+

Added: sandbox/local/libs/local/params_name/00.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/params_name/00.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,7 @@
+( ((BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL)) ((int x, BOOST_PP_EMPTY)) (( double y , 1.23 BOOST_PP_EMPTY )) , (BOOST_LOCAL_AUX_PP_NIL) ( c) (& d) , 1 , (BOOST_LOCAL_AUX_PP_NIL) ( a) (& b) , 0 , BOOST_PP_EMPTY )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) , (BOOST_LOCAL_AUX_PP_NIL) , 0 , (BOOST_LOCAL_AUX_PP_NIL) , 0 , ERROR_default_value_cannot_be_specified_as_the_first_element )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) , (BOOST_LOCAL_AUX_PP_NIL) , 0 , (BOOST_LOCAL_AUX_PP_NIL) , 0 , ERROR_default_must_follow_an_unbound_parameter_at_element_number_6 )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) ((int x, BOOST_PP_EMPTY)) , (BOOST_LOCAL_AUX_PP_NIL) (& d) , 1 , (BOOST_LOCAL_AUX_PP_NIL) ( a) , 2 , ERROR_object_this_cannot_be_bound_multiple_times )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) , (BOOST_LOCAL_AUX_PP_NIL) , 0 , (BOOST_LOCAL_AUX_PP_NIL) , 0 , BOOST_PP_EMPTY )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) , (BOOST_LOCAL_AUX_PP_NIL) , 0 , (BOOST_LOCAL_AUX_PP_NIL) , 0 , BOOST_PP_EMPTY )
+( ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) , (BOOST_LOCAL_AUX_PP_NIL) , 0 , (BOOST_LOCAL_AUX_PP_NIL) , 0 , BOOST_PP_EMPTY )

Added: sandbox/local/libs/local/params_name/02.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/params_name/02.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,490 @@
+
+#include "aux_/preprocessor/sign/params_/is_void.hpp"
+#include "aux_/preprocessor/keyword/bind.hpp"
+#include "aux_/preprocessor/keyword/const_bind.hpp"
+#include <boost/detail/preprocessor/keyword/default.hpp>
+#include <boost/detail/preprocessor/keyword/this.hpp>
+#include <boost/preprocessor.hpp>
+
+// Parameter (unbound, const-bound, and bound) tuple internal representation:
+// ( // Unbound params.
+// ((NIL, NIL)) (([auto | register] type name, default_value)) ...
+// , (NIL) ([&] const_bind_name) ... // Const bound params.
+// , const_bind_this_count // Number of const bound `this`.
+// , (NIL) ([&] bind_name) ... // Bound params (not const).
+// , bind_this_count // Number of bound `this` (not const).
+// )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_ 0
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_ 1
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_ 2
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_ 3
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_ 4
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_ 5
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_ 6
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_CONST_BIND_THIS_COUNT(params) \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_BIND_THIS_COUNT(params) \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_ERROR(params) \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_NIL \
+ ( \
+ /* unbound params: nil-seq of 2-tuples */ \
+ /* `((NIL, NIL)) ((classifier_type_name, default)) ...` */ \
+ ( (BOOST_LOCAL_AUX_PP_NIL, BOOST_LOCAL_AUX_PP_NIL) ) \
+ , \
+ /* const-binds: nil-seq of 1-tuple `(NIL) (ref_name) ...` */ \
+ (BOOST_LOCAL_AUX_PP_NIL) \
+ , \
+ 0 /* number of const-bind `this` */ \
+ , \
+ /* binds: nil-seq of 1-tuple `(NIL) (ref_name) ...` */ \
+ (BOOST_LOCAL_AUX_PP_NIL) \
+ , \
+ 0 /* number of bind `this` */ \
+ , \
+ BOOST_PP_EMPTY /* no error */ \
+ )
+
+// unbind_classified_type_and_name: [auto | register] type name
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND( \
+ params, unbind_classified_type_and_name) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ ((unbind_classified_type_and_name, BOOST_PP_EMPTY))\
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND_DEFAULT_( \
+ unbind_nilseq, default_value) \
+ BOOST_PP_SEQ_POP_BACK(unbind_nilseq) \
+ (( \
+ /* last appended classifier type and name */ \
+ BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_ELEM(BOOST_PP_DEC( \
+ BOOST_PP_SEQ_SIZE(unbind_nilseq)), unbind_nilseq)) \
+ , \
+ /* trailing empty because defaults are optional */ \
+ default_value BOOST_PP_EMPTY \
+ ))
+
+// default_value: a valid parameter default value (`-1`, etc)
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND_DEFAULT( \
+ params, default_value) \
+ ( /* unbind params and defaults */ \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND_DEFAULT_( \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params), \
+ default_value) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+// const_bind_qualified_name: [&] name (with name != `this`)
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_CONST_BIND( \
+ params, const_bind_qualified_name) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ (const_bind_qualified_name) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INC_CONST_BIND_THIS_COUNT(params) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_INC(BOOST_PP_TUPLE_ELEM( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params)) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+// bind_qualified_name: [&] name
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_BIND( \
+ params, bind_qualified_name) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ (bind_qualified_name) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INC_BIND_THIS_COUNT(params) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_INC(BOOST_PP_TUPLE_ELEM( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params)) \
+ , /* error message (if any) */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_ERROR_, \
+ params) \
+ )
+
+// error: `EMPTY` if no error, `ERROR_message_text EMPTY` if error.
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SET_ERROR(params, error) \
+ ( /* unbind params and defaults */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_UNBIND_, \
+ params) \
+ , /* const-bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_, \
+ params) \
+ , /* const-bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_CONST_BIND_THIS_COUNT_, \
+ params) \
+ , /* bind names */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_, \
+ params) \
+ , /* bind `this` count */ \
+ BOOST_PP_TUPLE_ELEM(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_MAX_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INDEX_BIND_THIS_COUNT_, \
+ params) \
+ , /* error message (if any) */ \
+ error \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_UNBIND_DEFAULT_( \
+ params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND_DEFAULT(params, \
+ BOOST_DETAIL_PP_KEYWORD_DEFAULT_REMOVE_FRONT(elem))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_UNBIND_(params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_UNBIND(params, elem)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_THIS_(params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INC_CONST_BIND_THIS_COUNT(params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_VAR_(params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_CONST_BIND(params, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_REMOVE_FRONT(elem))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_(params, elem) \
+ /* check from back because non `this` bounds might have `&` in front */ \
+ BOOST_PP_IIF(BOOST_DETAIL_PP_KEYWORD_IS_THIS_BACK( \
+ BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_REMOVE_FRONT(elem)), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_THIS_ \
+ , \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_VAR_ \
+ )(params, elem)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_VAR_(params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_APPEND_BIND(params, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_FRONT(elem))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_THIS_(params, elem) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_INC_BIND_THIS_COUNT(params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_(params, elem) \
+ /* check from back because non `this` bounds might have `&` in front */ \
+ BOOST_PP_IIF(BOOST_DETAIL_PP_KEYWORD_IS_THIS_BACK( \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_FRONT(elem)), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_THIS_ \
+ , \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_VAR_ \
+ )(params, elem)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_(s, params, elem) \
+ BOOST_PP_IIF(BOOST_DETAIL_PP_KEYWORD_IS_DEFAULT_FRONT(elem), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_UNBIND_DEFAULT_ \
+ , BOOST_PP_IIF(BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT(elem), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_CONST_BIND_ \
+ , BOOST_PP_IIF(BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT(elem), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_BIND_ \
+ , \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_UNBIND_ \
+ )))(params, elem)
+
+// Precondition: If seq contains a default param value `... (default ...) ...`,
+// the default value element is never 1st (it always has a previous elem) and
+// its previous element is a unbind param (no const-bind and no bind).
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALID_(params_seq) \
+ BOOST_PP_SEQ_FOLD_LEFT(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ELEM_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_NIL, params_seq)
+
+////
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_UNBIND_( \
+ elem) \
+ BOOST_PP_NOT(BOOST_PP_BITOR( \
+ BOOST_DETAIL_PP_KEYWORD_IS_DEFAULT_FRONT(elem) \
+ , BOOST_PP_BITOR( \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT(elem) \
+ , BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT(elem) \
+ ) \
+ ))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PREV_( \
+ params_seq, index, error) \
+ BOOST_PP_IIF( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_UNBIND_(\
+ BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(index), params_seq)), \
+ error /* no err, fwd existing one if any */ \
+ , \
+ BOOST_PP_CAT( \
+ ERROR_default_must_follow_an_unbound_parameter_at_element_number_, \
+ BOOST_PP_INC(index)) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_INDEX_( \
+ params_seq, index, error) \
+ BOOST_PP_IF(index, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PREV_ \
+ , \
+ ERROR_default_value_cannot_be_specified_as_the_first_element \
+ BOOST_PP_TUPLE_EAT(3) \
+ )(params_seq, index, error)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_OP_DATA_( \
+ params_seq, index, error) \
+ ( \
+ params_seq \
+ , \
+ BOOST_PP_INC(index) \
+ , \
+ BOOST_PP_IIF(BOOST_DETAIL_PP_KEYWORD_IS_DEFAULT_FRONT( \
+ BOOST_PP_SEQ_ELEM(index, params_seq)), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_INDEX_ \
+ , \
+ error BOOST_PP_TUPLE_EAT(3) /* no err, fwd existing one if any */\
+ )(params_seq, index, error) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_OP_(d, \
+ params_index_error) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_OP_DATA_( \
+ BOOST_PP_TUPLE_ELEM(3, 0, params_index_error), \
+ BOOST_PP_TUPLE_ELEM(3, 1, params_index_error), \
+ BOOST_PP_TUPLE_ELEM(3, 2, params_index_error))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PRED_DATA_( \
+ params_seq, index, error) \
+ BOOST_PP_AND( \
+ BOOST_PP_IS_EMPTY(error (/* expand empty */) ) \
+ , BOOST_PP_LESS(index, BOOST_PP_SEQ_SIZE(params_seq)) \
+ )
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PRED_(d, \
+ params_index_error) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PRED_DATA_( \
+ BOOST_PP_TUPLE_ELEM(3, 0, params_index_error), \
+ BOOST_PP_TUPLE_ELEM(3, 1, params_index_error), \
+ BOOST_PP_TUPLE_ELEM(3, 2, params_index_error))
+
+// Expand to `EMPTY` if no error, or `ERROR_message EMPTY` if error.
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_(params_seq) \
+ BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_WHILE( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_PRED_, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_OP_, \
+ (params_seq, 0, BOOST_PP_EMPTY)))
+
+///
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_VALIDATE_THIS_COUNT_(params) \
+ BOOST_PP_IIF(BOOST_PP_GREATER(BOOST_PP_ADD( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_CONST_BIND_THIS_COUNT(params), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_BIND_THIS_COUNT(params)), 1), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SET_ERROR \
+ , \
+ params BOOST_PP_TUPLE_EAT(2) \
+ )(params, ERROR_object_this_cannot_be_bound_multiple_times)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_VALIDATE_(params) \
+ BOOST_PP_IIF(BOOST_PP_IS_EMPTY( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_ERROR(params) \
+ (/* expand empty */)), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_VALIDATE_THIS_COUNT_ \
+ , \
+ params BOOST_PP_TUPLE_EAT(1) \
+ )(params)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_YES_(params_seq, unused) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_VALIDATE_( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALID_(params_seq))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_NO_(unused, error) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SET_ERROR( \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_NIL, error)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_( \
+ params_seq, defaults_error) \
+ BOOST_PP_IIF(BOOST_PP_IS_EMPTY(defaults_error (/* expand empty */)), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_YES_ \
+ , \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_NO_ \
+ )(params_seq, defaults_error)
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_(params_seq) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_PARSE_(params_seq, \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_VALIDATE_DEFAULTS_(params_seq))
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_EMPTY_(unused) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_NIL
+
+// `params_seq` is: Empty ``, or `void`, or `(void)` for empty parameter list;
+// Or, `{(param_type param_name)[(default default_value)]
+// | (bind_type bind_name}+` for non-empty parameters, where `bind_type` is
+// `bind | bind& | const bind | const bind&` and `bind_name` is in scope.
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS(params) \
+ BOOST_PP_IIF(BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID(params), \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_EMPTY_ \
+ , \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_SEQ_ \
+ )(params)
+
+#define BOOST_LOCAL_FUNCTION_PARAMS(params) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS(params)
+
+/** @todo Add to doc that this can never be bound by ref (as in C++) */
+
+/** @todo Validate params:
+ * 1. const_bind_this_count + bind_this_count > 1 => ERROR_object_this_cannot_be_bound_multiple_times
+ * 2. Inspect seq before parsing to make sure that default is never 1st and default always after an unbound param (no const-bind and no bind).
+ */
+
+BOOST_LOCAL_FUNCTION_PARAMS( (int x) (double y)(default 1.23)
+ (bind a) (bind& b) (const bind c) (const bind this) (const bind& d) )
+
+BOOST_LOCAL_FUNCTION_PARAMS( (default -1) (int x) (double y)(default 1.23)
+ (bind a) (bind& b) (const bind c) (const bind this) (const bind& d) )
+
+BOOST_LOCAL_FUNCTION_PARAMS( (int x) (double y)(default 1.23)
+ (bind a) (bind& b) (default -1) (const bind this) (const bind& d) )
+
+BOOST_LOCAL_FUNCTION_PARAMS( (bind this) (int x) (bind this)
+ (bind a) (const bind this) (const bind& d) )
+
+BOOST_LOCAL_FUNCTION_PARAMS(void)
+
+BOOST_LOCAL_FUNCTION_PARAMS( (void) )
+
+BOOST_LOCAL_FUNCTION_PARAMS()
+

Added: sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/bind.hpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/bind.hpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,56 @@
+
+// Copyright (C) 2009-2011 Lorenzo Caminiti
+// Use, modification, and distribution is subject to the
+// Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+#ifndef BOOST_LOCAL_AUX_PP_KEYWORD_BIND_HPP_
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_HPP_
+
+#include <boost/detail/preprocessor/keyword/utility/is.hpp>
+#include <boost/detail/preprocessor/keyword/utility/add.hpp>
+#include <boost/detail/preprocessor/keyword/utility/remove.hpp>
+
+// These are not local macros -- DO NOT #UNDEF.
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS_bind (1) /* unary */
+#define bind_BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS (1) /* unary */
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_bind /* nothing */
+#define bind_BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE /* nothing */
+
+// Is.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_IS_FRONT(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS_)
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_BACK(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_IS_BACK(tokens, \
+ _BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS)
+
+// Rremove.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_FRONT(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_REMOVE_FRONT(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_)
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_BACK(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_REMOVE_BACK(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_BACK, \
+ _BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE)
+
+// Add.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_ADD_FRONT(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_ADD_FRONT(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT, \
+ bind)
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_ADD_BACK(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_ADD_BACK(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_BACK, \
+ bind)
+
+#endif // #include guard
+

Added: sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/const_bind.hpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/params_name/aux_/preprocessor/keyword/const_bind.hpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,70 @@
+
+// Copyright (C) 2009-2011 Lorenzo Caminiti
+// Use, modification, and distribution is subject to the
+// Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+#ifndef BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_HPP_
+#define BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_HPP_
+
+#include "bind.hpp"
+#include <boost/detail/preprocessor/keyword/const.hpp>
+#include <boost/detail/preprocessor/keyword/utility/add.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+
+// These are not local macros -- DO NOT #UNDEF.
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS_bind (1) /* unary */
+#define bind_BOOST_LOCAL_AUX_PP_KEYWORD_BIND_IS (1) /* unary */
+#define BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_bind /* nothing */
+#define bind_BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE /* nothing */
+
+// Is.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT_(tokens) \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_FRONT( \
+ BOOST_DETAIL_PP_KEYWORD_CONST_REMOVE_FRONT(tokens))
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT(tokens) \
+ BOOST_PP_IIF(BOOST_DETAIL_PP_KEYWORD_IS_CONST_FRONT(tokens), \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT_ \
+ , \
+ 0 BOOST_PP_TUPLE_EAT(1) \
+ )(tokens)
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_BACK_(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_IS_CONST_BACK( \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_BACK(tokens))
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONDT_BIND_BACK(tokens) \
+ BOOST_PP_IIF(BOOST_LOCAL_AUX_PP_KEYWORD_IS_BIND_BACK(tokens) \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_BACK_ \
+ , \
+ 0 BOOST_PP_TUPLE_EAT(1) \
+ )(tokens)
+
+// Rremove.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_REMOVE_FRONT(tokens) \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_FRONT( \
+ BOOST_DETAIL_PP_KEYWORD_CONST_REMOVE_FRONT(tokens))
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_REMOVE_BACK(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_CONST_REMOVE_BACK( \
+ BOOST_LOCAL_AUX_PP_KEYWORD_BIND_REMOVE_BACK(tokens))
+
+// Add.
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_ADD_FRONT(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_ADD_FRONT(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_FRONT, \
+ const bind)
+
+#define BOOST_LOCAL_AUX_PP_KEYWORD_CONST_BIND_ADD_BACK(tokens) \
+ BOOST_DETAIL_PP_KEYWORD_UTILITY_ADD_BACK(tokens, \
+ BOOST_LOCAL_AUX_PP_KEYWORD_IS_CONST_BIND_BACK, \
+ const bind)
+
+#endif // #include guard
+

Added: sandbox/local/libs/local/params_name/aux_/preprocessor/sign/params_/is_void.hpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/params_name/aux_/preprocessor/sign/params_/is_void.hpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,40 @@
+
+
+#ifndef BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID_HPP_
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID_HPP_
+
+#include <boost/detail/preprocessor/keyword/void.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/facilities/is_empty.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/seq.hpp> // For `SEQ_HEAD`.
+
+// Private API.
+
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID_TOKEN_(token) \
+ BOOST_PP_IIF(BOOST_PP_IS_EMPTY(token), \
+ 1 /* handles empty params `()` as no params (C99 only) */ \
+ BOOST_PP_EMPTY \
+ , \
+ BOOST_DETAIL_PP_KEYWORD_IS_VOID_FRONT \
+ )(token)
+
+#define BOOST_LOCLAL_AUX_PP_SIGN_PARAMS_IS_VOID_SEQ_(params_seq) \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID_TOKEN_( \
+ BOOST_PP_SEQ_HEAD(params_seq))
+
+// Public API.
+
+// Expand to 1 iff params_seq is empty (C99 only), or `void` (supported also
+// for C++ but similar to unparenthesized paramter syntax for C99), or `(void)`
+// (parenthesized parameter syntax for C++).
+#define BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID(params) \
+ BOOST_PP_IIF(BOOST_PP_IS_UNARY(params), \
+ BOOST_LOCLAL_AUX_PP_SIGN_PARAMS_IS_VOID_SEQ_ \
+ , /* else, it's a sequence */ \
+ BOOST_LOCAL_AUX_PP_SIGN_PARAMS_IS_VOID_TOKEN_ \
+ )(params)
+
+#endif // #include guard
+

Modified: sandbox/local/libs/local/simpler_syntax/00.cpp
==============================================================================
--- sandbox/local/libs/local/simpler_syntax/00.cpp (original)
+++ sandbox/local/libs/local/simpler_syntax/00.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -1,12 +1,4 @@
-void BOOST_LOCAL_FUNCTION_PARAMS(
- (double& x) (auto int y)(default -1) (register int z)(default -2)
- (bind a) (bind& b) (const bind c) (const bind& d) ) {
- y = x;
-} BOOST_LOCAL_FUNCTION_NAME(f)
- int x
-double& y
- -1
+0
+1
1
1
- (bind a) (bind& b)
- (const bind c) (const bind& d)

Added: sandbox/local/libs/local/simpler_syntax/01.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/01.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,30 @@
+
+#include <boost/preprocessor.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+
+#define IS_AUTO_auto (1) /* must expand to unary */
+#define IS_AUTO(tokens) BOOST_PP_IS_UNARY(BOOST_PP_CAT(IS_AUTO_, tokens))
+
+#define REMOVE_AUTO_STRIP_auto /* must expand to nothing */
+#define REMOVE_AUTO_(tokens) BOOST_PP_CAT(REMOVE_AUTO_STRIP_, tokens)
+#define REMOVE_AUTO(tokens) \
+ BOOST_PP_IIF(IS_AUTO(tokens), \
+ REMOVE_AUTO_ \
+ , \
+ tokens BOOST_PP_TUPLE_EAT(1) \
+ )(tokens)
+
+#define ADD_AUTO(tokens) \
+ BOOST_PP_EXPR_IIF(BOOST_PP_NOT(IS_AUTO(tokens)), auto) tokens
+
+
+IS_AUTO(auto int x) // 1
+IS_AUTO(int x) // 0
+
+REMOVE_AUTO(auto int x) // int x
+REMOVE_AUTO(int x) // int x
+
+ADD_AUTO(auto int x) // auto int x
+ADD_AUTO(int x) // auto int x
+
+

Added: sandbox/local/libs/local/simpler_syntax/02.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/02.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,51 @@
+
+#include <boost/preprocessor.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+#include <boost/preprocessor/facilities/is_empty.hpp>
+#include <boost/detail/preprocessor/keyword/void.hpp>
+
+
+/// VOID ///
+
+#define BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID_TOKEN_(token) \
+ BOOST_PP_IIF(BOOST_PP_IS_EMPTY(token), \
+ 1 /* handles empty params `()` as no params (C99 only) */ \
+ BOOST_PP_EMPTY \
+ , \
+ BOOST_DETAIL_PP_KEYWORD_IS_VOID_FRONT \
+ )(token)
+
+#define BOOST_LOCLAL_AUX_FUNCTION_PARAMS_IS_VOID_SEQ_(params_seq) \
+ BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID_TOKEN_( \
+ BOOST_PP_SEQ_HEAD(params_seq))
+
+// Expand to 1 iff params_seq is empty (C99 only), or `void` (supported also
+// for C++ but similar to unparenthesized paramter syntax for C99), or `(void)`
+// (parenthesized parameter syntax for C++).
+#define BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID(params_seq) \
+ BOOST_PP_IIF(BOOST_PP_IS_UNARY(params_seq), \
+ BOOST_LOCLAL_AUX_FUNCTION_PARAMS_IS_VOID_SEQ_ \
+ , /* else, it's a sequence */ \
+ BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID_TOKEN_ \
+ )(params_seq)
+
+//#define BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID(params_seq)
+// params_seq --> BOOST_PP_IS_EMPTY(params_seq)
+
+
+/// PARAMS ///
+
+#define BOOST_LOCAL_AUX_FUNCTION_PARAMS(params_seq) \
+ BOOST_LOCAL_AUX_FUNCTION_PARAMS_IS_VOID(params_seq)
+
+
+
+BOOST_LOCAL_AUX_FUNCTION_PARAMS( (int x) (double y)(default 1.23)
+ (bind a) (const bind b) (bind& c) (const bind& d) )
+
+BOOST_LOCAL_AUX_FUNCTION_PARAMS(void)
+
+BOOST_LOCAL_AUX_FUNCTION_PARAMS( (void) )
+
+BOOST_LOCAL_AUX_FUNCTION_PARAMS()
+

Modified: sandbox/local/libs/local/simpler_syntax/TODO.txt
==============================================================================
--- sandbox/local/libs/local/simpler_syntax/TODO.txt (original)
+++ sandbox/local/libs/local/simpler_syntax/TODO.txt 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -12,14 +12,54 @@

* Double check all local function syntax elements (from Grammar) -- auto, register, etc.

-* Rename is_xxx.hpp to xxx.hpp for all PP_KEYWORD and add the strip (leading) macros.
+* Provide bound parameter types within the body (via private typdefs in the functor class) as `BOUND_PARAM_NAME>_type` -- these can be used for concept checking, etc. Actually, provide access to the bind types via a macro BOOST_LOCAL_TYPEOF() so to hide the type name and to strip eventual const& (Vicente's idea).
+
+* Rename is_xxx.hpp to xxx.hpp for all PP_KEYWORD and add REMOVE and ADD macros:
+> #include <boost/preprocessor.hpp>
+> #include <boost/preprocessor/detail/is_unary.hpp>
+>
+> #define IS_AUTO_auto (1) /* must expand to unary */
+> #define IS_AUTO(tokens) BOOST_PP_IS_UNARY(BOOST_PP_CAT(IS_AUTO_, tokens))
+>
+> #define REMOVE_AUTO_STRIP_auto /* must expand to nothing */
+> #define REMOVE_AUTO_(tokens) BOOST_PP_CAT(REMOVE_AUTO_STRIP_, tokens)
+> #define REMOVE_AUTO(tokens) \
+> BOOST_PP_IIF(IS_AUTO(tokens), \
+> REMOVE_AUTO_ \
+> , \
+> tokens BOOST_PP_TUPLE_EAT(1) \
+> )(tokens)
+>
+> #define ADD_AUTO(tokens) \
+> BOOST_PP_EXPR_IIF(BOOST_PP_NOT(IS_AUTO(tokens)), auto) tokens
+>
+> IS_AUTO(auto int x) // 1
+> IS_AUTO(int x) // 0
+>
+> REMOVE_AUTO(auto int x) // int x
+> REMOVE_AUTO(int x) // int x
+>
+> ADD_AUTO(auto int x) // auto int x
+> ADD_AUTO(int x) // auto int x
+The names should actually be AUTO_IN_FRONT, AUTO_ADD_FRONT, AUTO_REMOVE_FRONT, AUTO_IN_BACK, AUTO_ADD_BACK, AUTO_REMOVE_BACK (the general stuff could go into keyword/utility/in.hpp, add.hpp, remove.hpp).

* Send comments on variadic_macro_data:

+* Optimize macro expansion code for C++0x, C++03, etc. From John Bytheway:
+> Yes, in C++0x local structs can be passed as template parameters.
+> Obviously, in C++0x there are lambdas too, so you might think your
+> library is useless, but I'd expect most compilers to support passing
+> local structs as template parameters before they support lambdas, so
+> there is some advantage in having this intermediate implementation.
+> Also, your macros would allow writing code that worked in C++0x and
+> C++03, with the virtual function business in only those compilers/modes
+> where it is necessary.

+* See if the two local functors `functor_factorial` and `factorial` can be declared `const`.

+* Make sure that when no bound params, none of the binding overhead code is generated by the macro expansion.

* Add comparison with Look at Alex-Steven's syntax to docs:
http://thread.gmane.org/gmane.comp.lib.boost.devel/168612/focus=168694

Added: sandbox/local/libs/local/simpler_syntax/concepts.00.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/concepts.00.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,52 @@
+
+// Copyright (C) 2009-2011 Lorenzo Caminiti
+// Use, modification, and distribution is subject to the
+// Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+// Simple parenthesized syntax example used by the documentation.
+
+//[ add_num_factor_sum_cpp
+#include <boost/local/function.hpp>
+#include <boost/concept_check.hpp>
+#include <iostream>
+
+template<typename T>
+class Addable {
+ T x;
+ T y;
+ void return_type(T); // Used to check addition returns type `T`.
+public:
+ BOOST_CONCEPT_USAGE(Addable) {
+ return_type(x + y); // Check addition `T operator+(T x, T y)`.
+ }
+};
+
+struct pod {};
+
+#define BOOST_LOCAL_TYPEOF(bind_name) \
+ boost::remove_const<boost::remove_reference< \
+ BOOST_PP_CAT(bind_name, Xtype)>::type>::type
+
+int main() {
+ double sum = 0.0;
+ //pod sum;
+ int factor = 10;
+
+ BOOST_LOCAL_FUNCTION(
+ (void) (add)( (double)(num) (const bind)((factor)) (bind)((&sum)) )
+ ) {
+ typedef boost_se_params_t_add35::boost_se_param_t_1_add35* &sum_type;
+ BOOST_CONCEPT_ASSERT((Addable<
+ boost::remove_reference<sum_type>::type>));
+
+ sum = sum + factor * num;
+ } BOOST_LOCAL_FUNCTION_END(add)
+
+ add(100.0);
+
+ return 0;
+}
+//]
+

Added: sandbox/local/libs/local/simpler_syntax/concepts_c99.00.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/concepts_c99.00.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,43 @@
+
+// Copyright (C) 2009-2011 Lorenzo Caminiti
+// Use, modification, and distribution is subject to the
+// Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+// Simple parenthesized syntax example used by the documentation.
+
+//[ add_num_factor_sum_cpp
+#include <boost/local/function.hpp>
+#include <boost/concept_check.hpp>
+#include <iostream>
+
+template<typename T>
+class Addable {
+ T x;
+ T y;
+ void return_type(T); // Used to check addition returns type `T`.
+public:
+ BOOST_CONCEPT_USAGE(Addable) {
+ return_type(x + y); // Check addition `T operator+(T x, T y)`.
+ }
+};
+
+struct pod {};
+
+int main() {
+ pod sum;
+ int factor = 10;
+
+ void BOOST_LOCAL_FUNCTION_PARAMS(double num, const bind factor, bind& sum) {
+ BOOST_CONCEPT_ASSERT((Addable<boost::remove_reference<sum_type>::type>));
+
+ sum = sum + factor * num;
+ } BOOST_LOCAL_FUNCTION_NAME(add)
+
+ add(100.0);
+
+ return 0;
+}
+//]
+

Added: sandbox/local/libs/local/simpler_syntax/factorial_nomacros.07.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/factorial_nomacros.07.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,210 @@
+
+// Copyright (C) 2009-2011 Lorenzo Caminiti
+// Use, modification, and distribution is subject to the
+// Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+// Use recursion, default parameters, and bind by non-const reference.
+
+//[ factorial_cpp
+#include <boost/local/function.hpp>
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+
+int main () {
+ std::ostringstream output;
+
+ int // Result type (outside the `PARAMS` macro).
+
+ // On all C++ preprocessors (including C99 preprocessors) the macro:
+ //
+ // int BOOST_LOCAL_FUNCTION_PARAMS(
+ // (int n) (bool recursion)(default false) (bind& output) )
+ //
+ // Or, on C99 preprocessors only the macro:
+ //
+ // int BOOST_LOCAL_FUNCTION_PARAMS(
+ // int n, bool recursion, default false, bind& output)
+ //
+ // Expands to code equivalent to the following.
+ //
+ // NOTE:
+ // * Use line number `__LINE__` (e.g., `..._29`) to generate unique symbols.
+ // * Parameter name not available separately from its type.
+ // * Function name NOT available.
+
+// In actual expansion, the following tokens are made available as macro
+// parameters (and not as macro symbols) by the `PARAMS` macro:
+#define PARAMS_arg_0 auto int n
+#define PARAMS_arg_with_dflt_0 PARAMS_arg_0 // No default.
+#define PARAMS_arg_1 register bool recursion
+#define PARAMS_arg_with_dflt_1 PARAMS_arg_1 = false
+#define PARAMS_bind_0 &output
+#define PARAMS_is_const_bind_0 0 // Not a constant bind.
+
+ // Function traits.
+ // NOTE: Following result type specified just before the `PARAMS` macro.
+ // Default parameter values need to be separated from their parameter types
+ // and names because they are not part of the function type so they cannot
+ // be used by the following expressions and their number cannot be count
+ // at compile-time using template metaprogramming.
+ ERROR_missing_result_type_at_line_29(PARAMS_arg_0, PARAMS_arg_1);
+ /** @todo This typeof requires registration of result, arg, etc type? */
+ typedef BOOST_TYPEOF(ERROR_missing_result_type_at_line_29) function_type_29;
+ typedef boost::function_traits<function_type_29>::result_type
+ result_type_29;
+ typedef boost::function_traits<function_type_29>::arg1_type arg_type_0_29;
+ typedef boost::function_traits<function_type_29>::arg2_type arg_type_1_29;
+
+ // Handle bound parameters as done by Boost.ScopeEixt, deducing their types
+ // (using Boost.Typeof) and storing them by reference or by value.
+ typedef void (*bind_deduce_type_0_29)(int PARAMS_bind_0);
+ typedef BOOST_TYPEOF(
+ boost::scope_exit::aux::wrap(boost::scope_exit::aux::deref(
+ PARAMS_bind_0, static_cast<bind_deduce_type_0_29>(0))))
+ bind_wrapped_type_0_29;
+ typedef bind_wrapped_type_0_29::type capture_bind_type_0_29;
+ // Hold bound parameter types and values.
+ struct binds_29 {
+ typedef capture_bind_type_0_29 bind_type_0_29;
+ boost::scope_exit::aux::member<bind_type_0_29, bind_deduce_type_0_29>
+ bind_value_0_29;
+ } params_29 = { // Must use this initializer because reference members.
+#if defined(__GNUC__)
+ { // NOTE: Curly brakets are required by GCC but not supported by MSVC.
+#endif
+ boost::scope_exit::aux::deref(PARAMS_bind_0,
+ static_cast<bind_deduce_type_0_29>(0))
+#if defined(__GNUC__)
+ } // NOTE: Curly brakets are required by GCC but not supported by MSVC.
+#endif
+ };
+ // NOTE: The `args` variable is declared globally and not prefixed with
+ // __LINE__ so it can be used by both the `PARAMS` and `NAME`. The special
+ // template declaration type prevents this variable to be declared multiple
+ // times within the same scope.
+ boost::scope_exit::aux::declared<boost::scope_exit::aux::resolve<
+ sizeof(boost_local_auxXargs)>::cmp1<0>::cmp2> boost_local_auxXargs;
+ boost_local_auxXargs.value = &params_29;
+
+ // Functor for local function.
+ class functor_29:
+ // Base used to assign local functions to `function_ref` which can
+ // then be passed as template parameter.
+ public ::boost::local::aux::function_base<function_type_29, 1> {
+ public:
+ explicit functor_29(void* binds):
+ binds_(static_cast<binds_29*>(binds)) {
+ init_recursion();
+ }
+ result_type_29 operator()(arg_type_0_29 arg_0, arg_type_1_29 arg_1) {
+ assert(binds_);
+ return body(
+ binds_->bind_value_0_29.value
+ // Using general names `arg_i` because parameter types and
+ // names are not separated by the preprocessor so the actual
+ // argument name (e.g., `n`) is not available here.
+ , arg_0, arg_1
+ );
+ }
+ // Overloading to support default parameters.
+ result_type_29 operator()(arg_type_0_29 arg_0) {
+ assert(binds_);
+ return body(
+ binds_->bind_value_0_29.value
+ , arg_0
+ );
+ }
+ private:
+ // Non local functor type that can be passed as template parameter.
+ typedef ::boost::local::function_ref<function_type_29, 1> functor_type;
+ // Hold bound parameter values.
+ binds_29* binds_;
+ // LIMITATION: Body cannot be static because it has to access the
+ // member named after the function name for recursive calls (the
+ // function name is not know to this macro). However, ideally the body
+ // will be static so to prevent using `this` instead of `this_` by
+ // mistake (in most cases this will still cause a compile-time error
+ // because when functor has a different structure than the bound object
+ // `this_` -- but that is not the case if `this` is mistakenly used
+ // instead of `this` to do pointer operations). Programmers need to
+ // inspect the local function body code by eye and make sure that
+ // `this` is not used by the body code.
+ result_type_29 body(
+#if PARAMS_is_const_bind_0
+ ::boost::add_const< // Handle constant binding.
+#endif
+ binds_29::bind_type_0_29
+#if PARAMS_is_const_bind_0
+ >::type
+#endif
+ PARAMS_bind_0
+ , PARAMS_arg_with_dflt_0
+ , PARAMS_arg_with_dflt_1)
+
+ // Local function body (specified by programmers outside the macros).
+
+ {
+ int result = 0;
+ if (n < 2 ) result = 1;
+ else result = n * factorial(n - 1, true); // Recursive call.
+
+ if (!recursion) output << result << " ";
+ return result;
+ }
+
+// All `..._29` and `PARAMS_...` symbols are only available for within `PARAMS`
+// macro expansion for the code above.
+#undef PARAMS_arg0
+#undef PARAMS_dflt0
+#undef PARAMS_arg1
+#undef PARAMS_dflt1
+#undef PARAMS_bind0
+
+ // The macro:
+ //
+ // BOOST_LOCAL_FUNCTION_NAME(factorial)
+ //
+ // Expands to code equivalent to the following. Note:
+ //
+ // * Use function name `factorial` and/or line number `__LINE__`
+ // (e.g., `..._31`) to generate unique symbols.
+ // * Function name `factorial` available.
+ // * None of the `..._29` symbols are available (different `__LINE__`).
+
+ // Cannot be programmed in the constructor because it sets the
+ // `factorial` member with name only known in this macro expansion.
+ void init_recursion() { factorial = *this; }
+
+ public:
+ // Member with function name for recursive calls. This cannot be
+ // defined sooner because the function name is only available here.
+ // Also, it is public so it can be used to deduce the functor type
+ // outside the expansion of the PARAMS macro (where the PARAMS symbols
+ // are no longer available because of the different __LINE__ number).
+ functor_type factorial;
+ } functor_factorial_31(boost_local_auxXargs.value);
+ // The struct type cannot be passed as template parameter but the function
+ // type `function_ref<...>` deduced here can.
+ BOOST_TYPEOF(functor_factorial_31.factorial) factorial(
+ functor_factorial_31);
+
+ // Rest of the program.
+
+ // Factorial of a single number.
+ factorial(3); // Call local function.
+
+ std::vector<int> v;
+ v.resize(3);
+ v[0] = 1; v[1] = 4; v[2] = 7;
+ // Factorials of all vector's elements.
+ std::for_each(v.begin(), v.end(), factorial); // Pass as template parameter.
+
+ std::cout << output.str() << std::endl;
+ return 0;
+}
+//]
+

Modified: sandbox/local/libs/local/simpler_syntax/jamfile.jam
==============================================================================
--- sandbox/local/libs/local/simpler_syntax/jamfile.jam (original)
+++ sandbox/local/libs/local/simpler_syntax/jamfile.jam 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -5,5 +5,5 @@
# (see accompanying file LICENSE_1_0.txt or a copy at
# http://www.boost.org/LICENSE_1_0.txt).

-exe factorial_nomacros : factorial_nomacros.06.cpp ;
+exe factorial_nomacros : factorial_nomacros.07.cpp ;

Added: sandbox/local/libs/local/simpler_syntax/pp_keyword.01.cpp
==============================================================================
--- (empty file)
+++ sandbox/local/libs/local/simpler_syntax/pp_keyword.01.cpp 2011-02-14 17:05:43 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,30 @@
+
+#include <boost/preprocessor.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+
+#define IS_AUTO_auto (1) /* must expand to unary */
+#define IS_AUTO(tokens) BOOST_PP_IS_UNARY(BOOST_PP_CAT(IS_AUTO_, tokens))
+
+#define REMOVE_AUTO_STRIP_auto /* must expand to nothing */
+#define REMOVE_AUTO_(tokens) BOOST_PP_CAT(REMOVE_AUTO_STRIP_, tokens)
+#define REMOVE_AUTO(tokens) \
+ BOOST_PP_IIF(IS_AUTO(tokens), \
+ REMOVE_AUTO_ \
+ , \
+ tokens BOOST_PP_TUPLE_EAT(1) \
+ )(tokens)
+
+#define ADD_AUTO(tokens) \
+ BOOST_PP_EXPR_IIF(BOOST_PP_NOT(IS_AUTO(tokens)), auto) tokens
+
+
+IS_AUTO(auto int x) // 1
+IS_AUTO(int x) // 0
+
+REMOVE_AUTO(auto int x) // int x
+REMOVE_AUTO(int x) // int x
+
+ADD_AUTO(auto int x) // auto int x
+ADD_AUTO(int x) // auto int x
+
+

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r68874 - trunk/boost/random"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r68872 - in trunk: boost/random libs/random/doc libs/random/performance"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk