initial import
authorHoward Hinnant <hhinnant@apple.com>
Thu, 5 May 2011 15:27:28 +0000 (15:27 +0000)
committerHoward Hinnant <hhinnant@apple.com>
Thu, 5 May 2011 15:27:28 +0000 (15:27 +0000)
llvm-svn: 130921

libcxxabi/CREDITS.TXT [new file with mode: 0644]
libcxxabi/LICENSE.TXT [new file with mode: 0644]
libcxxabi/include/cxa_demangle.h [new file with mode: 0644]
libcxxabi/include/cxxabi.h [new file with mode: 0644]
libcxxabi/src/cxa_demangle.cpp [new file with mode: 0644]
libcxxabi/test/test_demangle.cpp [new file with mode: 0644]
libcxxabi/www/content.css [new file with mode: 0644]
libcxxabi/www/index.html [new file with mode: 0644]
libcxxabi/www/menu.css [new file with mode: 0644]

diff --git a/libcxxabi/CREDITS.TXT b/libcxxabi/CREDITS.TXT
new file mode 100644 (file)
index 0000000..dc2a4ff
--- /dev/null
@@ -0,0 +1,13 @@
+This file is a partial list of people who have contributed to the LLVM/libc++abi
+project.  If you have contributed a patch or made some other contribution to
+LLVM/libc++abi, please submit a patch to this file to add yourself, and it will be
+done!
+
+The list is sorted by surname and formatted to allow easy grepping and
+beautification by scripts.  The fields are: name (N), email (E), web-address
+(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
+(S).
+
+N: Howard Hinnant
+E: hhinnant@apple.com
+D: Architect and primary author of libc++abi
diff --git a/libcxxabi/LICENSE.TXT b/libcxxabi/LICENSE.TXT
new file mode 100644 (file)
index 0000000..40ce7c7
--- /dev/null
@@ -0,0 +1,76 @@
+==============================================================================
+libc++abi License
+==============================================================================
+
+The libc++abi library is dual licensed under both the University of Illinois
+"BSD-Like" license and the MIT license.  As a user of this code you may choose
+to use it under either license.  As a contributor, you agree to allow your code
+to be used under both.
+
+Full text of the relevant licenses is included below.
+
+==============================================================================
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
+
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/libcxxabi/include/cxa_demangle.h b/libcxxabi/include/cxa_demangle.h
new file mode 100644 (file)
index 0000000..863e0bc
--- /dev/null
@@ -0,0 +1,160 @@
+//===-------------------------- cxa_demangle.h ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CXA_DEMANGLE_H
+#define _CXA_DEMANGLE_H
+
+#include <cxxabi.h>
+
+namespace __cxxabiv1
+{
+
+namespace __libcxxabi
+{
+
+struct __demangle_tree;
+class __node;
+
+char*
+__demangle(__demangle_tree, char*, size_t*, int*);
+
+struct __demangle_tree_rv
+{
+    __demangle_tree* ptr_;
+
+    explicit __demangle_tree_rv(__demangle_tree* ptr)
+        : ptr_(ptr) {}
+};
+
+class __demangle_tree
+{
+    const char* __mangled_name_begin_;
+    const char* __mangled_name_end_;
+    int         __status_;
+    __node*     __root_;
+    __node*     __node_begin_;
+    __node*     __node_end_;
+    __node*     __node_cap_;
+    __node**    __sub_begin_;
+    __node**    __sub_end_;
+    __node**    __sub_cap_;
+    __node**    __t_begin_;
+    __node**    __t_end_;
+    __node**    __t_cap_;
+    bool        __tag_templates_;
+    bool        __fix_forward_references_;
+    bool        __owns_buf_;
+
+    __demangle_tree& operator=(const __demangle_tree&);
+public:
+    __demangle_tree(const char*, char*, size_t);
+    ~__demangle_tree();
+
+    __demangle_tree(__demangle_tree&);
+    __demangle_tree(__demangle_tree_rv);
+    operator __demangle_tree_rv() {return __demangle_tree_rv(this);}
+
+    int __status() const;
+    size_t size() const;
+    char* __get_demangled_name(char*) const;
+
+    void __parse();
+
+private:
+    const char* __parse_encoding(const char*, const char*);
+    const char* __parse_type(const char*, const char*,
+                             bool = true, bool = false);
+    const char* __parse_special_name(const char*, const char*);
+    const char* __parse_name(const char*, const char*);
+    const char* __parse_bare_function_type(const char*, const char*);
+    const char* __parse_call_offset(const char*, const char*);
+    const char* __parse_number(const char*, const char*);
+    const char* __parse_cv_qualifiers(const char* first, const char* last,
+                                      unsigned& cv, bool = false);
+    const char* __parse_nested_name(const char*, const char*);
+    const char* __parse_discriminator(const char*, const char*);
+    const char* __parse_local_name(const char*, const char*);
+    const char* __parse_unscoped_template_name(const char*, const char*);
+    const char* __parse_unscoped_name(const char*, const char*);
+    const char* __parse_operator_name(const char*, const char*, int* = 0);
+    const char* __parse_unqualified_name(const char*, const char*);
+    const char* __parse_source_name(const char*, const char*);
+    const char* __parse_ctor_dtor_name(const char*, const char*);
+    const char* __parse_unnamed_type_name(const char*, const char*);
+    const char* __parse_template_args(const char*, const char*);
+    const char* __parse_template_arg(const char*, const char*);
+    const char* __parse_expression(const char*, const char*);
+    const char* __parse_expr_primary(const char*, const char*);
+    const char* __parse_substitution(const char*, const char*);
+    const char* __parse_builtin_type(const char*, const char*);
+    const char* __parse_function_type(const char*, const char*);
+    const char* __parse_class_enum_type(const char*, const char*);
+    const char* __parse_array_type(const char*, const char*);
+    const char* __parse_pointer_to_member_type(const char*, const char*);
+    const char* __parse_decltype(const char*, const char*);
+    const char* __parse_template_param(const char*, const char*);
+    const char* __parse_unresolved_name(const char*, const char*);
+    const char* __parse_unresolved_type(const char*, const char*);
+    const char* __parse_base_unresolved_name(const char*, const char*);
+    const char* __parse_simple_id(const char*, const char*);
+    const char* __parse_destructor_name(const char*, const char*);
+    const char* __parse_function_param(const char*, const char*);
+    const char* __parse_const_cast_expr(const char*, const char*);
+    const char* __parse_alignof_expr(const char*, const char*);
+    const char* __parse_call_expr(const char*, const char*);
+    const char* __parse_conversion_expr(const char*, const char*);
+    const char* __parse_delete_array_expr(const char*, const char*);
+    const char* __parse_delete_expr(const char*, const char*);
+    const char* __parse_dynamic_cast_expr(const char*, const char*);
+    const char* __parse_dot_star_expr(const char*, const char*);
+    const char* __parse_dot_expr(const char*, const char*);
+    const char* __parse_decrement_expr(const char*, const char*);
+    const char* __parse_new_expr(const char*, const char*);
+    const char* __parse_increment_expr(const char*, const char*);
+    const char* __parse_arrow_expr(const char*, const char*);
+    const char* __parse_reinterpret_cast_expr(const char*, const char*);
+    const char* __parse_static_cast_expr(const char*, const char*);
+    const char* __parse_sizeof_type_expr(const char*, const char*);
+    const char* __parse_sizeof_param_pack_expr(const char*, const char*);
+    const char* __parse_typeid_expr(const char*, const char*);
+    const char* __parse_throw_expr(const char*, const char*);
+    const char* __parse_pack_expansion(const char*, const char*);
+    const char* __parse_sizeof_function_param_pack_expr(const char*, const char*);
+    const char* __parse_dot_suffix(const char*, const char*);
+    const char* __parse_hex_number(const char*, const char*, unsigned long long&);
+
+    template <class _Tp> bool __make();
+    template <class _Tp, class _A0> bool __make(_A0 __a0);
+    template <class _Tp, class _A0, class _A1> bool __make(_A0 __a0, _A1 __a1);
+    template <class _Tp, class _A0, class _A1, class _A2>
+        bool __make(_A0 __a0, _A1 __a1, _A2 __a2);
+    template <class _Tp, class _A0, class _A1, class _A2, class _A3>
+        bool __make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3);
+    template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4>
+        bool __make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4);
+    template <class _Tp, class _A0, class _A1, class _A2, class _A3, class _A4,
+                         class _A5>
+        bool __make(_A0 __a0, _A1 __a1, _A2 __a2, _A3 __a3, _A4 __a4, _A5 __a5);
+
+    friend
+    char*
+    __demangle(__demangle_tree, char*, size_t*, int*);
+
+};
+
+__demangle_tree
+__demangle(const char*);
+
+__demangle_tree
+__demangle(const char*, char*, size_t);
+
+}  // __libcxxabi
+}  // __cxxabiv1
+
+#endif  // _CXA_DEMANGLE_H
diff --git a/libcxxabi/include/cxxabi.h b/libcxxabi/include/cxxabi.h
new file mode 100644 (file)
index 0000000..d163dd4
--- /dev/null
@@ -0,0 +1,177 @@
+//===--------------------------- cxxabi.h ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CXXABI_H
+#define __CXXABI_H 
+
+/*
+ * This header provides the interface to the C++ ABI as defined at:
+ *       http://www.codesourcery.com/cxx-abi/
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace std {
+       class type_info; // forward declaration
+}
+
+
+// runtime routines use C calling conventions, but are in __cxxabiv1 namespace
+namespace __cxxabiv1 {  
+  extern "C"  {
+
+// 2.4.2 Allocating the Exception Object
+extern void * __cxa_allocate_exception(size_t thrown_size) throw();
+extern void __cxa_free_exception(void * thrown_exception) throw();
+
+// 2.4.3 Throwing the Exception Object
+extern void __cxa_throw(void * thrown_exception, struct std::type_info * tinfo, 
+                        void (*dest)(void *));
+
+// 2.5.3 Exception Handlers
+extern void * __cxa_get_exception_ptr(void * exceptionObject) throw();
+extern void * __cxa_begin_catch(void * exceptionObject) throw();
+extern void __cxa_end_catch();
+extern std::type_info * __cxa_current_exception_type();
+
+// 2.5.4 Rethrowing Exceptions
+extern void __cxa_rethrow();
+
+
+
+// 2.6 Auxiliary Runtime APIs
+extern void __cxa_bad_cast();
+extern void __cxa_bad_typeid();
+
+
+
+// 3.2.6 Pure Virtual Function API
+extern void __cxa_pure_virtual(void);
+
+// 3.3.2 One-time Construction API
+extern int  __cxa_guard_acquire(uint64_t*);
+extern void __cxa_guard_release(uint64_t*);
+extern void __cxa_guard_abort(uint64_t*);
+
+// 3.3.3 Array Construction and Destruction API
+extern void* __cxa_vec_new(size_t element_count, 
+                                                  size_t element_size, 
+                           size_t padding_size, 
+                                                  void (*constructor)(void*),
+                                                  void (*destructor)(void*) );
+
+extern void* __cxa_vec_new2(size_t element_count,
+                                                   size_t element_size, 
+                            size_t padding_size,
+                                                   void  (*constructor)(void*),
+                                                   void  (*destructor)(void*),
+                            void* (*alloc)(size_t), 
+                            void  (*dealloc)(void*) );
+
+extern void* __cxa_vec_new3(size_t element_count,
+                                                   size_t element_size, 
+                            size_t padding_size,
+                                                   void  (*constructor)(void*),
+                                                   void  (*destructor)(void*),
+                            void* (*alloc)(size_t), 
+                            void  (*dealloc)(void*, size_t) );
+  
+extern void __cxa_vec_ctor(void*  array_address, 
+                           size_t element_count,
+                           size_t element_size, 
+                                                  void (*constructor)(void*),
+                                                  void (*destructor)(void*) );
+
+
+extern void __cxa_vec_dtor(void*  array_address, 
+                           size_t element_count,
+                                                  size_t element_size, 
+                                                  void (*destructor)(void*) );
+
+
+extern void __cxa_vec_cleanup(void* array_address, 
+                             size_t element_count,
+                             size_t element_size, 
+                                                    void  (*destructor)(void*) );
+
+
+extern void __cxa_vec_delete(void*  array_address, 
+                             size_t element_size, 
+                             size_t padding_size, 
+                                                    void  (*destructor)(void*) );
+
+
+extern void __cxa_vec_delete2(void* array_address, 
+                             size_t element_size, 
+                             size_t padding_size, 
+                                                    void  (*destructor)(void*),
+                             void  (*dealloc)(void*) );
+  
+
+extern void __cxa_vec_delete3(void* __array_address, 
+                             size_t element_size, 
+                             size_t padding_size, 
+                                                    void  (*destructor)(void*),
+                                                        void  (*dealloc) (void*, size_t));
+
+
+extern void __cxa_vec_cctor(void*  dest_array, 
+                                                       void*  src_array, 
+                                                       size_t element_count, 
+                                                       size_t element_size, 
+                                                       void  (*constructor) (void*, void*), 
+                                                       void  (*destructor)(void*) );
+
+
+// 3.3.5.3 Runtime API
+extern int __cxa_atexit(void (*f)(void*), void* p, void* d);
+extern int __cxa_finalize(void*);
+
+
+// 3.4 Demangler API
+extern char* __cxa_demangle(const char* mangled_name, 
+                                                       char*       output_buffer,
+                                                       size_t*     length, 
+                                                       int*        status);
+
+  } // extern "C"
+} // namespace __cxxabiv1
+namespace abi = __cxxabiv1;
+
+
+
+
+
+// Below are Apple extensions to support implementing C++ ABI in a seperate dylib
+namespace __cxxabiapple {  
+  extern "C"  {
+
+// Apple additions to support multiple STL stacks that share common 
+// terminate, unexpected, and new handlers
+extern void (*__cxa_terminate_handler)();
+extern void (*__cxa_unexpected_handler)();
+extern void (*__cxa_new_handler)();
+
+// Apple additions to support C++ 0x exception_ptr class
+// These are primitives to wrap a smart pointer around an exception object
+extern void * __cxa_current_primary_exception() throw();
+extern void __cxa_rethrow_primary_exception(void* primary_exception);
+extern void __cxa_increment_exception_refcount(void* primary_exception) throw();
+extern void __cxa_decrement_exception_refcount(void* primary_exception) throw();
+
+// Apple addition to support std::uncaught_exception()
+extern bool __cxa_uncaught_exception() throw();
+
+  } // extern "C"
+} // namespace __cxxabiv1
+
+
+
+#endif // __CXXABI_H 
diff --git a/libcxxabi/src/cxa_demangle.cpp b/libcxxabi/src/cxa_demangle.cpp
new file mode 100644 (file)
index 0000000..f455329
--- /dev/null
@@ -0,0 +1,14933 @@
+//===-------------------------- cxa_demangle.cpp --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "cxa_demangle.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <new>
+#include <algorithm>
+#include <assert.h>
+
+
+#ifdef DEBUGGING
+
+#include <string>
+#include <typeinfo>
+
+#endif
+
+namespace __cxxabiv1
+{
+
+namespace __libcxxabi
+{
+
+#pragma GCC visibility push(hidden)
+
+class __node
+{
+    __node(const __node&);
+    __node& operator=(const __node&);
+public:
+    const char* __name_;
+    size_t __size_;
+    __node* __left_;
+    __node* __right_;
+    long double __value_;
+    long __cached_size_;
+public:
+    __node()
+        : __name_(0), __size_(0), __left_(0), __right_(0), __cached_size_(-1)
+        {}
+    virtual ~__node() {};
+
+    void reset_cached_size()
+    {
+        __cached_size_ = -1;
+        if (__left_)
+            __left_->reset_cached_size();
+        if (__right_)
+            __right_->reset_cached_size();
+    }
+
+    virtual size_t first_size() const  {return 0;}
+    virtual size_t second_size() const {return 0;}
+    virtual size_t size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = first_size() + second_size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const {return buf;}
+    virtual char* second_demangled_name(char* buf) const {return buf;}
+    virtual char* get_demangled_name(char* buf) const
+    {
+        return second_demangled_name(first_demangled_name(buf));
+    }
+    virtual size_t base_size() const {return size();}
+    virtual char* get_base_name(char* buf) const
+    {
+        return get_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_base_name(char* f, char* l) const
+    {
+        return print(f, l);
+    }
+    virtual bool ends_with_template() const
+    {
+        return false;
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return false;
+    }
+    virtual __node* base_name() const
+    {
+        return const_cast<__node*>(this);
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return false;
+    }
+    virtual bool is_function() const
+    {
+        return false;
+    }
+    virtual bool is_cv_qualifer() const
+    {
+        return false;
+    }
+    virtual bool is_array() const
+    {
+        return false;
+    }
+
+    virtual bool fix_forward_references(__node**, __node**)
+    {
+        return true;
+    }
+    virtual __node* extract_cv(__node*&) const
+    {
+        return 0;
+    }
+    virtual size_t list_len() const
+    {
+        return 0;
+    }
+    virtual bool is_sub() const
+    {
+        return false;
+    }
+
+    virtual ptrdiff_t print(char* f, char* l) const
+    {
+        const ptrdiff_t sz1 = print_first(f, l);
+        return sz1 + print_second(f+std::min(sz1, l-f), l);
+    }
+    virtual ptrdiff_t print_first(char*, char*) const
+    {
+        return 0;
+    }
+    virtual ptrdiff_t print_second(char*, char*) const
+    {
+        return 0;
+    }
+};
+
+#ifdef DEBUGGING
+
+void display(__node* x, int indent = 0)
+{
+    if (x)
+    {
+        for (int i = 0; i < 2*indent; ++i)
+            printf(" ");
+        std::string buf(x->size(), '\0');
+        x->print(&buf.front(), &buf.back()+1);
+        printf("%s %s, %p\n", typeid(*x).name(), buf.c_str(), x);
+        display(x->__left_, indent+1);
+        display(x->__right_, indent+1);
+    }
+}
+
+#endif
+
+class __vtable
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("vtable for ") - 1;
+public:
+    __vtable(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "vtable for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'v';
+            *f++ = 't';
+            *f++ = 'a';
+            *f++ = 'b';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = ' ';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __VTT
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("VTT for ") - 1;
+public:
+    __VTT(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "VTT for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'V';
+            *f++ = 'T';
+            *f++ = 'T';
+            *f++ = ' ';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __typeinfo
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("typeinfo for ") - 1;
+public:
+    __typeinfo(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "typeinfo for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 't';
+            *f++ = 'y';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = ' ';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __typeinfo_name
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("typeinfo name for ") - 1;
+public:
+    __typeinfo_name(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "typeinfo name for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 't';
+            *f++ = 'y';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = ' ';
+            *f++ = 'n';
+            *f++ = 'a';
+            *f++ = 'm';
+            *f++ = 'e';
+            *f++ = ' ';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __covariant_return_thunk
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("covariant return thunk to ") - 1;
+public:
+    __covariant_return_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "covariant return thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'c';
+            *f++ = 'o';
+            *f++ = 'v';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = 'i';
+            *f++ = 'a';
+            *f++ = 'n';
+            *f++ = 't';
+            *f++ = ' ';
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 't';
+            *f++ = 'u';
+            *f++ = 'r';
+            *f++ = 'n';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'h';
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 'k';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'o';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __virtual_thunk
+    : public __node
+{
+    static const size_t n = sizeof("virtual thunk to ") - 1;
+public:
+    __virtual_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "virtual thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'v';
+            *f++ = 'i';
+            *f++ = 'r';
+            *f++ = 't';
+            *f++ = 'u';
+            *f++ = 'a';
+            *f++ = 'l';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'h';
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 'k';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'o';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __non_virtual_thunk
+    : public __node
+{
+    static const size_t n = sizeof("non-virtual thunk to ") - 1;
+public:
+    __non_virtual_thunk(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "non-virtual thunk to ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'n';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f++ = '-';
+            *f++ = 'v';
+            *f++ = 'i';
+            *f++ = 'r';
+            *f++ = 't';
+            *f++ = 'u';
+            *f++ = 'a';
+            *f++ = 'l';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'h';
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 'k';
+            *f++ = ' ';
+            *f++ = 't';
+            *f++ = 'o';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __right_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __guard_variable
+    : public __node
+{
+    static const size_t n = sizeof("guard variable for ") - 1;
+public:
+    __guard_variable(__node* type)
+    {
+        __right_ = type;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "guard variable for ", n);
+        return __right_->get_demangled_name(buf+n);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz = __right_->print(f+n, l) + n;
+        if (r >= sz)
+        {
+            *f++ = 'g';
+            *f++ = 'u';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'v';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = 'i';
+            *f++ = 'a';
+            *f++ = 'b';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = ' ';
+            *f++ = 'f';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return sz;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __source_name
+    : public __node
+{
+public:
+    __source_name(const char* __name, unsigned __size)
+    {
+        __name_ = __name;
+        __size_ = __size;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
+                const_cast<long&>(__cached_size_) = 21;
+            else
+                const_cast<long&>(__cached_size_) = __size_;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
+            return strncpy(buf, "(anonymous namespace)", 21) + 21;
+        return strncpy(buf, __name_, __size_) + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
+        {
+            const ptrdiff_t n = sizeof("(anonymous namespace)") - 1;
+            if (r >= n)
+            {
+                *f++ = '(';
+                *f++ = 'a';
+                *f++ = 'n';
+                *f++ = 'o';
+                *f++ = 'n';
+                *f++ = 'y';
+                *f++ = 'm';
+                *f++ = 'o';
+                *f++ = 'u';
+                *f++ = 's';
+                *f++ = ' ';
+                *f++ = 'n';
+                *f++ = 'a';
+                *f++ = 'm';
+                *f++ = 'e';
+                *f++ = 's';
+                *f++ = 'p';
+                *f++ = 'a';
+                *f++ = 'c';
+                *f++ = 'e';
+                *f   = ')';
+            }
+            return n;
+        }
+        if (r >= __size_)
+            strncpy(f, __name_, __size_);
+        return __size_;
+    }
+};
+
+class __operator_new
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator new") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator new", sizeof("operator new") - 1) +
+                                            sizeof("operator new") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator new") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f   = 'w';
+        }
+        return n;
+    }
+};
+
+class __operator_new_array
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator new[]") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator new[]", sizeof("operator new[]") - 1) +
+                                              sizeof("operator new[]") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator new[]") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'w';
+            *f++ = '[';
+            *f   = ']';
+        }
+        return n;
+    }
+};
+
+class __operator_delete
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator delete") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator delete", sizeof("operator delete") - 1) +
+                                               sizeof("operator delete") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator delete") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'd';
+            *f++ = 'e';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = 't';
+            *f   = 'e';
+        }
+        return n;
+    }
+};
+
+class __operator_delete_array
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator delete[]") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return strncpy(buf, "operator delete[]", sizeof("operator delete[]") - 1) +
+                                                 sizeof("operator delete[]") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator delete[]") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'd';
+            *f++ = 'e';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = 't';
+            *f++ = 'e';
+            *f++ = '[';
+            *f   = ']';
+        }
+        return n;
+    }
+};
+
+class __operator_logical_and
+    : public __node
+{
+public:
+
+    __operator_logical_and() {}
+    __operator_logical_and(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") && (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&&", sizeof("operator&&") - 1);
+            buf += sizeof("operator&&") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '&';
+                *f++ = '&';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator&&") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '&';
+            *f   = '&';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_addressof
+    : public __node
+{
+public:
+
+    __operator_addressof() {}
+    explicit __operator_addressof(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '&';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&", sizeof("operator&") - 1);
+            buf += sizeof("operator&") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '&';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator&") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '&';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_bit_and
+    : public __node
+{
+public:
+
+    __operator_bit_and() {}
+    __operator_bit_and(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") & (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&", sizeof("operator&") - 1);
+            buf += sizeof("operator&") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '&';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator&") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '&';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_and_equal
+    : public __node
+{
+public:
+
+    __operator_and_equal() {}
+    __operator_and_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator&=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") &= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator&=", sizeof("operator&=") - 1);
+            buf += sizeof("operator&=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '&';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator&=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '&';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_equal
+    : public __node
+{
+public:
+
+    __operator_equal() {}
+    __operator_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") = (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator=", sizeof("operator=") - 1);
+            buf += sizeof("operator=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_alignof_type
+    : public __node
+{
+public:
+
+    __operator_alignof_type() {}
+    __operator_alignof_type(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "alignof (", 9);
+            buf += 9;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator alignof", sizeof("operator alignof") - 1);
+            buf += sizeof("operator alignof") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__right_)
+        {
+            const ptrdiff_t n1 = sizeof("alignof ()") - 1;
+            if (r < n1)
+                return n1 + __right_->print(l, l);
+            ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = 'a';
+                *f++ = 'l';
+                *f++ = 'i';
+                *f++ = 'g';
+                *f++ = 'n';
+                *f++ = 'o';
+                *f++ = 'f';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator alignof") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'a';
+            *f++ = 'l';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'o';
+            *f   = 'f';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_alignof_expression
+    : public __node
+{
+public:
+
+    __operator_alignof_expression() {}
+    __operator_alignof_expression(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "alignof (", 9);
+            buf += 9;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator alignof", sizeof("operator alignof") - 1);
+            buf += sizeof("operator alignof") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__right_)
+        {
+            const ptrdiff_t n1 = sizeof("alignof ()") - 1;
+            if (r < n1)
+                return n1 + __right_->print(l, l);
+            ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = 'a';
+                *f++ = 'l';
+                *f++ = 'i';
+                *f++ = 'g';
+                *f++ = 'n';
+                *f++ = 'o';
+                *f++ = 'f';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator alignof") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 'a';
+            *f++ = 'l';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'o';
+            *f   = 'f';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_paren
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator()") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "operator()", sizeof("operator()") - 1);
+        return buf + sizeof("operator()") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator()") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '(';
+            *f   = ')';
+        }
+        return n;
+    }
+};
+
+class __operator_comma
+    : public __node
+{
+public:
+
+    __operator_comma() {}
+    __operator_comma(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator,") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") , (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator,", sizeof("operator,") - 1);
+            buf += sizeof("operator,") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = ',';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator,") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ',';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_tilda
+    : public __node
+{
+public:
+
+    __operator_tilda() {}
+    explicit __operator_tilda(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator~") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '~';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator~", sizeof("operator~") - 1);
+            buf += sizeof("operator~") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '~';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator~") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '~';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_cast
+    : public __node
+{
+    static const size_t n = sizeof("operator ") - 1;
+public:
+
+    explicit __operator_cast(__node* type)
+    {
+        __right_ = type;
+    }
+    __operator_cast(__node* type, __node* arg)
+    {
+        __size_ = 1;
+        __right_ = type;
+        __left_ = arg;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t off;
+            if (__size_)
+            {
+                off = 4;
+                off += __right_->size();
+                if (__left_)
+                    off += __left_->size();
+            }
+            else
+                off = n +  __right_->size();;
+            const_cast<long&>(__cached_size_) = off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            *buf++ = '(';
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+            *buf++ = '(';
+            if (__left_)
+                buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator ", n);
+            buf = __right_->get_demangled_name(buf+n);
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__size_)
+        {
+            const ptrdiff_t n1 = 4;
+            if (r < n1)
+                return n1 + __right_->print(l, l) +
+                            (__left_ ? __left_->print(l, l) : 0);
+            ptrdiff_t sz1 = __right_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + (__left_ ? __left_->print(l, l) : 0);
+            ptrdiff_t sz2 = __left_ ? __left_->print(f+3+sz1, l) : 0;
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator ") - 1;
+        if (r < n2)
+            return n2 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+n2, l);
+        if (r >= n2 + sz1)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = ' ';
+        }
+        return n2 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return true;
+    }
+};
+
+class __cast_literal
+    : public __node
+{
+public:
+
+    __cast_literal(__node* type, const char* f, const char* l)
+    {
+        __left_ = type;
+        __name_ = f;
+        __size_ = l - f;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = 2 + __left_->size() + __size_;
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        *buf++ = '(';
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = ')';
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = 2;
+        if (r < __size_ + n)
+            return __size_ + n + __left_->print(l, l);
+        ptrdiff_t sz = __left_->print(f+1, l);
+        if (r >= __size_ + n + sz)
+        {
+            *f   = '(';
+            f += 1 + sz;
+            *f++ = ')';
+            strncpy(f, __name_, __size_);
+        }
+        return __size_ + n + sz;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __operator_dereference
+    : public __node
+{
+public:
+
+    __operator_dereference() {}
+    explicit __operator_dereference(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator*") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '*';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator*", sizeof("operator*") - 1);
+            buf += sizeof("operator*") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '*';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator*") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '*';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_divide
+    : public __node
+{
+public:
+
+    __operator_divide() {}
+    __operator_divide(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator/") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") / (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator/", sizeof("operator/") - 1);
+            buf += sizeof("operator/") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '/';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator/") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '/';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_divide_equal
+    : public __node
+{
+public:
+
+    __operator_divide_equal() {}
+    __operator_divide_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator/=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") /= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator/=", sizeof("operator/=") - 1);
+            buf += sizeof("operator/=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '/';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator/=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '/';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_xor
+    : public __node
+{
+public:
+
+    __operator_xor() {}
+    __operator_xor(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator^") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") ^ (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator^", sizeof("operator^") - 1);
+            buf += sizeof("operator^") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '^';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator^") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '^';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_xor_equal
+    : public __node
+{
+public:
+
+    __operator_xor_equal() {}
+    __operator_xor_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator^=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';  // strncpy(buf, "(", 1);
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") ^= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator^=", sizeof("operator^=") - 1);
+            buf += sizeof("operator^=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '^';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator^=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '^';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_equality
+    : public __node
+{
+public:
+
+    __operator_equality() {}
+    __operator_equality(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator==") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") == (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator==", sizeof("operator==") - 1);
+            buf += sizeof("operator==") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '=';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator==") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '=';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_greater_equal
+    : public __node
+{
+public:
+
+    __operator_greater_equal() {}
+    __operator_greater_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator>=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") >= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator>=", sizeof("operator>=") - 1);
+            buf += sizeof("operator>=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '>';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator>=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '>';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_greater
+    : public __node
+{
+public:
+
+    __operator_greater() {}
+    __operator_greater(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator>") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") > (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator>", sizeof("operator>") - 1);
+            buf += sizeof("operator>") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 9;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-2)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f++ = '(';
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '>';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f++ = ')';
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator>") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '>';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_brackets
+    : public __node
+{
+public:
+
+    virtual size_t first_size() const {return sizeof("operator[]") - 1;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "operator[]", sizeof("operator[]") - 1);
+        return buf + sizeof("operator[]") - 1;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("operator[]") - 1;
+        if (r >= n)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '[';
+            *f   = ']';
+        }
+        return n;
+    }
+};
+
+class __operator_less_equal
+    : public __node
+{
+public:
+
+    __operator_less_equal() {}
+    __operator_less_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator<=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") <= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator<=", sizeof("operator<=") - 1);
+            buf += sizeof("operator<=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '<';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator<=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '<';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_less
+    : public __node
+{
+public:
+
+    __operator_less() {}
+    __operator_less(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator<") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") < (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator<", sizeof("operator<") - 1);
+            buf += sizeof("operator<") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '<';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator<") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '<';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_left_shift
+    : public __node
+{
+public:
+
+    __operator_left_shift() {}
+    __operator_left_shift(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator<<") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") << (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator<<", sizeof("operator<<") - 1);
+            buf += sizeof("operator<<") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '<';
+                *f++ = '<';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator<<") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '<';
+            *f   = '<';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_left_shift_equal
+    : public __node
+{
+public:
+
+    __operator_left_shift_equal() {}
+    __operator_left_shift_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator<<=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") <<= (", 7);
+            buf += 7;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator<<=", sizeof("operator<<=") - 1);
+            buf += sizeof("operator<<=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 9;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '<';
+                *f++ = '<';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator<<=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '<';
+            *f++ = '<';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_minus
+    : public __node
+{
+public:
+
+    __operator_minus() {}
+    __operator_minus(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator-") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") - (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator-", sizeof("operator-") - 1);
+            buf += sizeof("operator-") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '-';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator-") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '-';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_minus_equal
+    : public __node
+{
+public:
+
+    __operator_minus_equal() {}
+    __operator_minus_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator-=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") -= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator-=", sizeof("operator-=") - 1);
+            buf += sizeof("operator-=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '-';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator-=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '-';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_times
+    : public __node
+{
+public:
+
+    __operator_times() {}
+    __operator_times(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator*") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") * (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator*", sizeof("operator*") - 1);
+            buf += sizeof("operator*") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '*';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator*") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '*';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_times_equal
+    : public __node
+{
+public:
+
+    __operator_times_equal() {}
+    __operator_times_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator*=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") *= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator*=", sizeof("operator*=") - 1);
+            buf += sizeof("operator*=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '*';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator*=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '*';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_decrement
+    : public __node
+{
+public:
+
+    __operator_decrement() {}
+    explicit __operator_decrement(bool prefix, __node* op)
+    {
+        __size_ = prefix;
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 4+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator--") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            if (__size_)
+            {
+                *buf++ = '-';
+                *buf++ = '-';
+                *buf++ = '(';
+            }
+            else
+                *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            if (__size_)
+                *buf++ = ')';
+            else
+            {
+                *buf++ = ')';
+                *buf++ = '-';
+                *buf++ = '-';
+            }
+        }
+        else
+        {
+            strncpy(buf, "operator--", sizeof("operator--") - 1);
+            buf += sizeof("operator--") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 4;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f + (__size_ ? 3 : 1), l);
+            if (r >= n1 + sz1)
+            {
+                if (__size_)
+                {
+                    *f++ = '-';
+                    *f++ = '-';
+                    *f   = '(';
+                    f += 1+sz1;
+                    *f   = ')';
+                }
+                else
+                {
+                    *f   = '(';
+                    f += 1+sz1;
+                    *f++ = ')';
+                    *f++ = '-';
+                    *f   = '-';
+                }
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator--") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '-';
+            *f   = '-';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_not_equal
+    : public __node
+{
+public:
+
+    __operator_not_equal() {}
+    __operator_not_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator!=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") != (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator!=", sizeof("operator!=") - 1);
+            buf += sizeof("operator!=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '!';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator!=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '!';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_negate
+    : public __node
+{
+public:
+
+    __operator_negate() {}
+    explicit __operator_negate(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator-") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '-';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator-", sizeof("operator-") - 1);
+            buf += sizeof("operator-") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '-';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator-") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '-';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_logical_not
+    : public __node
+{
+public:
+
+    __operator_logical_not() {}
+    explicit __operator_logical_not(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator!") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '!';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator!", sizeof("operator!") - 1);
+            buf += sizeof("operator!") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '!';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator!") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '!';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_logical_or
+    : public __node
+{
+public:
+
+    __operator_logical_or() {}
+    __operator_logical_or(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator||") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") || (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator||", sizeof("operator||") - 1);
+            buf += sizeof("operator||") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '|';
+                *f++ = '|';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator||") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '|';
+            *f   = '|';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_bit_or
+    : public __node
+{
+public:
+
+    __operator_bit_or() {}
+    __operator_bit_or(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator|") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") | (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator|", sizeof("operator|") - 1);
+            buf += sizeof("operator|") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '|';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator|") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '|';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_or_equal
+    : public __node
+{
+public:
+
+    __operator_or_equal() {}
+    __operator_or_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator|=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") |= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator|=", sizeof("operator|=") - 1);
+            buf += sizeof("operator|=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '|';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator|=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '|';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_pointer_to_member
+    : public __node
+{
+public:
+
+    __operator_pointer_to_member() {}
+    __operator_pointer_to_member(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator->*") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") ->* (", 7);
+            buf += 7;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator->*", sizeof("operator->*") - 1);
+            buf += sizeof("operator->*") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 9;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '-';
+                *f++ = '>';
+                *f++ = '*';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator->*") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '-';
+            *f++ = '>';
+            *f   = '*';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_plus
+    : public __node
+{
+public:
+
+    __operator_plus() {}
+    __operator_plus(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator+") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") + (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator+", sizeof("operator+") - 1);
+            buf += sizeof("operator+") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '+';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator+") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '+';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_plus_equal
+    : public __node
+{
+public:
+
+    __operator_plus_equal() {}
+    __operator_plus_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator+=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") += (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator+=", sizeof("operator+=") - 1);
+            buf += sizeof("operator+=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '+';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator+=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '+';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_increment
+    : public __node
+{
+public:
+
+    __operator_increment() {}
+    explicit __operator_increment(bool prefix, __node* op)
+    {
+        __size_ = prefix;
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 4+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator++") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            if (__size_)
+            {
+                *buf++ = '+';
+                *buf++ = '+';
+                *buf++ = '(';
+            }
+            else
+                *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            if (__size_)
+                *buf++ = ')';
+            else
+            {
+                *buf++ = ')';
+                *buf++ = '+';
+                *buf++ = '+';
+            }
+        }
+        else
+        {
+            strncpy(buf, "operator++", sizeof("operator++") - 1);
+            buf += sizeof("operator++") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 4;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f + (__size_ ? 3 : 1), l);
+            if (r >= n1 + sz1)
+            {
+                if (__size_)
+                {
+                    *f++ = '+';
+                    *f++ = '+';
+                    *f   = '(';
+                    f += 1+sz1;
+                    *f   = ')';
+                }
+                else
+                {
+                    *f   = '(';
+                    f += 1+sz1;
+                    *f++ = ')';
+                    *f++ = '+';
+                    *f   = '+';
+                }
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator++") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '+';
+            *f   = '+';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_unary_plus
+    : public __node
+{
+public:
+
+    __operator_unary_plus() {}
+    explicit __operator_unary_plus(__node* op)
+    {
+        __left_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = 3+__left_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator+") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '+';
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator+", sizeof("operator+") - 1);
+            buf += sizeof("operator+") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 3;
+            if (r < n1)
+                return n1 + __left_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+2, l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = '+';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator+") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '+';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_)
+            return __left_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_arrow
+    : public __node
+{
+public:
+
+    __operator_arrow() {}
+    __operator_arrow(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator->") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") -> (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator->", sizeof("operator->") - 1);
+            buf += sizeof("operator->") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '-';
+                *f++ = '>';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator->") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '-';
+            *f   = '>';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_conditional
+    : public __node
+{
+public:
+
+    __operator_conditional() {}
+    __operator_conditional(__node* op1, __node* op2, __node* op3)
+    {
+        __name_ = (const char*)op1;
+        __left_ = op2;
+        __right_ = op3;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+            {
+                __node* op1 = (__node*)__name_;
+                const_cast<long&>(__cached_size_) = op1->size() + __left_->size() + 12 + __right_->size();
+            }
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator?") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            __node* op1 = (__node*)__name_;
+            *buf++ = '(';
+            buf = op1->get_demangled_name(buf);
+            strncpy(buf, ") ? (", 5);
+            buf += 5;
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") : (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator?", sizeof("operator?") - 1);
+            buf += sizeof("operator?") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 12;
+            __node* op1 = (__node*)__name_;
+            if (r < n1)
+                return n1 + op1->print(l, l) + __left_->print(l, l) +
+                                               __right_->print(l, l);
+            ptrdiff_t sz1 = op1->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz2 = __left_->print(f+6+sz1, l);
+            if (r < n1 + sz1 + sz2)
+                return n1 + sz1 + sz2 + __right_->print(l, l);
+            ptrdiff_t sz3 = __right_->print(f+11+sz1+sz2, l);
+            if (r >= n1 + sz1 + sz2 + sz3)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '?';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = ':';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz3;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2 + sz3;
+        }
+        const ptrdiff_t n2 = sizeof("operator?") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '?';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__name_)
+            r = r && ((__node*)__name_)->fix_forward_references(t_begin, t_end);
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_mod
+    : public __node
+{
+public:
+
+    __operator_mod() {}
+    __operator_mod(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator%") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") % (", 5);
+            buf += 5;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator%", sizeof("operator%") - 1);
+            buf += sizeof("operator%") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 7;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '%';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator%") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = '%';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_mod_equal
+    : public __node
+{
+public:
+
+    __operator_mod_equal() {}
+    __operator_mod_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator%=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") %= (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator%=", sizeof("operator%=") - 1);
+            buf += sizeof("operator%=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '%';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator%=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '%';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_right_shift
+    : public __node
+{
+public:
+
+    __operator_right_shift() {}
+    __operator_right_shift(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator>>") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") >> (", 6);
+            buf += 6;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator>>", sizeof("operator>>") - 1);
+            buf += sizeof("operator>>") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 8;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '>';
+                *f++ = '>';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator>>") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '>';
+            *f   = '>';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_right_shift_equal
+    : public __node
+{
+public:
+
+    __operator_right_shift_equal() {}
+    __operator_right_shift_equal(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_)
+                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator>>=") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            strncpy(buf, ") >>= (", 7);
+            buf += 7;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator>>=", sizeof("operator>>=") - 1);
+            buf += sizeof("operator>>=") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__left_)
+        {
+            const ptrdiff_t n1 = 9;
+            if (r < n1)
+                return n1 + __left_->print(l, l) + __right_->print(l, l);
+            ptrdiff_t sz1 = __left_->print(f+1, l);
+            if (r < n1 + sz1)
+                return n1 + sz1 + __right_->print(l, l);
+            ptrdiff_t sz2 = __right_->print(f+(n1-1)+sz1, l);
+            if (r >= n1 + sz1 + sz2)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+                *f++ = ' ';
+                *f++ = '>';
+                *f++ = '>';
+                *f++ = '=';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz2;
+                *f   = ')';
+            }
+            return n1 + sz1 + sz2;
+        }
+        const ptrdiff_t n2 = sizeof("operator>>=") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = '>';
+            *f++ = '>';
+            *f   = '=';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __operator_sizeof_type
+    : public __node
+{
+public:
+
+    __operator_sizeof_type() {}
+    __operator_sizeof_type(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 9;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "sizeof (", 8);
+            buf += 8;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1);
+            buf += sizeof("operator sizeof") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__right_)
+        {
+            const ptrdiff_t n1 = sizeof("sizeof ()") - 1;
+            if (r < n1)
+                return n1 + __right_->print(l, l);
+            ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = 's';
+                *f++ = 'i';
+                *f++ = 'z';
+                *f++ = 'e';
+                *f++ = 'o';
+                *f++ = 'f';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator sizeof") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'z';
+            *f++ = 'e';
+            *f++ = 'o';
+            *f   = 'f';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __operator_sizeof_expression
+    : public __node
+{
+public:
+
+    __operator_sizeof_expression() {}
+    __operator_sizeof_expression(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__right_)
+                const_cast<long&>(__cached_size_) = __right_->size() + 9;
+            else
+                const_cast<long&>(__cached_size_) = sizeof("operator sizeof") - 1;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__right_)
+        {
+            strncpy(buf, "sizeof (", 8);
+            buf += 8;
+            buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        else
+        {
+            strncpy(buf, "operator sizeof", sizeof("operator sizeof") - 1);
+            buf += sizeof("operator sizeof") - 1;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__right_)
+        {
+            const ptrdiff_t n1 = sizeof("sizeof ()") - 1;
+            if (r < n1)
+                return n1 + __right_->print(l, l);
+            ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+            if (r >= n1 + sz1)
+            {
+                *f++ = 's';
+                *f++ = 'i';
+                *f++ = 'z';
+                *f++ = 'e';
+                *f++ = 'o';
+                *f++ = 'f';
+                *f++ = ' ';
+                *f   = '(';
+                f += 1 + sz1;
+                *f   = ')';
+            }
+            return n1 + sz1;
+        }
+        const ptrdiff_t n2 = sizeof("operator sizeof") - 1;
+        if (r >= n2)
+        {
+            *f++ = 'o';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = ' ';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'z';
+            *f++ = 'e';
+            *f++ = 'o';
+            *f   = 'f';
+        }
+        return n2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__right_)
+            return __right_->fix_forward_references(t_begin, t_end);
+        return true;
+    }
+};
+
+class __typeid
+    : public __node
+{
+public:
+
+    __typeid(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __right_->size() + 8;
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "typeid(", 7);
+        buf += 7;
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("typeid()") - 1;
+            if (r < n1)
+                return n1 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+        if (r >= n1 + sz1)
+        {
+            *f++ = 't';
+            *f++ = 'y';
+            *f++ = 'p';
+            *f++ = 'e';
+            *f++ = 'i';
+            *f++ = 'd';
+            *f   = '(';
+            f += 1 + sz1;
+            *f   = ')';
+        }
+        return n1 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __throw
+    : public __node
+{
+public:
+
+    __throw(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __right_->size() + 6;
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "throw ", 6);
+        return __right_->get_demangled_name(buf+6);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("throw ") - 1;
+        if (r < n1)
+            return n1 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+n1, l);
+        if (r >= n1 + sz1)
+        {
+            *f++ = 't';
+            *f++ = 'h';
+            *f++ = 'r';
+            *f++ = 'o';
+            *f++ = 'w';
+            *f   = ' ';
+        }
+        return n1 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __rethrow
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("throw") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "throw", n);
+        return buf+n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 't';
+            *f++ = 'h';
+            *f++ = 'r';
+            *f++ = 'o';
+            *f   = 'w';
+        }
+        return n;
+    }
+};
+
+class __operator_sizeof_param_pack
+    : public __node
+{
+public:
+
+    __operator_sizeof_param_pack(__node* op)
+    {
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __right_->size() + 11;
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "sizeof...(", 10);
+        buf += 10;
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("sizeof...()") - 1;
+        if (r < n1)
+            return n1 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+(n1-1), l);
+        if (r >= n1 + sz1)
+        {
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'z';
+            *f++ = 'e';
+            *f++ = 'o';
+            *f++ = 'f';
+            *f++ = '.';
+            *f++ = '.';
+            *f++ = '.';
+            *f   = '(';
+            f += 1+sz1;
+            *f   = ')';
+        }
+        return n1 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __const_cast
+    : public __node
+{
+public:
+
+    __const_cast(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 14 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "const_cast<", 11);
+        buf += 11;
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '>';
+        *buf++ = '(';
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("const_cast<>()") - 1;
+        if (r < n1)
+            return n1 + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f+(n1-3), l);
+        if (r < n1 + sz1)
+            return n1 + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l);
+        if (r >= n1 + sz1 + sz2)
+        {
+            *f++ = 'c';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = '_';
+            *f++ = 'c';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 't';
+            *f   = '<';
+            f += 1+sz1;
+            *f++ = '>';
+            *f   = '(';
+            f += 1+sz2;
+            *f   = ')';
+        }
+        return n1 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __dynamic_cast
+    : public __node
+{
+public:
+
+    __dynamic_cast(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 16 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "dynamic_cast<", 13);
+        buf += 13;
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '>';
+        *buf++ = '(';
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("dynamic_cast<>()") - 1;
+        if (r < n1)
+            return n1 + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f+(n1-3), l);
+        if (r < n1 + sz1)
+            return n1 + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l);
+        if (r >= n1 + sz1 + sz2)
+        {
+            *f++ = 'd';
+            *f++ = 'y';
+            *f++ = 'n';
+            *f++ = 'a';
+            *f++ = 'm';
+            *f++ = 'i';
+            *f++ = 'c';
+            *f++ = '_';
+            *f++ = 'c';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 't';
+            *f   = '<';
+            f += 1+sz1;
+            *f++ = '>';
+            *f   = '(';
+            f += 1+sz2;
+            *f   = ')';
+        }
+        return n1 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __reinterpret_cast
+    : public __node
+{
+public:
+
+    __reinterpret_cast(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 20 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "reinterpret_cast<", 17);
+        buf += 17;
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '>';
+        *buf++ = '(';
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("reinterpret_cast<>()") - 1;
+        if (r < n1)
+            return n1 + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f+(n1-3), l);
+        if (r < n1 + sz1)
+            return n1 + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l);
+        if (r >= n1 + sz1 + sz2)
+        {
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 't';
+            *f++ = 'e';
+            *f++ = 'r';
+            *f++ = 'p';
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 't';
+            *f++ = '_';
+            *f++ = 'c';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 't';
+            *f   = '<';
+            f += 1+sz1;
+            *f++ = '>';
+            *f   = '(';
+            f += 1+sz2;
+            *f   = ')';
+        }
+        return n1 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __static_cast
+    : public __node
+{
+public:
+
+    __static_cast(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 15 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "static_cast<", 12);
+        buf += 12;
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '>';
+        *buf++ = '(';
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("static_cast<>()") - 1;
+        if (r < n1)
+            return n1 + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f+(n1-3), l);
+        if (r < n1 + sz1)
+            return n1 + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+(n1-1), l);
+        if (r >= n1 + sz1 + sz2)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'i';
+            *f++ = 'c';
+            *f++ = '_';
+            *f++ = 'c';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 't';
+            *f   = '<';
+            f += 1+sz1;
+            *f++ = '>';
+            *f   = '(';
+            f += 1+sz2;
+            *f   = ')';
+        }
+        return n1 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __call_expr
+    : public __node
+{
+public:
+
+    __call_expr(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t off = __left_->size() + 2;
+            if (__right_)
+                off += __right_->size();
+            const_cast<long&>(__cached_size_) = off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '(';
+        if (__right_)
+            buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("()") - 1;
+        if (r < n1)
+            return n1 + __left_->print(l, l) + (__right_ ? __right_->print(l, l) : 0);
+        ptrdiff_t sz1 = __left_->print(f, l);
+        if (r < n1 + sz1)
+            return n1 + sz1 + (__right_ ? __right_->print(l, l) : 0);
+        ptrdiff_t sz2 = __right_ ? __right_->print(f+sz1+1, l) : 0;
+        if (r >= n1 + sz1 + sz2)
+        {
+            f += sz1;
+            *f = '(';
+            f += 1+sz2;
+            *f = ')';
+        }
+        return n1 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __delete_array_expr
+    : public __node
+{
+public:
+
+    __delete_array_expr(bool global, __node* op)
+    {
+        __size_ = global;
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = (__size_ ? 2 : 0) + 9 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            *buf++ = ':';
+            *buf++ = ':';
+        }
+        strncpy(buf, "delete[] ", 9);
+        return __right_->get_demangled_name(buf+9);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("delete[] ") - 1 + (__size_ ? 2 : 0);
+        if (r < n1)
+            return n1 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+n1, l);
+        if (r >= n1 + sz1)
+        {
+            if (__size_)
+            {
+                *f++ = ':';
+                *f++ = ':';
+            }
+            *f++ = 'd';
+            *f++ = 'e';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = 't';
+            *f++ = 'e';
+            *f++ = '[';
+            *f++ = ']';
+            *f   = ' ';
+        }
+        return n1 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __delete_expr
+    : public __node
+{
+public:
+
+    __delete_expr(bool global, __node* op)
+    {
+        __size_ = global;
+        __right_ = op;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = (__size_ ? 2 : 0) + 7 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            *buf++ = ':';
+            *buf++ = ':';
+        }
+        strncpy(buf, "delete ", 7);
+        return __right_->get_demangled_name(buf+7);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("delete ") - 1 + (__size_ ? 2 : 0);
+        if (r < n1)
+            return n1 + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+n1, l);
+        if (r >= n1 + sz1)
+        {
+            if (__size_)
+            {
+                *f++ = ':';
+                *f++ = ':';
+            }
+            *f++ = 'd';
+            *f++ = 'e';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f++ = 't';
+            *f++ = 'e';
+            *f   = ' ';
+        }
+        return n1 + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __new_expr
+    : public __node
+{
+public:
+
+    __new_expr(bool global, bool is_array, bool has_init,
+               __node* expr, __node* type, __node* init)
+    {
+        __size_ =  (unsigned)global         |
+                  ((unsigned)is_array << 1) |
+                  ((unsigned)has_init << 2);
+        __left_ = expr;
+        __name_ = (const char*)type;
+        __right_ = init;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t off = 4;
+            if (__size_ & 1)
+                off += 2;
+            if (__size_ & 2)
+                off += 2;
+            if (__left_)
+            {
+                off += 2;
+                off += __left_->size();
+            }
+            __node* type = (__node*)__name_;
+            off += type->size();
+            if (__size_ & 4)
+            {
+                off += 2;
+                if (__right_)
+                    off += __right_->size();
+            }
+            const_cast<long&>(__cached_size_) = off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_ & 1)
+        {
+            *buf++ = ':';
+            *buf++ = ':';
+        }
+        *buf++ = 'n';
+        *buf++ = 'e';
+        *buf++ = 'w';
+        if (__size_ & 2)
+        {
+            *buf++ = '[';
+            *buf++ = ']';
+        }
+        if (__left_)
+        {
+            *buf++ = '(';
+            buf = __left_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        *buf++ = ' ';
+        __node* type = (__node*)__name_;
+        buf = type->get_demangled_name(buf);
+        if (__size_ & 4)
+        {
+            *buf++ = '(';
+            if (__right_)
+                buf = __right_->get_demangled_name(buf);
+            *buf++ = ')';
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n1 = sizeof("new ") - 1 + (__size_ & 1 ? 2 : 0) +
+              (__size_ & 2 ? 2 : 0) + (__left_ ? 2 : 0) + (__size_ & 4 ? 2 : 0);
+        __node* type = (__node*)__name_;
+        if (r < n1)
+            return n1 + (__left_ ? __left_->print(l, l) : 0) +
+                        type->print(l, l) +
+                        (__right_ ? __right_->print(l, l) : 0);
+        ptrdiff_t sz1 = __left_ ? __left_->print(f+4+
+                                                 (__size_ & 1 ? 2 : 0) +
+                                                 (__size_ & 2 ? 2 : 0), l) : 0;
+        if (r < n1 + sz1)
+            return n1 + sz1 + type->print(l, l) +
+                              (__right_ ? __right_->print(l, l) : 0);
+        ptrdiff_t sz2 = type->print(f+(n1-(__size_ & 4 ? 2 : 0)+sz1), l);
+        if (r < n1 + sz1 + sz2)
+            return n1 + sz1 + sz2 + (__right_ ? __right_->print(l, l) : 0);
+        ptrdiff_t sz3 = __right_ ? __right_->print(f+(n1-1)+sz1+sz2, l) : 0;
+        if (r >= n1 + sz1 + sz2 + sz3)
+        {
+            if (__size_ & 1)
+            {
+                *f++ = ':';
+                *f++ = ':';
+            }
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'w';
+            if (__size_ & 2)
+            {
+                *f++ = '[';
+                *f++ = ']';
+            }
+            if (__left_)
+            {
+                *f   = '(';
+                f += 1 + sz1;
+                *f++ = ')';
+            }
+            *f   = ' ';
+            if (__size_ & 4)
+            {
+                f += 1 + sz2;
+                *f = '(';
+                f += 1 + sz3;
+                *f = ')';
+            }
+        }
+        return n1 + sz1 + sz2 + sz3;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        __node* type = (__node*)__name_;
+        bool r = type->fix_forward_references(t_begin, t_end);
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);;
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);;
+        return r;
+    }
+};
+
+class __dot_star_expr
+    : public __node
+{
+public:
+
+    __dot_star_expr(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 2 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '.';
+        *buf++ = '*';
+        return __right_->get_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof(".*") - 1;
+        if (r < n)
+            return n + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f, l);
+        if (r < n + sz1)
+            return n + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+n, l);
+        if (r >= n + sz1 + sz2)
+        {
+            f += sz1;
+            *f++ = '.';
+            *f   = '*';
+        }
+        return n + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __dot_expr
+    : public __node
+{
+public:
+
+    __dot_expr(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 1 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '.';
+        return __right_->get_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof(".") - 1;
+        if (r < n)
+            return n + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f, l);
+        if (r < n + sz1)
+            return n + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+n, l);
+        if (r >= n + sz1 + sz2)
+            f[sz1] = '.';
+        return n + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __arrow_expr
+    : public __node
+{
+public:
+
+    __arrow_expr(__node* op1, __node* op2)
+    {
+        __left_ = op1;
+        __right_ = op2;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + 2 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '-';
+        *buf++ = '>';
+        return __right_->get_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("->") - 1;
+        if (r < n)
+            return n + __left_->print(l, l) + __right_->print(l, l);
+        ptrdiff_t sz1 = __left_->print(f, l);
+        if (r < n + sz1)
+            return n + sz1 + __right_->print(l, l);
+        ptrdiff_t sz2 = __right_->print(f+sz1+n, l);
+        if (r >= n + sz1 + sz2)
+        {
+            f += sz1;
+            *f++ = '-';
+            *f   = '>';
+        }
+        return n + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) &&
+              __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __std_qualified_name
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std") - 1;
+public:
+
+    __std_qualified_name()
+    {
+    }
+    virtual size_t first_size() const
+    {
+        return n;
+    }
+
+    virtual char* first_demangled_name(char* buf) const
+    {
+        *buf++ = 's';
+        *buf++ = 't';
+        *buf++ = 'd';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f   = 'd';
+        }
+        return n;
+    }
+};
+
+class __sub_allocator
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std::allocator") - 1;
+public:
+
+    virtual size_t first_size() const
+    {
+        return n;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "std::allocator", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 'a';
+            *f++ = 'l';
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'c';
+            *f++ = 'a';
+            *f++ = 't';
+            *f++ = 'o';
+            *f   = 'r';
+        }
+        return n;
+    }
+};
+
+class __sub_basic_string
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std::basic_string") - 1;
+public:
+
+    virtual size_t first_size() const
+    {
+        return n;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "std::basic_string", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 'b';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'c';
+            *f++ = '_';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+};
+
+class __sub_string
+    : public __node
+{
+    static const size_t n = sizeof("std::string") - 1;
+    static const size_t ne = sizeof("std::basic_string<char, std::char_traits<char>, std::allocator<char> >") - 1;
+public:
+
+    virtual size_t first_size() const
+    {
+        if (__size_)
+            return ne;
+        return n;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            strncpy(buf, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >", ne);
+            buf += ne;
+        }
+        else
+        {
+            strncpy(buf, "std::string", n);
+            buf += n;
+        }
+        return buf;
+    }
+
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (__size_)
+        {
+            const ptrdiff_t n1 =
+                sizeof("std::basic_string<char, std::char_traits<char>,"
+                       " std::allocator<char> >") - 1;
+            if (r >= n1)
+                strncpy(f, "std::basic_string<char, std::char_traits<char>,"
+                           " std::allocator<char> >", n1);
+            return n1;
+        }
+        const ptrdiff_t n2 = sizeof("std::string") - 1;
+        if (r >= n2)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n2;
+    }
+    virtual size_t base_size() const
+    {
+        return 12;
+    }
+    virtual char* get_base_name(char* buf) const
+    {
+        strncpy(buf, "basic_string", 12);
+        return buf + 12;
+    }
+    virtual ptrdiff_t print_base_name(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("basic_string") - 1;
+        if (r >= n)
+        {
+            *f++ = 'b';
+            *f++ = 'a';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'c';
+            *f++ = '_';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+
+    virtual __node* base_name() const
+    {
+        const_cast<size_t&>(__size_) = true;
+        return const_cast<__node*>(static_cast<const __node*>(this));
+    }
+};
+
+class __sub_istream
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std::istream") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "std::istream", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 'i';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 'a';
+            *f   = 'm';
+        }
+        return n;
+    }
+};
+
+class __sub_ostream
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std::ostream") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "std::ostream", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 'o';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 'a';
+            *f   = 'm';
+        }
+        return n;
+    }
+};
+
+class __sub_iostream
+    : public __node
+{
+    static const ptrdiff_t n = sizeof("std::iostream") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "std::iostream", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'd';
+            *f++ = ':';
+            *f++ = ':';
+            *f++ = 'i';
+            *f++ = 'o';
+            *f++ = 's';
+            *f++ = 't';
+            *f++ = 'r';
+            *f++ = 'e';
+            *f++ = 'a';
+            *f   = 'm';
+        }
+        return n;
+    }
+};
+
+class __sub
+    : public __node
+{
+public:
+
+    explicit __sub(__node* arg)
+    {
+        __left_ = arg;
+    }
+    explicit __sub(size_t arg)
+    {
+        __size_ = arg;
+    }
+    virtual size_t first_size() const
+    {
+        return __left_->first_size();
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        return __left_->first_demangled_name(buf);
+    }
+    virtual size_t second_size() const
+    {
+        return __left_->second_size();
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        return __left_->second_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        return __left_->print_first(f, l);
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        return __left_->print_second(f, l);
+    }
+    virtual bool ends_with_template() const
+    {
+        return __left_->ends_with_template();
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_reference_or_pointer_to_function_or_array();
+    }
+    virtual bool is_function() const
+    {
+        return __left_->is_function();
+    }
+    virtual bool is_cv_qualifer() const
+    {
+        return __left_->is_cv_qualifer();
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return __left_->is_ctor_dtor_conv();
+    }
+    virtual bool is_array() const
+    {
+        return __left_->is_array();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        if (__left_ == 0)
+        {
+            if (__size_ < t_end - t_begin)
+            {
+                __left_ = t_begin[__size_];
+                __size_ = 0;
+            }
+            else
+                return false;
+        }
+        return true;
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+    virtual bool is_sub() const
+    {
+        return true;
+    }
+};
+
+class __unscoped_template_name
+    : public __node
+{
+public:
+    __unscoped_template_name(__node* name, __node* args)
+        {__left_ = name; __right_ = args;}
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = __left_->size() + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        return __right_->get_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t sz1 = __left_->print(f, l);
+        if (r < sz1)
+            return sz1 + __right_->print(l, l);
+        return sz1 + __right_->print(f + sz1, l);
+    }
+    virtual bool ends_with_template() const
+    {
+        return __right_->ends_with_template();
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end) && 
+               __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+// length == 0: __left_ == NULL
+// length == 1: __left_ != NULL, __right_ == NULL
+// length  > 1: __left_ != NULL, __right_ != NULL
+class __list
+    : public __node
+{
+public:
+    explicit __list(__node* type)
+        {__left_ = type;}
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            if (__left_ == NULL)
+                const_cast<long&>(__cached_size_) = 0;
+            else if (__right_ == NULL)
+                const_cast<long&>(__cached_size_) = __left_->size();
+            else
+            {
+                size_t off = __right_->size();
+                if (off > 0)
+                    off += 2;
+                const_cast<long&>(__cached_size_) = __left_->size() + off;
+            }
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_ != NULL)
+        {
+            char* t = __left_->get_demangled_name(buf + (__size_ ? 2 : 0));
+            if (__size_ == 0)
+                buf = t;
+            else if (t != buf+2)
+            {
+                *buf++ = ',';
+                *buf++ = ' ';
+                buf = t;
+            }
+            if (__right_)
+                buf = __right_->get_demangled_name(buf);
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        if (__left_ == 0)
+            return 0;
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        if (__size_)
+        {
+            n = 2;
+            if (r < n)
+            {
+                ptrdiff_t sz1 = __left_->print(l, l);
+                if (sz1 == 0)
+                    n = 0;
+                return n + sz1 + (__right_ ? __right_->print(l, l) : 0);
+            }
+        }
+        const ptrdiff_t sz1 = __left_->print(f+n, l);
+        if (sz1 == 0)
+            n = 0;
+        else if (n != 0)
+        {
+            f[0] = ',';
+            f[1] = ' ';
+        }
+        const ptrdiff_t sz2 = __right_ ? __right_->print(f+std::min(n+sz1, r), l) : 0;
+        return n + sz1 + sz2;
+    }
+    virtual bool ends_with_template() const
+    {
+        if (__right_ != NULL)
+            return __right_->ends_with_template();
+        if (__left_ != NULL)
+            return __left_->ends_with_template();
+        return false;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+    virtual size_t list_len() const
+    {
+        if (!__left_)
+            return 0;
+        if (!__right_)
+            return 1;
+        return 1 + __right_->list_len();
+    }
+};
+
+class __template_args
+    : public __node
+{
+public:
+    __template_args(__node* name, __node* list)
+    {
+        __left_ = name;
+        __right_ = list;
+    }
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t off = 2;
+            if (__right_)
+            {
+                if (__right_->ends_with_template())
+                    ++off;
+                off += __right_->size();
+            }
+            const_cast<long&>(__cached_size_) = __left_->size() + off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        *buf++ = '<';
+        if (__right_)
+        {
+            buf = __right_->get_demangled_name(buf);
+            if (buf[-1] == '>')
+                *buf++ = ' ';
+        }
+        *buf++ = '>';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz1 = __left_->print(f, l);
+        ptrdiff_t sz2 = 0;
+        ptrdiff_t n = 2;
+        if (__right_)
+        {
+            sz2 = __right_->print(f+std::min(sz1+1, r), l);
+            if (r >= sz1 + sz2 + 2)
+            {
+                if (f[sz1+sz2] == '>')
+                {
+                    f[sz1+sz2+1] = ' ';
+                    ++n;
+                }
+            }
+            else if (__right_->ends_with_template())
+                ++n;
+        }
+        if (r >= sz1 + sz2 + n)
+        {
+            f[sz1] = '<';
+            f[sz1+sz2+n-1] = '>';
+        }
+        return n + sz1 + sz2;
+    }
+
+    virtual bool ends_with_template() const
+    {
+        return true;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return __left_->is_ctor_dtor_conv();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __function_args
+    : public __node
+{
+public:
+    __function_args(__node* list)
+        {__right_ = list;}
+
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = 2 + __right_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        *buf++ = '(';
+        buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = 2;
+        if (r < n)
+            return n + __right_->print(l, l);
+        ptrdiff_t sz1 = __right_->print(f+1, l);
+        if (r >= n + sz1)
+        {
+            *f = '(';
+            f += 1 + sz1;
+            *f = ')';
+        }
+        return n + sz1;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __right_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __cv_qualifiers
+    : public __node
+{
+public:
+    __cv_qualifiers(size_t cv, __node* type)
+    {
+        __left_ = type;
+        __size_ = __left_->is_function() ? cv << 5 : cv;
+    }
+
+    virtual size_t first_size() const
+    {
+        size_t s = __left_->first_size();
+        if (__size_ & 4)
+            s += sizeof(" restrict")-1;
+        if (__size_ & 2)
+            s += sizeof(" volatile")-1;
+        if (__size_ & 1)
+            s += sizeof(" const")-1;
+        if (__size_ & 8)
+            s += sizeof(" &")-1;
+        if (__size_ & 16)
+            s += sizeof(" &&")-1;
+        return s;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->first_demangled_name(buf);
+        if (__size_ & 1)
+        {
+            const size_t n = sizeof(" const")-1;
+            strncpy(buf, " const", n);
+            buf += n;
+        }
+        if (__size_ & 2)
+        {
+            const size_t n = sizeof(" volatile")-1;
+            strncpy(buf, " volatile", n);
+            buf += n;
+        }
+        if (__size_ & 4)
+        {
+            const size_t n = sizeof(" restrict")-1;
+            strncpy(buf, " restrict", n);
+            buf += n;
+        }
+        if (__size_ & 8)
+        {
+            *buf++ = ' ';
+            *buf++ = '&';
+        }
+        if (__size_ & 16)
+        {
+            *buf++ = ' ';
+            *buf++ = '&';
+            *buf++ = '&';
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print_first(f, l);
+        ptrdiff_t n = 0;
+        if (__size_ & 0x1F)
+        {
+            if (__size_ & 1)
+            {
+                const ptrdiff_t d = sizeof(" const")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'c';
+                    *t++ = 'o';
+                    *t++ = 'n';
+                    *t++ = 's';
+                    *t   = 't';
+                }
+                n += d;
+            }
+            if (__size_ & 2)
+            {
+                const ptrdiff_t d = sizeof(" volatile")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'v';
+                    *t++ = 'o';
+                    *t++ = 'l';
+                    *t++ = 'a';
+                    *t++ = 't';
+                    *t++ = 'i';
+                    *t++ = 'l';
+                    *t   = 'e';
+                }
+                n += d;
+            }
+            if (__size_ & 4)
+            {
+                const ptrdiff_t d = sizeof(" restrict")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'r';
+                    *t++ = 'e';
+                    *t++ = 's';
+                    *t++ = 't';
+                    *t++ = 'r';
+                    *t++ = 'i';
+                    *t++ = 'c';
+                    *t   = 't';
+                }
+                n += d;
+            }
+            if (__size_ & 8)
+            {
+                const ptrdiff_t d = sizeof(" &")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t   = '&';
+                }
+                n += d;
+            }
+            if (__size_ & 16)
+            {
+                const ptrdiff_t d = sizeof(" &&")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = '&';
+                    *t   = '&';
+                }
+                n += d;
+            }
+        }
+        return n + sz;
+    }
+    virtual size_t second_size() const
+    {
+        size_t s = __left_->second_size();
+        if (__size_ & 128)
+            s += sizeof(" restrict")-1;
+        if (__size_ & 64)
+            s += sizeof(" volatile")-1;
+        if (__size_ & 32)
+            s += sizeof(" const")-1;
+        if (__size_ & 256)
+            s += sizeof(" &")-1;
+        if (__size_ & 512)
+            s += sizeof(" &&")-1;
+        return s;
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        buf = __left_->second_demangled_name(buf);
+        if (__size_ & 32)
+        {
+            const size_t n = sizeof(" const")-1;
+            strncpy(buf, " const", n);
+            buf += n;
+        }
+        if (__size_ & 64)
+        {
+            const size_t n = sizeof(" volatile")-1;
+            strncpy(buf, " volatile", n);
+            buf += n;
+        }
+        if (__size_ & 128)
+        {
+            const size_t n = sizeof(" restrict")-1;
+            strncpy(buf, " restrict", n);
+            buf += n;
+        }
+        if (__size_ & 256)
+        {
+            *buf++ = ' ';
+            *buf++ = '&';
+        }
+        if (__size_ & 512)
+        {
+            *buf++ = ' ';
+            *buf++ = '&';
+            *buf++ = '&';
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print_second(f, l);
+        ptrdiff_t n = 0;
+        if (__size_ & 0x3E0)
+        {
+            if (__size_ & 32)
+            {
+                const ptrdiff_t d = sizeof(" const")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'c';
+                    *t++ = 'o';
+                    *t++ = 'n';
+                    *t++ = 's';
+                    *t   = 't';
+                }
+                n += d;
+            }
+            if (__size_ & 64)
+            {
+                const ptrdiff_t d = sizeof(" volatile")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'v';
+                    *t++ = 'o';
+                    *t++ = 'l';
+                    *t++ = 'a';
+                    *t++ = 't';
+                    *t++ = 'i';
+                    *t++ = 'l';
+                    *t   = 'e';
+                }
+                n += d;
+            }
+            if (__size_ & 128)
+            {
+                const ptrdiff_t d = sizeof(" restrict")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = 'r';
+                    *t++ = 'e';
+                    *t++ = 's';
+                    *t++ = 't';
+                    *t++ = 'r';
+                    *t++ = 'i';
+                    *t++ = 'c';
+                    *t   = 't';
+                }
+                n += d;
+            }
+            if (__size_ & 256)
+            {
+                const ptrdiff_t d = sizeof(" &")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t   = '&';
+                }
+                n += d;
+            }
+            if (__size_ & 512)
+            {
+                const ptrdiff_t d = sizeof(" &&")-1;
+                if (r >= sz + n + d)
+                {
+                    char* t = f + sz + n;
+                    *t++ = ' ';
+                    *t++ = '&';
+                    *t   = '&';
+                }
+                n += d;
+            }
+        }
+        return n + sz;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_reference_or_pointer_to_function_or_array();
+    }
+    virtual bool is_function() const
+    {
+        return __left_->is_function();
+    }
+    virtual bool is_cv_qualifer() const
+    {
+        return true;
+    }
+    virtual __node* extract_cv(__node*& rt) const
+    {
+        if (rt == this)
+        {
+            rt = __left_;
+            return const_cast<__node*>(static_cast<const __node*>(this));
+        }
+        return 0;
+    }
+    virtual bool ends_with_template() const
+    {
+        return __left_->ends_with_template();
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return __left_->is_ctor_dtor_conv();
+    }
+    virtual bool is_array() const
+    {
+        return __left_->is_array();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+};
+
+class __extended_qualifier
+    : public __node
+{
+public:
+    __extended_qualifier(__node* name, __node* type)
+    {
+        __left_ = type;
+        __right_ = name;
+        __size_ = __left_->is_function() ? 1 : 0;
+    }
+
+    virtual size_t first_size() const
+    {
+        size_t s = __left_->first_size();
+        if (__size_ == 0)
+            s += __right_->size() + 1;
+        return s;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->first_demangled_name(buf);
+        if (__size_ == 0)
+        {
+            *buf++ = ' ';
+            buf = __right_->get_demangled_name(buf);
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz1 = __left_->print_first(f, l);
+        ptrdiff_t sz2 = 0;
+        ptrdiff_t n = 0;
+        if (__size_ == 0)
+        {
+            if (r < sz1 + 1)
+                return sz1 + 1 + __right_->print(l, l);
+            sz2 = __right_->print(f+1+sz1, l);
+            n = 1;
+            f[sz1] = ' ';
+        }
+        return n + sz1 + sz2;
+    }
+    virtual size_t second_size() const
+    {
+        size_t s = __left_->second_size();
+        if (__size_ == 1)
+            s += __right_->size() + 1;
+        return s;
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        buf = __left_->second_demangled_name(buf);
+        if (__size_ == 1)
+        {
+            *buf++ = ' ';
+            buf = __right_->get_demangled_name(buf);
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz1 = __left_->print_second(f, l);
+        ptrdiff_t sz2 = 0;
+        ptrdiff_t n = 0;
+        if (__size_ == 1)
+        {
+            if (r < sz1 + 1)
+                return sz1 + 1 + __right_->print(l, l);
+            sz2 = __right_->print(f+1+sz1, l);
+            n = 1;
+            f[sz1] = ' ';
+        }
+        return n + sz1 + sz2;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_reference_or_pointer_to_function_or_array();
+    }
+    virtual bool is_function() const
+    {
+        return __left_->is_function();
+    }
+    virtual bool is_cv_qualifer() const
+    {
+        return true;
+    }
+    virtual __node* extract_cv(__node*& rt) const
+    {
+        if (rt == this)
+        {
+            rt = __left_;
+            return const_cast<__node*>(static_cast<const __node*>(this));
+        }
+        return 0;
+    }
+    virtual bool ends_with_template() const
+    {
+        return __left_->ends_with_template();
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return __left_->is_ctor_dtor_conv();
+    }
+    virtual bool is_array() const
+    {
+        return __left_->is_array();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+};
+
+class __function
+    : public __node
+{
+public:
+
+    __function(__node* name, __node* signature, size_t ret_goes_first = true)
+    {
+        __size_ = ret_goes_first;
+        __left_ = name;
+        __right_ = signature;
+    }
+
+    virtual size_t first_size() const
+    {
+        size_t off = 0;
+        if (__size_)
+        {
+            off = __right_->first_size();
+            if (off > 0 && (__left_ == NULL ||
+                            !__right_->__left_->is_reference_or_pointer_to_function_or_array()))
+                ++off;
+        }
+        else
+            off = 5;
+        if (__left_)
+            off += __left_->first_size();
+        else
+            ++off;
+        return off;
+    }
+
+    virtual size_t second_size() const
+    {
+        size_t off = 0;
+        if (__left_ == NULL)
+            off = 1;
+        off += __right_->second_size();
+        if (!__size_)
+        {
+            off += 2;
+            off += __right_->first_size();
+        }
+        return off;
+    }
+
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__size_)
+        {
+            const char* t = buf;
+            buf = __right_->first_demangled_name(buf);
+            if (buf != t && (__left_ == NULL ||
+                            !__right_->__left_->is_reference_or_pointer_to_function_or_array()))
+                *buf++ = ' ';
+        }
+        else
+        {
+            strncpy(buf, "auto ", 5);
+            buf += 5;
+        }
+        if (__left_)
+            buf = __left_->first_demangled_name(buf);
+        else
+            *buf++ = '(';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        ptrdiff_t sz1 = 0;
+        ptrdiff_t sz2 = 0;
+        if (__size_)
+        {
+            sz1 = __right_->print_first(f, l);
+            if (sz1 != 0 && (__left_ == NULL ||
+                            !__right_->__left_->is_reference_or_pointer_to_function_or_array()))
+            {
+                ++n;
+                if (r >= sz1 + 1)
+                    f[sz1] = ' ';
+            }
+        }
+        else
+        {
+            n = 5;
+            if (r >= 5)
+            {
+                char* t = f;
+                *t++ = 'a';
+                *t++ = 'u';
+                *t++ = 't';
+                *t++ = 'o';
+                *t++ = ' ';
+            }
+        }
+        if (__left_)
+            sz2 = __left_->print_first(f + std::min(n + sz1, r), l);
+        else
+        {
+            ++n;
+            if (r >= n + sz1)
+                f[n+sz1-1] = '(';
+        }
+        return n + sz1 + sz2;
+    }
+
+    virtual char* second_demangled_name(char* buf) const
+    {
+        if (__left_ == NULL)
+            *buf++ = ')';
+        buf = __right_->second_demangled_name(buf);
+        if (!__size_)
+        {
+            *buf++ = '-';
+            *buf++ = '>';
+            buf = __right_->first_demangled_name(buf);
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        ptrdiff_t sz1 = 0;
+        ptrdiff_t sz2 = 0;
+        if (__left_ == NULL)
+        {
+            n = 1;
+            if (r >= 1)
+                *f = ')';
+        }
+        sz1 = __right_->print_second(f+std::min(r, n), l);
+        if (!__size_)
+        {
+            if (r > n+sz1+1)
+            {
+                f[n+sz1]   = '-';
+                f[n+sz1+1] = '>';
+            }
+            n += 2;
+            sz2 = __right_->print_first(f+std::min(r, n+sz1), l);
+        }
+        return n + sz1 + sz2;
+    }
+
+    virtual bool is_function() const
+    {
+        return true;
+    }
+    virtual bool is_ctor_dtor_conv() const
+    {
+        return __left_->is_ctor_dtor_conv();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __function_signature
+    : public __node
+{
+public:
+    __function_signature(__node* ret, __node* args)
+    {
+        __left_ = ret;
+        __right_ = args;
+    }
+    virtual size_t first_size() const
+    {
+        return __left_ ? __left_->first_size() : 0;
+    }
+
+    virtual size_t second_size() const
+    {
+        return 2 + (__right_ ? __right_->size() : 0)
+                 + (__left_ ? __left_->second_size() : 0);
+    }
+
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (__left_)
+            buf = __left_->first_demangled_name(buf);
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        return __left_ ? __left_->print_first(f, l) : 0;
+    }
+
+    virtual char* second_demangled_name(char* buf) const
+    {
+        *buf++ = '(';
+        if (__right_)
+            buf = __right_->get_demangled_name(buf);
+        *buf++ = ')';
+        if (__left_)
+            buf = __left_->second_demangled_name(buf);
+        return buf;
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz1 = __right_ ? __right_->print(f+std::min<ptrdiff_t>(1, r), l) : 0;
+        const ptrdiff_t sz2 = __left_ ? __left_->print_second(f+std::min(2+sz1, r), l) : 0;
+        if (r >= 2 + sz1 + sz2)
+        {
+            *f = '(';
+            f += 1 + sz1;
+            *f = ')';
+        }
+        return 2 + sz1 + sz2;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        bool r = true;
+        if (__left_)
+            r = r && __left_->fix_forward_references(t_begin, t_end);
+        if (__right_)
+            r = r && __right_->fix_forward_references(t_begin, t_end);
+        return r;
+    }
+};
+
+class __pointer_to
+    : public __node
+{
+public:
+
+    explicit __pointer_to(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        return __left_->first_size() + (__left_->is_array() ? 3 : 1);
+    }
+    virtual size_t second_size() const
+    {
+        return __left_->second_size() + (__left_->is_array() ? 1 : 0);
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->first_demangled_name(buf);
+        if (__left_->is_array())
+        {
+            *buf++ = ' ';
+            *buf++ = '(';
+            *buf++ = '*';
+        }
+        else
+            *buf++ = '*';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print_first(f, l);
+        ptrdiff_t n;
+        if (__left_->is_array())
+        {
+            n = 3;
+            if (r >= sz + n)
+            {
+                f += sz;
+                *f++ = ' ';
+                *f++ = '(';
+                *f   = '*';
+            }
+        }
+        else
+        {
+            n = 1;
+            if (r >= sz + n)
+                f[sz] = '*';
+        }
+        return sz + n;
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        if (__left_->is_array())
+            *buf++ = ')';
+        return __left_->second_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        if (__left_->is_array())
+        {
+            n = 1;
+            if (r > n)
+                *f = ')';
+        }
+        return __left_->print_second(f + std::min(n, r), l) + n;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_function() ||
+               __left_->is_reference_or_pointer_to_function_or_array();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+};
+
+class __lvalue_reference_to
+    : public __node
+{
+public:
+
+    explicit __lvalue_reference_to(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        return __left_->first_size() + (__left_->is_array() ? 3 : 1);
+    }
+    virtual size_t second_size() const
+    {
+        return __left_->second_size() + (__left_->is_array() ? 1 : 0);
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->first_demangled_name(buf);
+        if (__left_->is_array())
+        {
+            *buf++ = ' ';
+            *buf++ = '(';
+            *buf++ = '&';
+        }
+        else
+            *buf++ = '&';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print_first(f, l);
+        ptrdiff_t n;
+        if (__left_->is_array())
+        {
+            n = 3;
+            if (r >= sz + n)
+            {
+                f += sz;
+                *f++ = ' ';
+                *f++ = '(';
+                *f   = '&';
+            }
+        }
+        else
+        {
+            n = 1;
+            if (r >= sz + n)
+                f[sz] = '&';
+        }
+        return sz + n;
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        if (__left_->is_array())
+            *buf++ = ')';
+        return __left_->second_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        if (__left_->is_array())
+        {
+            n = 1;
+            if (r > n)
+                *f = ')';
+        }
+        return __left_->print_second(f + std::min(n, r), l) + n;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_function();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+};
+
+class __rvalue_reference_to
+    : public __node
+{
+public:
+
+    explicit __rvalue_reference_to(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        return __left_->first_size() + (__left_->is_array() ? 4 : 2);
+    }
+    virtual size_t second_size() const
+    {
+        return __left_->second_size() + (__left_->is_array() ? 1 : 0);
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->first_demangled_name(buf);
+        if (__left_->is_array())
+        {
+            strncpy(buf, " (&&", 4);
+            buf += 4;
+        }
+        else
+        {
+            *buf++ = '&';
+            *buf++ = '&';
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print_first(f, l);
+        ptrdiff_t n;
+        if (__left_->is_array())
+        {
+            n = 4;
+            if (r >= sz + n)
+            {
+                f += sz;
+                *f++ = ' ';
+                *f++ = '(';
+                *f++ = '&';
+                *f   = '&';
+            }
+        }
+        else
+        {
+            n = 2;
+            if (r >= sz + n)
+            {
+                f += sz;
+                *f++ = '&';
+                *f   = '&';
+            }
+        }
+        return sz + n;
+    }
+    virtual char* second_demangled_name(char* buf) const
+    {
+        if (__left_->is_array())
+            *buf++ = ')';
+        return __left_->second_demangled_name(buf);
+    }
+    virtual ptrdiff_t print_second(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        ptrdiff_t n = 0;
+        if (__left_->is_array())
+        {
+            n = 1;
+            if (r > n)
+                *f = ')';
+        }
+        return __left_->print_second(f + std::min(n, r), l) + n;
+    }
+    virtual __node* base_name() const
+    {
+        return __left_->base_name();
+    }
+    virtual bool is_reference_or_pointer_to_function_or_array() const
+    {
+        return __left_->is_function();
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+    virtual size_t list_len() const
+    {
+        return __left_->list_len();
+    }
+};
+
+class __d_complex
+    : public __node
+{
+    static const size_t n = sizeof(" complex") - 1;
+public:
+
+    explicit __d_complex(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __left_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        strncpy(buf, " complex", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print(f, l);
+        const ptrdiff_t n = sizeof(" complex") - 1;
+        if (r >= sz + n)
+        {
+            f += sz;
+            *f++ = ' ';
+            *f++ = 'c';
+            *f++ = 'o';
+            *f++ = 'm';
+            *f++ = 'p';
+            *f++ = 'l';
+            *f++ = 'e';
+            *f   = 'x';
+        }
+        return sz + n;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __imaginary
+    : public __node
+{
+    static const size_t n = sizeof(" imaginary") - 1;
+public:
+
+    explicit __imaginary(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+            const_cast<long&>(__cached_size_) = n + __left_->size();
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        buf = __left_->get_demangled_name(buf);
+        strncpy(buf, " imaginary", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t sz = __left_->print(f, l);
+        const ptrdiff_t n = sizeof(" imaginary") - 1;
+        if (r >= sz + n)
+        {
+            f += sz;
+            *f++ = ' ';
+            *f++ = 'i';
+            *f++ = 'm';
+            *f++ = 'a';
+            *f++ = 'g';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f   = 'y';
+        }
+        return sz + n;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __pack_expansion
+    : public __node
+{
+public:
+
+    explicit __pack_expansion(__node* type)
+    {
+        __left_ = type;
+    }
+    virtual size_t first_size() const
+    {
+        if (__cached_size_ == -1)
+        {
+            size_t len = __left_->list_len();
+            size_t off = 0;
+            if (len != 0)
+            {
+                if (__left_->is_sub() || len == 1)
+                    off = __left_->size();
+                else
+                {
+                    __node* top = __left_;
+                    __node* bottom = top;
+                    while (!bottom->__left_->is_sub())
+                        bottom = bottom->__left_;
+                    __node* sub = bottom->__left_;
+                    __node* i = sub->__left_;
+                    bool first = true;
+                    top->reset_cached_size();
+                    while (i)
+                    {
+                        if (!first)
+                            off += 2;
+                        bottom->__left_ = i->__left_;
+                        off += top->size();
+                        top->reset_cached_size();
+                        i = i->__right_;
+                        first = false;
+                    }
+                    bottom->__left_ = sub;
+                }
+            }
+            const_cast<long&>(__cached_size_) = off;
+        }
+        return __cached_size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        size_t len = __left_->list_len();
+        if (len != 0)
+        {
+            if (__left_->is_sub() || len == 1)
+                buf = __left_->get_demangled_name(buf);
+            else
+            {
+                __node* top = __left_;
+                __node* bottom = top;
+                while (!bottom->__left_->is_sub())
+                    bottom = bottom->__left_;
+                __node* sub = bottom->__left_;
+                __node* i = sub->__left_;
+                bool first = true;
+                top->reset_cached_size();
+                while (i)
+                {
+                    if (!first)
+                    {
+                        *buf++ = ',';
+                        *buf++ = ' ';
+                    }
+                    bottom->__left_ = i->__left_;
+                    buf = top->get_demangled_name(buf);
+                    top->reset_cached_size();
+                    i = i->__right_;
+                    first = false;
+                }
+                bottom->__left_ = sub;
+            }
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t len = __left_->list_len();
+        ptrdiff_t sz = 0;
+        if (len != 0)
+        {
+             if (__left_->is_sub() || len == 1)
+                sz = __left_->print(f, l);
+            else
+            {
+                __node* top = __left_;
+                __node* bottom = top;
+                while (!bottom->__left_->is_sub())
+                    bottom = bottom->__left_;
+                __node* sub = bottom->__left_;
+                __node* i = sub->__left_;
+                bool first = true;
+                while (i)
+                {
+                    if (!first)
+                    {
+                        if (r >= sz+2)
+                        {
+                            f[sz]   = ',';
+                            f[sz+1] = ' ';
+                        }
+                        sz += 2;
+                    }
+                    bottom->__left_ = i->__left_;
+                    sz += top->print(f+std::min(sz, r), l);
+                    i = i->__right_;
+                    first = false;
+                }
+                bottom->__left_ = sub;
+            }
+        }
+        return sz;
+    }
+    virtual bool fix_forward_references(__node** t_begin, __node** t_end)
+    {
+        return __left_->fix_forward_references(t_begin, t_end);
+    }
+};
+
+class __void
+    : public __node
+{
+    static const size_t n = sizeof("void") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "void", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'v';
+            *f++ = 'o';
+            *f++ = 'i';
+            *f   = 'd';
+        }
+        return n;
+    }
+};
+
+class __wchar_t
+    : public __node
+{
+    static const size_t n = sizeof("wchar_t") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "wchar_t", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'w';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = '_';
+            *f   = 't';
+        }
+        return n;
+    }
+};
+
+class __wchar_t_literal
+    : public __node
+{
+public:
+    explicit __wchar_t_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+9;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(wchar_t)", 9);
+        buf += 9;
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(wchar_t)") - 1;
+        if (r >= n + __size_)
+        {
+            *f++ = '(';
+            *f++ = 'w';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = '_';
+            *f++ = 't';
+            *f++ = ')';
+            strncpy(f, __name_, __size_);
+        }
+        return n + __size_;
+    }
+};
+
+class __bool
+    : public __node
+{
+    static const size_t n = sizeof("bool") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "bool", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'b';
+            *f++ = 'o';
+            *f++ = 'o';
+            *f   = 'l';
+        }
+        return n;
+    }
+};
+
+class __bool_literal
+    : public __node
+{
+public:
+    explicit __bool_literal(const char* __name, unsigned __size)
+    {
+        __name_ = __name;
+        __size_ = __size;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= __size_)
+            strncpy(f, __name_, __size_);
+        return __size_;
+    }
+};
+
+class __char
+    : public __node
+{
+    static const size_t n = sizeof("char") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "char", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f   = 'r';
+        }
+        return n;
+    }
+};
+
+class __char_literal
+    : public __node
+{
+public:
+    explicit __char_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+6;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(char)", 6);
+        buf += 6;
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';  // strncpy(buf+6, "-", 1);
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(char)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = ')';
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+            }
+            else
+                strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __signed_char
+    : public __node
+{
+    static const size_t n = sizeof("signed char") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "signed char", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f   = 'r';
+        }
+        return n;
+    }
+};
+
+class __signed_char_literal
+    : public __node
+{
+public:
+    explicit __signed_char_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+13;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(signed char)", 13);
+        buf += 13;
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(signed char)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = ')';
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+            }
+            else
+                strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __unsigned_char
+    : public __node
+{
+    static const size_t n = sizeof("unsigned char") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned char", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f   = 'r';
+        }
+        return n;
+    }
+};
+
+class __unsigned_char_literal
+    : public __node
+{
+public:
+    explicit __unsigned_char_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+15;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(unsigned char)", 15);
+        buf += 15;
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(unsigned char)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'c';
+            *f++ = 'h';
+            *f++ = 'a';
+            *f++ = 'r';
+            *f++ = ')';
+            strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __short
+    : public __node
+{
+    static const size_t n = sizeof("short") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "short", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 's';
+            *f++ = 'h';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = 't';
+        }
+        return n;
+    }
+};
+
+class __short_literal
+    : public __node
+{
+public:
+    explicit __short_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+7;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(short)", 7);
+        buf += 7;
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(short)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = 's';
+            *f++ = 'h';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = 't';
+            *f++ = ')';
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+            }
+            else
+                strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __unsigned_short
+    : public __node
+{
+    static const size_t n = sizeof("unsigned short") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned short", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 's';
+            *f++ = 'h';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f   = 't';
+        }
+        return n;
+    }
+};
+
+class __unsigned_short_literal
+    : public __node
+{
+public:
+    explicit __unsigned_short_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+16;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(unsigned short)", 16);
+        buf += 16;
+        strncpy(buf, __name_, __size_);
+        return buf + __size_;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(unsigned short)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 's';
+            *f++ = 'h';
+            *f++ = 'o';
+            *f++ = 'r';
+            *f++ = 't';
+            *f++ = ')';
+            strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __int
+    : public __node
+{
+    static const size_t n = sizeof("int") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        *buf++ = 'i';
+        *buf++ = 'n';
+        *buf++ = 't';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'i';
+            *f++ = 'n';
+            *f   = 't';
+        }
+        return n;
+    }
+};
+
+class __int_literal
+    : public __node
+{
+public:
+    explicit __int_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= __size_)
+        {
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+            }
+            else
+                strncpy(f, __name_, __size_);
+        }
+        return __size_;
+    }
+};
+
+class __unsigned_int
+    : public __node
+{
+    static const size_t n = sizeof("unsigned int") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned int", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f   = 't';
+        }
+        return n;
+    }
+};
+
+class __unsigned_int_literal
+    : public __node
+{
+public:
+    explicit __unsigned_int_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+1;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, __name_, __size_);
+        buf += __size_;
+        *buf++ = 'u';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("u") - 1;
+        if (r >= __size_ + n)
+        {
+            strncpy(f, __name_, __size_);
+            f[__size_] = 'u';
+        }
+        return __size_ + n;
+    }
+};
+
+class __long
+    : public __node
+{
+    static const size_t n = sizeof("long") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "long", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+};
+
+class __long_literal
+    : public __node
+{
+public:
+    explicit __long_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+1;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';  // strncpy(buf, "-", 1);
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        *buf++ = 'l';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("l") - 1;
+        if (r >= __size_ + n)
+        {
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+                f += __size_-1;
+            }
+            else
+            {
+                strncpy(f, __name_, __size_);
+                f += __size_;
+            }
+            *f = 'l';
+        }
+        return __size_ + n;
+    }
+};
+
+class __unsigned_long
+    : public __node
+{
+    static const size_t n = sizeof("unsigned long") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned long", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+};
+
+class __unsigned_long_literal
+    : public __node
+{
+public:
+    explicit __unsigned_long_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+2;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, __name_, __size_);
+        buf += __size_;
+        *buf++ = 'u';
+        *buf++ = 'l';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("ul") - 1;
+        if (r >= __size_ + n)
+        {
+            strncpy(f, __name_, __size_);
+            f += __size_;
+            *f++ = 'u';
+            *f   = 'l';
+        }
+        return __size_ + n;
+    }
+};
+
+class __long_long
+    : public __node
+{
+    static const size_t n = sizeof("long long") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "long long", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f++ = 'g';
+            *f++ = ' ';
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+};
+
+class __long_long_literal
+    : public __node
+{
+public:
+    explicit __long_long_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+2;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        *buf++ = 'l';
+        *buf++ = 'l';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("ll") - 1;
+        if (r >= __size_ + n)
+        {
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+                f += __size_-1;
+            }
+            else
+            {
+                strncpy(f, __name_, __size_);
+                f += __size_;
+            }
+            *f++ = 'l';
+            *f   = 'l';
+        }
+        return __size_ + n;
+    }
+};
+
+class __unsigned_long_long
+    : public __node
+{
+    static const size_t n = sizeof("unsigned long long") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned long long", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f++ = 'g';
+            *f++ = ' ';
+            *f++ = 'l';
+            *f++ = 'o';
+            *f++ = 'n';
+            *f   = 'g';
+        }
+        return n;
+    }
+};
+
+class __unsigned_long_long_literal
+    : public __node
+{
+public:
+    explicit __unsigned_long_long_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+3;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, __name_, __size_);
+        buf += __size_;
+        *buf++ = 'u';
+        *buf++ = 'l';
+        *buf++ = 'l';
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("ull") - 1;
+        if (r >= __size_ + n)
+        {
+            strncpy(f, __name_, __size_);
+            f += __size_;
+            *f++ = 'u';
+            *f++ = 'l';
+            *f   = 'l';
+        }
+        return __size_ + n;
+    }
+};
+
+class __int128
+    : public __node
+{
+    static const size_t n = sizeof("__int128") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "__int128", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = '_';
+            *f++ = '_';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 't';
+            *f++ = '1';
+            *f++ = '2';
+            *f   = '8';
+        }
+        return n;
+    }
+};
+
+class __int128_literal
+    : public __node
+{
+public:
+    explicit __int128_literal(const char* __first, const char* __last)
+    {
+        __name_ = __first;
+        __size_ = __last - __first;
+    }
+
+    virtual size_t first_size() const
+    {
+        return __size_+10;
+    }
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "(__int128)", 10);
+        buf += 10;
+        if (*__name_ == 'n')
+        {
+            *buf++ = '-';
+            strncpy(buf, __name_+1, __size_-1);
+            buf += __size_ - 1;
+        }
+        else
+        {
+            strncpy(buf, __name_, __size_);
+            buf += __size_;
+        }
+        return buf;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        const ptrdiff_t n = sizeof("(__int128)") - 1;
+        if (r >= __size_ + n)
+        {
+            *f++ = '(';
+            *f++ = '_';
+            *f++ = '_';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 't';
+            *f++ = '1';
+            *f++ = '2';
+            *f++ = '8';
+            *f   = ')';
+            if (*__name_ == 'n')
+            {
+                *f++ = '-';
+                strncpy(f, __name_+1, __size_-1);
+            }
+            else
+                strncpy(f, __name_, __size_);
+        }
+        return __size_ + n;
+    }
+};
+
+class __unsigned_int128
+    : public __node
+{
+    static const size_t n = sizeof("unsigned __int128") - 1;
+public:
+
+    virtual size_t first_size() const {return n;}
+    virtual char* first_demangled_name(char* buf) const
+    {
+        strncpy(buf, "unsigned __int128", n);
+        return buf + n;
+    }
+    virtual ptrdiff_t print_first(char* f, char* l) const
+    {
+        const ptrdiff_t r = l - f;
+        if (r >= n)
+        {
+            *f++ = 'u';
+            *f++ = 'n';
+            *f++ = 's';
+            *f++ = 'i';
+            *f++ = 'g';
+            *f++ = 'n';
+            *f++ = 'e';
+            *f++ = 'd';
+            *f++ = ' ';
+            *f++ = '_';
+            *f++ = '_';
+            *f++ = 'i';
+            *f++ = 'n';
+            *f++ = 't';
+ &nb