From 06930616b2da392565b272ce8e8025f2fa1381ac Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Jun 2014 10:02:46 +0900 Subject: [PATCH 1/9] Added cmake files. https://github.com/msgpack/msgpack-c/pull/20 Removed 'preprocess' from original CMakeLists.txt. Removed file copy from original CMakeLists.txt. Removed 'preprocess' from bootstrap. Removed file copy from bootstrap. Added erb generated files. Ruby is no longer required. Moved cases.mpac, cases_compact.mpa, pack_define.h, pack_template.h, unpack_define.h, unpack_template.h, and sysdep.h to apropriate location. If you want to re-generate zone.hpp, define.hpp, and tuple.hpp, then you execute preprocess. --- .gitignore | 10 - CMakeLists.txt | 155 + bootstrap | 7 - preprocess | 23 +- pack_define.h => src/msgpack/pack_define.h | 0 .../msgpack/pack_template.h | 0 sysdep.h => src/msgpack/sysdep.h | 0 src/msgpack/type/define.hpp | 3465 ++++ src/msgpack/type/tuple.hpp | 13691 ++++++++++++++++ .../msgpack/unpack_define.h | 0 .../msgpack/unpack_template.h | 0 src/msgpack/zone.hpp | 464 + test/CMakeLists.txt | 45 + cases.mpac => test/cases.mpac | Bin cases_compact.mpac => test/cases_compact.mpac | Bin 15 files changed, 17823 insertions(+), 37 deletions(-) create mode 100644 CMakeLists.txt rename pack_define.h => src/msgpack/pack_define.h (100%) rename pack_template.h => src/msgpack/pack_template.h (100%) rename sysdep.h => src/msgpack/sysdep.h (100%) create mode 100644 src/msgpack/type/define.hpp create mode 100644 src/msgpack/type/tuple.hpp rename unpack_define.h => src/msgpack/unpack_define.h (100%) rename unpack_template.h => src/msgpack/unpack_template.h (100%) create mode 100644 src/msgpack/zone.hpp create mode 100644 test/CMakeLists.txt rename cases.mpac => test/cases.mpac (100%) rename cases_compact.mpac => test/cases_compact.mpac (100%) diff --git a/.gitignore b/.gitignore index ca7355a4..ffc26910 100644 --- a/.gitignore +++ b/.gitignore @@ -9,16 +9,6 @@ /configure /msgpack_vc2008.sln /msgpack_vc2008.vcproj -/src/msgpack/pack_define.h -/src/msgpack/pack_template.h -/src/msgpack/sysdep.h -/src/msgpack/type/define.hpp -/src/msgpack/type/tuple.hpp -/src/msgpack/unpack_define.h -/src/msgpack/unpack_template.h -/src/msgpack/zone.hpp -/test/cases.mpac -/test/cases_compact.mpac Makefile.in # Files generated by the configure script. diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..bbb27baf --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,155 @@ +CMAKE_MINIMUM_REQUIRED (VERSION 2.8.7) +PROJECT (msgpack) + +SET (VERSION 0.5.7) +SET (VERSION_MAJOR 5) +SET (VERSION_MINOR 7) + + +FIND_PACKAGE (GTest) +FIND_PACKAGE (ZLIB) +FIND_PACKAGE (Threads) +IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND) + OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) +ENDIF () + +OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) + +INCLUDE (CheckCXXSourceCompiles) +CHECK_CXX_SOURCE_COMPILES (" +#include +int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; } +int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; } +int main(int argc, char * argv[]) +{ + atomic_sub(1); + atomic_add(1); +} +" MSGPACK_ENABLE_GCC_CXX_ATOMIC) + +IF (MSGPACK_ENABLE_CXX) + LIST (APPEND msgpack_SOURCES + src/object.cpp + ) +ENDIF () + +IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC) + LIST (APPEND msgpack_SOURCES + src/gcc_atomic.cpp + ) +ENDIF () + + +LIST (APPEND msgpack_SOURCES + src/unpack.c + src/objectc.c + src/version.c + src/vrefbuffer.c + src/zone.c +) + +LIST (APPEND msgpack_HEADERS + src/msgpack/pack_define.h + src/msgpack/pack_template.h + src/msgpack/unpack_define.h + src/msgpack/unpack_template.h + src/msgpack/sysdep.h + src/msgpack.h + src/msgpack/sbuffer.h + src/msgpack/version.h + src/msgpack/vrefbuffer.h + src/msgpack/zbuffer.h + src/msgpack/pack.h + src/msgpack/unpack.h + src/msgpack/object.h + src/msgpack/zone.h +) + +IF (MSGPACK_ENABLE_CXX) + LIST (APPEND msgpack_HEADERS + src/msgpack.hpp + src/msgpack/sbuffer.hpp + src/msgpack/vrefbuffer.hpp + src/msgpack/zbuffer.hpp + src/msgpack/pack.hpp + src/msgpack/unpack.hpp + src/msgpack/object.hpp + src/msgpack/zone.hpp + src/msgpack/type.hpp + src/msgpack/type/bool.hpp + src/msgpack/type/deque.hpp + src/msgpack/type/float.hpp + src/msgpack/type/fixint.hpp + src/msgpack/type/int.hpp + src/msgpack/type/list.hpp + src/msgpack/type/map.hpp + src/msgpack/type/nil.hpp + src/msgpack/type/pair.hpp + src/msgpack/type/raw.hpp + src/msgpack/type/set.hpp + src/msgpack/type/string.hpp + src/msgpack/type/vector.hpp + src/msgpack/type/tuple.hpp + src/msgpack/type/define.hpp + src/msgpack/type/tr1/unordered_map.hpp + src/msgpack/type/tr1/unordered_set.hpp + ) +ENDIF () + +IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + SET_SOURCE_FILES_PROPERTIES(${msgpack_SOURCES} PROPERTIES LANGUAGE CXX) +ENDIF () + +EXECUTE_PROCESS ( + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack +) + +CONFIGURE_FILE ( + src/msgpack/version.h.in + ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h +) + +INCLUDE_DIRECTORIES ( + ./ + src/ + src/msgpack/ + ${CMAKE_CURRENT_BINARY_DIR}/src/ + ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/ +) + +ADD_LIBRARY (msgpack + ${msgpack_SOURCES} + ${msgpack_HEADERS} +) + +IF (MSGPACK_BUILD_TESTS) + ENABLE_TESTING () + ADD_SUBDIRECTORY (test) +ENDIF () + +# Doxygen +FIND_PACKAGE (Doxygen) +IF (DOXYGEN_FOUND) + ADD_CUSTOM_TARGET ( + doxygen_c + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen_cpp + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen + DEPENDS doxygen_c doxygen_cpp + ) +ENDIF () diff --git a/bootstrap b/bootstrap index 1ff6b76e..bf39812f 100755 --- a/bootstrap +++ b/bootstrap @@ -38,13 +38,6 @@ test -f ChangeLog || touch ChangeLog test -f NEWS || touch NEWS test -f README || cp -f README.md README -./preprocess -if [ $? -ne 0 ]; then - exit 1 -fi - - - ACLOCAL="aclocal" ACLOCAL_FILES="aclocal.m4" ALWAYS_CLEAN="config.status config.log config.cache libtool" diff --git a/preprocess b/preprocess index 839eb137..96280d59 100755 --- a/preprocess +++ b/preprocess @@ -12,23 +12,6 @@ preprocess() { fi } -if [ "$1" = "clean" ];then - rm -f src/msgpack/type/tuple.hpp - rm -f src/msgpack/type/define.hpp - rm -f src/msgpack/zone.hpp -else - preprocess src/msgpack/type/tuple.hpp - preprocess src/msgpack/type/define.hpp - preprocess src/msgpack/zone.hpp -fi -cp -f sysdep.h src/msgpack/ -cp -f pack_define.h src/msgpack/ -cp -f pack_template.h src/msgpack/ -cp -f unpack_define.h src/msgpack/ -cp -f unpack_template.h src/msgpack/ -cp -f cases.mpac test/ -cp -f cases_compact.mpac test/ - -sed -e 's/8\.00/9.00/' < msgpack_vc8.vcproj > msgpack_vc2008.vcproj -sed -e 's/9\.00/10.00/' -e 's/msgpack_vc8/msgpack_vc2008/' < msgpack_vc8.sln > msgpack_vc2008.sln - +preprocess src/msgpack/type/tuple.hpp +preprocess src/msgpack/type/define.hpp +preprocess src/msgpack/zone.hpp diff --git a/pack_define.h b/src/msgpack/pack_define.h similarity index 100% rename from pack_define.h rename to src/msgpack/pack_define.h diff --git a/pack_template.h b/src/msgpack/pack_template.h similarity index 100% rename from pack_template.h rename to src/msgpack/pack_template.h diff --git a/sysdep.h b/src/msgpack/sysdep.h similarity index 100% rename from sysdep.h rename to src/msgpack/sysdep.h diff --git a/src/msgpack/type/define.hpp b/src/msgpack/type/define.hpp new file mode 100644 index 00000000..bb8e2137 --- /dev/null +++ b/src/msgpack/type/define.hpp @@ -0,0 +1,3465 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_DEFINE_HPP__ +#define MSGPACK_TYPE_DEFINE_HPP__ + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum) \ + namespace msgpack { \ + template <> \ + inline enum& operator>> (object o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return v; \ + } \ + template <> \ + inline void operator<< (object::with_zone& o, const enum& v) \ + { \ + o << static_cast(v); \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast(v); \ + } \ + }; \ + } \ + } + +namespace msgpack { +namespace type { + + + +template +struct define; + + +template <> +struct define<> { + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = NULL; + o->via.array.size = 0; + } +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0) : + a0(_a0) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(1); + + pk.pack(a0); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*1); + o->via.array.size = 1; + + o->via.array.ptr[0] = object(a0, z); + } + + A0& a0; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1) : + a0(_a0), a1(_a1) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(2); + + pk.pack(a0); + pk.pack(a1); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*2); + o->via.array.size = 2; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + } + + A0& a0; + A1& a1; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(3); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*3); + o->via.array.size = 3; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + } + + A0& a0; + A1& a1; + A2& a2; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(4); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*4); + o->via.array.size = 4; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(5); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*5); + o->via.array.size = 5; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(6); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*6); + o->via.array.size = 6; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(7); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*7); + o->via.array.size = 7; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(8); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*8); + o->via.array.size = 8; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(9); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*9); + o->via.array.size = 9; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(10); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*10); + o->via.array.size = 10; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(11); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*11); + o->via.array.size = 11; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(12); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*12); + o->via.array.size = 12; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(13); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*13); + o->via.array.size = 13; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(14); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*14); + o->via.array.size = 14; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(15); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*15); + o->via.array.size = 15; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(16); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*16); + o->via.array.size = 16; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(17); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*17); + o->via.array.size = 17; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(18); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*18); + o->via.array.size = 18; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(19); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*19); + o->via.array.size = 19; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(20); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*20); + o->via.array.size = 20; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(21); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*21); + o->via.array.size = 21; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(22); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*22); + o->via.array.size = 22; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(23); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*23); + o->via.array.size = 23; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(24); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*24); + o->via.array.size = 24; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(25); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*25); + o->via.array.size = 25; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(26); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*26); + o->via.array.size = 26; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(27); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*27); + o->via.array.size = 27; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(28); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 28: ptr[27].convert(&a27); + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*28); + o->via.array.size = 28; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(29); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 29: ptr[28].convert(&a28); + case 28: ptr[27].convert(&a27); + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*29); + o->via.array.size = 29; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(30); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 30: ptr[29].convert(&a29); + case 29: ptr[28].convert(&a28); + case 28: ptr[27].convert(&a27); + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*30); + o->via.array.size = 30; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(31); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 31: ptr[30].convert(&a30); + case 30: ptr[29].convert(&a29); + case 29: ptr[28].convert(&a28); + case 28: ptr[27].convert(&a27); + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*31); + o->via.array.size = 31; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; + A30& a30; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(32); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + pk.pack(a31); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 32: ptr[31].convert(&a31); + case 31: ptr[30].convert(&a30); + case 30: ptr[29].convert(&a29); + case 29: ptr[28].convert(&a28); + case 28: ptr[27].convert(&a27); + case 27: ptr[26].convert(&a26); + case 26: ptr[25].convert(&a25); + case 25: ptr[24].convert(&a24); + case 24: ptr[23].convert(&a23); + case 23: ptr[22].convert(&a22); + case 22: ptr[21].convert(&a21); + case 21: ptr[20].convert(&a20); + case 20: ptr[19].convert(&a19); + case 19: ptr[18].convert(&a18); + case 18: ptr[17].convert(&a17); + case 17: ptr[16].convert(&a16); + case 16: ptr[15].convert(&a15); + case 15: ptr[14].convert(&a14); + case 14: ptr[13].convert(&a13); + case 13: ptr[12].convert(&a12); + case 12: ptr[11].convert(&a11); + case 11: ptr[10].convert(&a10); + case 10: ptr[9].convert(&a9); + case 9: ptr[8].convert(&a8); + case 8: ptr[7].convert(&a7); + case 7: ptr[6].convert(&a6); + case 6: ptr[5].convert(&a5); + case 5: ptr[4].convert(&a4); + case 4: ptr[3].convert(&a3); + case 3: ptr[2].convert(&a2); + case 2: ptr[1].convert(&a1); + case 1: ptr[0].convert(&a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*32); + o->via.array.size = 32; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + o->via.array.ptr[31] = object(a31, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; + A30& a30; + A31& a31; +}; + + +inline define<> make_define() +{ + return define<>(); +} + +template +define make_define(A0& a0) +{ + return define(a0); +} + +template +define make_define(A0& a0, A1& a1) +{ + return define(a0, a1); +} + +template +define make_define(A0& a0, A1& a1, A2& a2) +{ + return define(a0, a1, a2); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3) +{ + return define(a0, a1, a2, a3); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) +{ + return define(a0, a1, a2, a3, a4); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) +{ + return define(a0, a1, a2, a3, a4, a5); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) +{ + return define(a0, a1, a2, a3, a4, a5, a6); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + + +} // namespace type +} // namespace msgpack + + +#endif /* msgpack/type/define.hpp */ + diff --git a/src/msgpack/type/tuple.hpp b/src/msgpack/type/tuple.hpp new file mode 100644 index 00000000..7a893dca --- /dev/null +++ b/src/msgpack/type/tuple.hpp @@ -0,0 +1,13691 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TUPLE_HPP__ +#define MSGPACK_TYPE_TUPLE_HPP__ + +#include "msgpack/object.hpp" + +namespace msgpack { + +namespace type { + +// FIXME operator== +// FIXME operator!= + + +template +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type { + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : _x(x.a27) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : _x(x.a27) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : _x(x.a28) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : _x(x.a27) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : _x(x.a28) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : _x(x.a29) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : _x(x.a27) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : _x(x.a28) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : _x(x.a29) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 30> : tuple_type { + tuple_element(tuple& x) : _x(x.a30) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : _x(x.a0) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : _x(x.a1) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : _x(x.a2) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : _x(x.a3) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : _x(x.a4) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : _x(x.a5) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : _x(x.a6) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : _x(x.a7) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : _x(x.a8) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : _x(x.a9) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : _x(x.a10) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : _x(x.a11) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : _x(x.a12) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : _x(x.a13) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : _x(x.a14) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : _x(x.a15) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : _x(x.a16) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : _x(x.a17) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : _x(x.a18) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : _x(x.a19) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : _x(x.a20) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : _x(x.a21) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : _x(x.a22) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : _x(x.a23) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : _x(x.a24) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : _x(x.a25) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : _x(x.a26) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : _x(x.a27) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : _x(x.a28) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : _x(x.a29) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 30> : tuple_type { + tuple_element(tuple& x) : _x(x.a30) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + +template +struct tuple_element, 31> : tuple_type { + tuple_element(tuple& x) : _x(x.a31) {} + typename tuple_type::reference get() { return _x; } + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::reference _x; +}; + + + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a27) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a27) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a28) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a27) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a28) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a29) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a27) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a28) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a29) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 30> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a30) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a0) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a1) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a2) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a3) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a4) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a5) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a6) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a7) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a8) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a9) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a10) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a11) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a12) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a13) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a14) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a15) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a16) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a17) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a18) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a19) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a20) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a21) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a22) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a23) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a24) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a25) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a26) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a27) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a28) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a29) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 30> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a30) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + +template +struct const_tuple_element, 31> : tuple_type { + const_tuple_element(const tuple& x) : _x(x.a31) {} + typename tuple_type::const_reference get() const { return _x; } +private: + typename tuple_type::const_reference _x; +}; + + + +template <> +struct tuple<> { + tuple() {} + tuple(object o) { o.convert(this); } + typedef tuple<> value_type; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0) : + a0(_a0) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : + a0(_a0), a1(_a1) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; + A30 a30; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; + A30 a30; + A31 a31; +}; + + +inline tuple<> make_tuple() +{ + return tuple<>(); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0) +{ + return tuple(a0); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) +{ + return tuple(a0, a1); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) +{ + return tuple(a0, a1, a2); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) +{ + return tuple(a0, a1, a2, a3); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) +{ + return tuple(a0, a1, a2, a3, a4); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) +{ + return tuple(a0, a1, a2, a3, a4, a5); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + + +} // namespace type + + +inline type::tuple<>& operator>> ( + object o, + type::tuple<>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 1) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 2) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 3) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 4) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 5) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 6) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 7) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 8) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 9) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 10) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 11) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 12) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 13) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 14) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 15) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 16) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 17) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 18) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 19) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 20) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 21) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 22) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 23) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 24) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 25) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 26) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 27) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 28) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[27].convert::type>(&v.template get<27>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 29) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[27].convert::type>(&v.template get<27>()); + o.via.array.ptr[28].convert::type>(&v.template get<28>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 30) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[27].convert::type>(&v.template get<27>()); + o.via.array.ptr[28].convert::type>(&v.template get<28>()); + o.via.array.ptr[29].convert::type>(&v.template get<29>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 31) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[27].convert::type>(&v.template get<27>()); + o.via.array.ptr[28].convert::type>(&v.template get<28>()); + o.via.array.ptr[29].convert::type>(&v.template get<29>()); + o.via.array.ptr[30].convert::type>(&v.template get<30>()); + return v; +} + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 32) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[27].convert::type>(&v.template get<27>()); + o.via.array.ptr[28].convert::type>(&v.template get<28>()); + o.via.array.ptr[29].convert::type>(&v.template get<29>()); + o.via.array.ptr[30].convert::type>(&v.template get<30>()); + o.via.array.ptr[31].convert::type>(&v.template get<31>()); + return v; +} + + +template +const packer& operator<< ( + packer& o, + const type::tuple<>& v) { + o.pack_array(0); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(1); + + o.pack(v.template get<0>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(2); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(3); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(4); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(5); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(6); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(7); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(8); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(9); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(10); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(11); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(12); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(13); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(14); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(15); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(16); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(17); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(18); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(19); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(20); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(21); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(22); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(23); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(24); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(25); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(26); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(27); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(28); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(29); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(30); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(31); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + return o; +} + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(32); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + o.pack(v.template get<31>()); + return o; +} + + +inline void operator<< ( + object::with_zone& o, + const type::tuple<>& v) { + o.type = type::ARRAY; + o.via.array.ptr = NULL; + o.via.array.size = 0; +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*1); + o.via.array.size = 1; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*2); + o.via.array.size = 2; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*3); + o.via.array.size = 3; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*4); + o.via.array.size = 4; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*5); + o.via.array.size = 5; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*6); + o.via.array.size = 6; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*7); + o.via.array.size = 7; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*8); + o.via.array.size = 8; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*9); + o.via.array.size = 9; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*10); + o.via.array.size = 10; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*11); + o.via.array.size = 11; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*12); + o.via.array.size = 12; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*13); + o.via.array.size = 13; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*14); + o.via.array.size = 14; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*15); + o.via.array.size = 15; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*16); + o.via.array.size = 16; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*17); + o.via.array.size = 17; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*18); + o.via.array.size = 18; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*19); + o.via.array.size = 19; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*20); + o.via.array.size = 20; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*21); + o.via.array.size = 21; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*22); + o.via.array.size = 22; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*23); + o.via.array.size = 23; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*24); + o.via.array.size = 24; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*25); + o.via.array.size = 25; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*26); + o.via.array.size = 26; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*27); + o.via.array.size = 27; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*28); + o.via.array.size = 28; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*29); + o.via.array.size = 29; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*30); + o.via.array.size = 30; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*31); + o.via.array.size = 31; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*32); + o.via.array.size = 32; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); + o.via.array.ptr[31] = object(v.template get<31>(), o.zone); +} + + +} // namespace msgpack + + +//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) { +// return o << "[]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << ", " << v.template get<31>() +// << "]"; +//} +// + +#endif /* msgpack/type/tuple.hpp */ + diff --git a/unpack_define.h b/src/msgpack/unpack_define.h similarity index 100% rename from unpack_define.h rename to src/msgpack/unpack_define.h diff --git a/unpack_template.h b/src/msgpack/unpack_template.h similarity index 100% rename from unpack_template.h rename to src/msgpack/unpack_template.h diff --git a/src/msgpack/zone.hpp b/src/msgpack/zone.hpp new file mode 100644 index 00000000..692fbf8c --- /dev/null +++ b/src/msgpack/zone.hpp @@ -0,0 +1,464 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2010 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_ZONE_HPP__ +#define MSGPACK_ZONE_HPP__ + +#include "zone.h" +#include +#include +#include + + +namespace msgpack { + + +class zone : public msgpack_zone { +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); + ~zone(); + +public: + void* malloc(size_t size); + void* malloc_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(std::auto_ptr obj); + + void clear(); + + void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + + template + T* allocate(); + + template + T* allocate(A1 a1); + + template + T* allocate(A1 a1, A2 a2); + + template + T* allocate(A1 a1, A2 a2, A3 a3); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15); + + +private: + void undo_malloc(size_t size); + + template + static void object_destructor(void* obj); + + typedef msgpack_zone base; + +private: + zone(const zone&); +}; + + + +inline zone::zone(size_t chunk_size) +{ + msgpack_zone_init(this, chunk_size); +} + +inline zone::~zone() +{ + msgpack_zone_destroy(this); +} + +inline void* zone::malloc(size_t size) +{ + void* ptr = msgpack_zone_malloc(this, size); + if(!ptr) { + throw std::bad_alloc(); + } + return ptr; +} + +inline void* zone::malloc_no_align(size_t size) +{ + void* ptr = msgpack_zone_malloc_no_align(this, size); + if(!ptr) { + throw std::bad_alloc(); + } + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + if(!msgpack_zone_push_finalizer(this, func, data)) { + throw std::bad_alloc(); + } +} + +template +inline void zone::push_finalizer(std::auto_ptr obj) +{ + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { + throw std::bad_alloc(); + } + obj.release(); +} + +inline void zone::clear() +{ + msgpack_zone_clear(this); +} + +inline void zone::swap(zone& o) +{ + msgpack_zone_swap(this, &o); +} + +template +void zone::object_destructor(void* obj) +{ + reinterpret_cast(obj)->~T(); +} + +inline void zone::undo_malloc(size_t size) +{ + base::chunk_list.ptr -= size; + base::chunk_list.free += size; +} + + +template +T* zone::allocate() +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} + + +} // namespace msgpack + +#endif /* msgpack/zone.hpp */ + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 00000000..a380e24e --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,45 @@ +FIND_PACKAGE (GTest REQUIRED) +FIND_PACKAGE (ZLIB REQUIRED) +FIND_PACKAGE (Threads REQUIRED) + +INCLUDE_DIRECTORIES ( + ${GTEST_INCLUDE_DIRS} + ${ZLIB_INCLUDE_DIRS} +) + +SET (check_PROGRAMS + pack_unpack.cc + version.cc + streaming_c.cc + pack_unpack_c.cc + zone.cc + msgpack_test.cpp + buffer.cc + msgpackc_test.cpp + streaming.cc + convert.cc + fixint_c.cc +) + +IF (MSGPACK_ENABLE_CXX) + LIST (APPEND check_PROGRAMS + cases.cc + fixint.cc + object.cc + ) +ENDIF () + +FOREACH (source_file ${check_PROGRAMS}) + GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) + ADD_EXECUTABLE ( + ${source_file_we} + ${source_file} + ) + TARGET_LINK_LIBRARIES (${source_file_we} + msgpack + ${GTEST_BOTH_LIBRARIES} + ${ZLIB_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ) + ADD_TEST (${source_file_we} ${source_file_we}) +ENDFOREACH () \ No newline at end of file diff --git a/cases.mpac b/test/cases.mpac similarity index 100% rename from cases.mpac rename to test/cases.mpac diff --git a/cases_compact.mpac b/test/cases_compact.mpac similarity index 100% rename from cases_compact.mpac rename to test/cases_compact.mpac From 643b0c95233ac1e0dfa80c4597be21345f02092b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 7 Jun 2014 00:13:23 +0900 Subject: [PATCH 2/9] Supported shared library on cmake. Updated the documentation. --- CMakeLists.txt | 10 +++++++++- README.md | 36 ++++++++++++++++++++++++++++++------ 2 files changed, 39 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bbb27baf..e12bcbbf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -117,11 +117,19 @@ INCLUDE_DIRECTORIES ( ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/ ) -ADD_LIBRARY (msgpack +ADD_LIBRARY (msgpack SHARED ${msgpack_SOURCES} ${msgpack_HEADERS} ) +ADD_LIBRARY (msgpack-static STATIC + ${msgpack_SOURCES} + ${msgpack_HEADERS} +) + +SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack") +SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib") + IF (MSGPACK_BUILD_TESTS) ENABLE_TESTING () ADD_SUBDIRECTORY (test) diff --git a/README.md b/README.md index 548e8af7..6d40cb2e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack #### Install from git repository +##### Using autotools You will need gcc (4.1.0 or higher), autotools. ``` @@ -37,6 +38,16 @@ $ make $ sudo make install ``` +##### Using cmake +You will need gcc (4.1.0 or higher), cmake. + +``` +$ git clone https://github.com/msgpack/msgpack-c.git +$ cd msgpack-c +$ cmake . +$ make +``` + #### Install from package ##### UNIX-like platform with ./configure @@ -79,16 +90,29 @@ $ sudo brew install msgpack ##### Windows -On Windows, download source package from [here](https://sourceforge.net/projects/msgpack/files/) and extract it. Open `msgpack_vc8.vcproj` or msgpack_vc2008 file and build it using batch build. It builds libraries in `lib/` folder and header files in `include/` folder. - -You can build using command line as follows: +Clone msgpack-c git repository. ``` -> vcbuild msgpack_vc2008.vcproj -> dir lib % DLL files are here -> dir include % header files are here +$ git clone https://github.com/msgpack/msgpack-c.git ``` +or using GUI git client. + +e.g.) tortoise git https://code.google.com/p/tortoisegit/ + +Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html + +Set 'Where is the source code:' text box and 'Where to build the binaries:' text box. + +Click 'Configure' button. + +Choose your Visual Studio version. + +Click 'Generate' button. + +Open the created msgpack.sln on Visual Studio. + +Build all. ### Linking with an Application From c8fa0be3453daffe7a288c24f2e1f36d9752d0a0 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 7 Jun 2014 14:39:59 +0000 Subject: [PATCH 3/9] Supported make install. Removed vc2008 files from make dist. --- CMakeLists.txt | 32 +++++++++++++++++++++++++++++--- Makefile.am | 4 +--- 2 files changed, 30 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e12bcbbf..6dcae8e9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,13 +48,18 @@ LIST (APPEND msgpack_SOURCES src/zone.c ) -LIST (APPEND msgpack_HEADERS +LIST (APPEND msgpack_root_HEADERS + src/msgpack.h +) + +LIST (APPEND msgpack_HEADERS ${msgpack_root_HEADERS}) + +LIST (APPEND msgpack_msgpack_HEADERS src/msgpack/pack_define.h src/msgpack/pack_template.h src/msgpack/unpack_define.h src/msgpack/unpack_template.h src/msgpack/sysdep.h - src/msgpack.h src/msgpack/sbuffer.h src/msgpack/version.h src/msgpack/vrefbuffer.h @@ -65,9 +70,15 @@ LIST (APPEND msgpack_HEADERS src/msgpack/zone.h ) +LIST (APPEND msgpack_HEADERS ${msgpack_msgpack_HEADERS}) + IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_HEADERS + LIST (APPEND msgpack_root_HEADERS src/msgpack.hpp + ) + LIST (APPEND msgpack_HEADERS ${msgpack_root_HEADERS}) + + LIST (APPEND msgpack_msgpack_HEADERS src/msgpack/sbuffer.hpp src/msgpack/vrefbuffer.hpp src/msgpack/zbuffer.hpp @@ -75,6 +86,10 @@ IF (MSGPACK_ENABLE_CXX) src/msgpack/unpack.hpp src/msgpack/object.hpp src/msgpack/zone.hpp + ) + LIST (APPEND msgpack_HEADERS ${msgpack_msgpack_HEADERS}) + + LIST (APPEND msgpack_type_HEADERS src/msgpack/type.hpp src/msgpack/type/bool.hpp src/msgpack/type/deque.hpp @@ -91,9 +106,14 @@ IF (MSGPACK_ENABLE_CXX) src/msgpack/type/vector.hpp src/msgpack/type/tuple.hpp src/msgpack/type/define.hpp + ) + LIST (APPEND msgpack_HEADERS ${msgpack_type_HEADERS}) + + LIST (APPEND msgpack_tr1_HEADERS src/msgpack/type/tr1/unordered_map.hpp src/msgpack/type/tr1/unordered_set.hpp ) + LIST (APPEND msgpack_HEADERS ${msgpack_tr1_HEADERS}) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") @@ -135,6 +155,12 @@ IF (MSGPACK_BUILD_TESTS) ADD_SUBDIRECTORY (test) ENDIF () +INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) +INSTALL (FILES ${msgpack_root_HEADERS} DESTINATION include) +INSTALL (FILES ${msgpack_msgpack_HEADERS} DESTINATION include/msgpack) +INSTALL (FILES ${msgpack_type_HEADERS} DESTINATION include/msgpack/type) +INSTALL (FILES ${msgpack_tr1_HEADERS} DESTINATION include/msgpack/type/tr1) + # Doxygen FIND_PACKAGE (Doxygen) IF (DOXYGEN_FOUND) diff --git a/Makefile.am b/Makefile.am index bcc24a42..0963e880 100644 --- a/Makefile.am +++ b/Makefile.am @@ -6,12 +6,10 @@ DOC_FILES = \ NOTICE \ msgpack_vc8.vcproj \ msgpack_vc8.sln \ - msgpack_vc2008.vcproj \ - msgpack_vc2008.sln \ msgpack_vc.postbuild.bat EXTRA_DIST = \ - $(DOC_FILES) + $(DOC_FILES) CMakeLists.txt test/CMakeLists.txt pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = msgpack.pc From fb1d480fafb7f02bea4ae74dd9c4bb907656a98d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 8 Jun 2014 14:05:33 +0000 Subject: [PATCH 4/9] Added the SOVERSION same as autotools. Set CMAKE_MINIMUM_REQUIRED to 2.6.4. --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6dcae8e9..85fa8f70 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,11 +1,10 @@ -CMAKE_MINIMUM_REQUIRED (VERSION 2.8.7) +CMAKE_MINIMUM_REQUIRED (VERSION 2.6.4) PROJECT (msgpack) SET (VERSION 0.5.7) SET (VERSION_MAJOR 5) SET (VERSION_MINOR 7) - FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) FIND_PACKAGE (Threads) @@ -149,6 +148,7 @@ ADD_LIBRARY (msgpack-static STATIC SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack") SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib") +SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 3.0.0) IF (MSGPACK_BUILD_TESTS) ENABLE_TESTING () From d15e30bf4ab0f71a23d1c8af312a2307bd55e824 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 8 Jun 2014 15:23:02 +0000 Subject: [PATCH 5/9] Fixed major_version and minor_version. Fixed relase_version. Added msgpack.pc creating proccess. --- CMakeLists.txt | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 85fa8f70..3794dbcb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,14 @@ CMAKE_MINIMUM_REQUIRED (VERSION 2.6.4) PROJECT (msgpack) -SET (VERSION 0.5.7) -SET (VERSION_MAJOR 5) -SET (VERSION_MINOR 7) +SET (VERSION 0.5.8) +SET (VERSION_MAJOR 0) +SET (VERSION_MINOR 5) + +SET (prefix ${CMAKE_INSTALL_PREFIX}) +SET (exec_prefix "\${prefix}") +SET (libdir "\${exec_prefix}/lib") +SET (includedir "\${prefix}/include") FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) @@ -128,6 +133,12 @@ CONFIGURE_FILE ( ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h ) +CONFIGURE_FILE ( + msgpack.pc.in + msgpack.pc + @ONLY +) + INCLUDE_DIRECTORIES ( ./ src/ @@ -160,6 +171,7 @@ INSTALL (FILES ${msgpack_root_HEADERS} DESTINATION include) INSTALL (FILES ${msgpack_msgpack_HEADERS} DESTINATION include/msgpack) INSTALL (FILES ${msgpack_type_HEADERS} DESTINATION include/msgpack/type) INSTALL (FILES ${msgpack_tr1_HEADERS} DESTINATION include/msgpack/type/tr1) +INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) From 04286eb9dcd13abdbb299875540c156b1a51eca9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 12 Jun 2014 11:18:06 +0900 Subject: [PATCH 6/9] Modified the way to install msgpack headers. --- CMakeLists.txt | 31 ++++--------------------------- 1 file changed, 4 insertions(+), 27 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3794dbcb..cf85cc43 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,13 +52,7 @@ LIST (APPEND msgpack_SOURCES src/zone.c ) -LIST (APPEND msgpack_root_HEADERS - src/msgpack.h -) - -LIST (APPEND msgpack_HEADERS ${msgpack_root_HEADERS}) - -LIST (APPEND msgpack_msgpack_HEADERS +LIST (APPEND msgpack_HEADERS src/msgpack/pack_define.h src/msgpack/pack_template.h src/msgpack/unpack_define.h @@ -74,15 +68,9 @@ LIST (APPEND msgpack_msgpack_HEADERS src/msgpack/zone.h ) -LIST (APPEND msgpack_HEADERS ${msgpack_msgpack_HEADERS}) - IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_root_HEADERS + LIST (APPEND msgpack_HEADERS src/msgpack.hpp - ) - LIST (APPEND msgpack_HEADERS ${msgpack_root_HEADERS}) - - LIST (APPEND msgpack_msgpack_HEADERS src/msgpack/sbuffer.hpp src/msgpack/vrefbuffer.hpp src/msgpack/zbuffer.hpp @@ -90,10 +78,6 @@ IF (MSGPACK_ENABLE_CXX) src/msgpack/unpack.hpp src/msgpack/object.hpp src/msgpack/zone.hpp - ) - LIST (APPEND msgpack_HEADERS ${msgpack_msgpack_HEADERS}) - - LIST (APPEND msgpack_type_HEADERS src/msgpack/type.hpp src/msgpack/type/bool.hpp src/msgpack/type/deque.hpp @@ -110,14 +94,9 @@ IF (MSGPACK_ENABLE_CXX) src/msgpack/type/vector.hpp src/msgpack/type/tuple.hpp src/msgpack/type/define.hpp - ) - LIST (APPEND msgpack_HEADERS ${msgpack_type_HEADERS}) - - LIST (APPEND msgpack_tr1_HEADERS src/msgpack/type/tr1/unordered_map.hpp src/msgpack/type/tr1/unordered_set.hpp ) - LIST (APPEND msgpack_HEADERS ${msgpack_tr1_HEADERS}) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") @@ -167,10 +146,8 @@ IF (MSGPACK_BUILD_TESTS) ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) -INSTALL (FILES ${msgpack_root_HEADERS} DESTINATION include) -INSTALL (FILES ${msgpack_msgpack_HEADERS} DESTINATION include/msgpack) -INSTALL (FILES ${msgpack_type_HEADERS} DESTINATION include/msgpack/type) -INSTALL (FILES ${msgpack_tr1_HEADERS} DESTINATION include/msgpack/type/tr1) +INSTALL (DIRECTORY src/msgpack DESTINATION include) +INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include) INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig) # Doxygen From 6daef66ea7db7c25cff572ecc70188676b039bb5 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 21 Jun 2014 11:11:32 +0900 Subject: [PATCH 7/9] Added warning flags. --- CMakeLists.txt | 12 ++++++++++++ test/CMakeLists.txt | 12 +++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cf85cc43..79f03f22 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -145,6 +145,18 @@ IF (MSGPACK_BUILD_TESTS) ADD_SUBDIRECTORY (test) ENDIF () +IF (CMAKE_COMPILER_IS_GNUCC) + SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) + SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) +ENDIF () +IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () +ENDIF () + INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) INSTALL (DIRECTORY src/msgpack DESTINATION include) INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a380e24e..71ad7669 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -42,4 +42,14 @@ FOREACH (source_file ${check_PROGRAMS}) ${CMAKE_THREAD_LIBS_INIT} ) ADD_TEST (${source_file_we} ${source_file_we}) -ENDFOREACH () \ No newline at end of file + IF (CMAKE_COMPILER_IS_GNUCC) + SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) + ENDIF () + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () + ENDIF () +ENDFOREACH () From ab8e7ea822adab3575a1f28453fcdc6ec6899ff1 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 21 Jun 2014 11:27:33 +0900 Subject: [PATCH 8/9] Added -DPIC option on shared library. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 79f03f22..46200341 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -146,7 +146,7 @@ IF (MSGPACK_BUILD_TESTS) ENDIF () IF (CMAKE_COMPILER_IS_GNUCC) - SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) + SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -DPIC") SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") From 3104f7e4517a1008c8de99e6af9d0e45a2429846 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 21 Jun 2014 19:00:59 +0900 Subject: [PATCH 9/9] Added -O3 -g option for gcc and clang. Improved compiler checking method. --- CMakeLists.txt | 6 +++--- test/CMakeLists.txt | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 46200341..9946708f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -145,9 +145,9 @@ IF (MSGPACK_BUILD_TESTS) ADD_SUBDIRECTORY (test) ENDIF () -IF (CMAKE_COMPILER_IS_GNUCC) - SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -DPIC") - SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) +IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC") + SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" ) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 71ad7669..252fd164 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -42,8 +42,8 @@ FOREACH (source_file ${check_PROGRAMS}) ${CMAKE_THREAD_LIBS_INIT} ) ADD_TEST (${source_file_we} ${source_file_we}) - IF (CMAKE_COMPILER_IS_GNUCC) - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS -Wall ) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")