diff --git a/src/ccutil/tesscallback.h b/src/ccutil/tesscallback.h
index dcdd805505..23d298eaeb 100644
--- a/src/ccutil/tesscallback.h
+++ b/src/ccutil/tesscallback.h
@@ -7770,16 +7770,6 @@ class _TessMemberResultCallback_0_4<del, void, T, A1, A2, A3, A4>
   }
 };
 
-#ifndef SWIG
-template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
-inline
-    typename _TessMemberResultCallback_0_4<true, R, T1, A1, A2, A3, A4>::base*
-    NewTessCallback(T1* obj, R (T2::*member)(A1, A2, A3, A4)) {
-  return new _TessMemberResultCallback_0_4<true, R, T1, A1, A2, A3, A4>(obj,
-                                                                        member);
-}
-#endif
-
 #ifndef SWIG
 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
 inline
@@ -7790,3842 +7780,4 @@ inline
 }
 #endif
 
-template <bool del, class R, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_0_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-
- public:
-  inline explicit _TessFunctionResultCallback_0_4(FunctionSignature function)
-      : function_(function) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_0_4<del, void, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-
- public:
-  inline explicit _TessFunctionResultCallback_0_4(FunctionSignature function)
-      : function_(function) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(a1, a2, a3, a4);
-    } else {
-      (*function_)(a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_0_4<true, R, A1, A2, A3, A4>::base*
-NewTessCallback(R (*function)(A1, A2, A3, A4)) {
-  return new _TessFunctionResultCallback_0_4<true, R, A1, A2, A3, A4>(function);
-}
-
-template <class R, class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_0_4<false, R, A1, A2, A3, A4>::base*
-NewPermanentTessCallback(R (*function)(A1, A2, A3, A4)) {
-  return new _TessFunctionResultCallback_0_4<false, R, A1, A2, A3, A4>(
-      function);
-}
-
-template <bool del, class R, class T, class P1, class A1, class A2, class A3,
-          class A4>
-class _ConstTessMemberResultCallback_1_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _ConstTessMemberResultCallback_1_4(const T* object,
-                                            MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _ConstTessMemberResultCallback_1_4(const T* object,
-                                            MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4>
-inline typename _ConstTessMemberResultCallback_1_4<true, R, T1, P1, A1, A2, A3,
-                                                   A4>::base*
-NewTessCallback(const T1* obj, R (T2::*member)(P1, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1) {
-  return new _ConstTessMemberResultCallback_1_4<true, R, T1, P1, A1, A2, A3,
-                                                A4>(obj, member, p1);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4>
-inline typename _ConstTessMemberResultCallback_1_4<false, R, T1, P1, A1, A2, A3,
-                                                   A4>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, A1, A2, A3, A4) const,
-                         typename Identity<P1>::type p1) {
-  return new _ConstTessMemberResultCallback_1_4<false, R, T1, P1, A1, A2, A3,
-                                                A4>(obj, member, p1);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class A1, class A2, class A3,
-          class A4>
-class _TessMemberResultCallback_1_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessMemberResultCallback_1_4(T* object, MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessMemberResultCallback_1_4(T* object, MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4>
-inline typename _TessMemberResultCallback_1_4<true, R, T1, P1, A1, A2, A3,
-                                              A4>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, A1, A2, A3, A4),
-                typename Identity<P1>::type p1) {
-  return new _TessMemberResultCallback_1_4<true, R, T1, P1, A1, A2, A3, A4>(
-      obj, member, p1);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4>
-inline typename _TessMemberResultCallback_1_4<false, R, T1, P1, A1, A2, A3,
-                                              A4>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1) {
-  return new _TessMemberResultCallback_1_4<false, R, T1, P1, A1, A2, A3, A4>(
-      obj, member, p1);
-}
-#endif
-
-template <bool del, class R, class P1, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_1_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
-      : function_(function), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_1_4<del, void, P1, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
-      : function_(function), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class A1, class A2, class A3, class A4>
-inline
-    typename _TessFunctionResultCallback_1_4<true, R, P1, A1, A2, A3, A4>::base*
-    NewTessCallback(R (*function)(P1, A1, A2, A3, A4),
-                    typename Identity<P1>::type p1) {
-  return new _TessFunctionResultCallback_1_4<true, R, P1, A1, A2, A3, A4>(
-      function, p1);
-}
-
-template <class R, class P1, class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_1_4<false, R, P1, A1, A2, A3,
-                                                A4>::base*
-NewPermanentTessCallback(R (*function)(P1, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1) {
-  return new _TessFunctionResultCallback_1_4<false, R, P1, A1, A2, A3, A4>(
-      function, p1);
-}
-
-template <bool del, class R, class T, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-class _ConstTessMemberResultCallback_2_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _ConstTessMemberResultCallback_2_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class A1, class A2, class A3,
-          class A4>
-class _ConstTessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _ConstTessMemberResultCallback_2_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-inline typename _ConstTessMemberResultCallback_2_4<true, R, T1, P1, P2, A1, A2,
-                                                   A3, A4>::base*
-NewTessCallback(const T1* obj, R (T2::*member)(P1, P2, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _ConstTessMemberResultCallback_2_4<true, R, T1, P1, P2, A1, A2, A3,
-                                                A4>(obj, member, p1, p2);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-inline typename _ConstTessMemberResultCallback_2_4<false, R, T1, P1, P2, A1, A2,
-                                                   A3, A4>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, P2, A1, A2, A3, A4) const,
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _ConstTessMemberResultCallback_2_4<false, R, T1, P1, P2, A1, A2,
-                                                A3, A4>(obj, member, p1, p2);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-class _TessMemberResultCallback_2_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessMemberResultCallback_2_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class A1, class A2, class A3,
-          class A4>
-class _TessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessMemberResultCallback_2_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-inline typename _TessMemberResultCallback_2_4<true, R, T1, P1, P2, A1, A2, A3,
-                                              A4>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, A1, A2, A3, A4),
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _TessMemberResultCallback_2_4<true, R, T1, P1, P2, A1, A2, A3, A4>(
-      obj, member, p1, p2);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4>
-inline typename _TessMemberResultCallback_2_4<false, R, T1, P1, P2, A1, A2, A3,
-                                              A4>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, P2, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _TessMemberResultCallback_2_4<false, R, T1, P1, P2, A1, A2, A3,
-                                           A4>(obj, member, p1, p2);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class A1, class A2, class A3,
-          class A4>
-class _TessFunctionResultCallback_2_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, P2, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1,
-                                         P2 p2)
-      : function_(function), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_2_4<del, void, P1, P2, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, P2, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1,
-                                         P2 p2)
-      : function_(function), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, p2_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, p2_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_2_4<true, R, P1, P2, A1, A2, A3,
-                                                A4>::base*
-NewTessCallback(R (*function)(P1, P2, A1, A2, A3, A4),
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _TessFunctionResultCallback_2_4<true, R, P1, P2, A1, A2, A3, A4>(
-      function, p1, p2);
-}
-
-template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_2_4<false, R, P1, P2, A1, A2, A3,
-                                                A4>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _TessFunctionResultCallback_2_4<false, R, P1, P2, A1, A2, A3, A4>(
-      function, p1, p2);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_3_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _ConstTessMemberResultCallback_3_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4>
-class _ConstTessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3,
-                                         A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _ConstTessMemberResultCallback_3_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_3_4<true, R, T1, P1, P2, P3, A1,
-                                                   A2, A3, A4>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _ConstTessMemberResultCallback_3_4<true, R, T1, P1, P2, P3, A1, A2,
-                                                A3, A4>(obj, member, p1, p2,
-                                                        p3);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_3_4<false, R, T1, P1, P2, P3, A1,
-                                                   A2, A3, A4>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, P2, P3, A1, A2, A3, A4) const,
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _ConstTessMemberResultCallback_3_4<false, R, T1, P1, P2, P3, A1,
-                                                A2, A3, A4>(obj, member, p1, p2,
-                                                            p3);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-class _TessMemberResultCallback_3_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessMemberResultCallback_3_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4>
-class _TessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessMemberResultCallback_3_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_3_4<true, R, T1, P1, P2, P3, A1, A2,
-                                              A3, A4>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _TessMemberResultCallback_3_4<true, R, T1, P1, P2, P3, A1, A2, A3,
-                                           A4>(obj, member, p1, p2, p3);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_3_4<false, R, T1, P1, P2, P3, A1, A2,
-                                              A3, A4>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _TessMemberResultCallback_3_4<false, R, T1, P1, P2, P3, A1, A2, A3,
-                                           A4>(obj, member, p1, p2, p3);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4>
-class _TessFunctionResultCallback_3_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, P2, P3, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4>
-class _TessFunctionResultCallback_3_4<del, void, P1, P2, P3, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, P2, P3, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, p2_, p3_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4>
-inline typename _TessFunctionResultCallback_3_4<true, R, P1, P2, P3, A1, A2, A3,
-                                                A4>::base*
-NewTessCallback(R (*function)(P1, P2, P3, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _TessFunctionResultCallback_3_4<true, R, P1, P2, P3, A1, A2, A3,
-                                             A4>(function, p1, p2, p3);
-}
-
-template <class R, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4>
-inline typename _TessFunctionResultCallback_3_4<false, R, P1, P2, P3, A1, A2,
-                                                A3, A4>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _TessFunctionResultCallback_3_4<false, R, P1, P2, P3, A1, A2, A3,
-                                             A4>(function, p1, p2, p3);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_4_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _ConstTessMemberResultCallback_4_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2,
-                                         A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _ConstTessMemberResultCallback_4_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_4_4<true, R, T1, P1, P2, P3, P4,
-                                                   A1, A2, A3, A4>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _ConstTessMemberResultCallback_4_4<true, R, T1, P1, P2, P3, P4, A1,
-                                                A2, A3, A4>(obj, member, p1, p2,
-                                                            p3, p4);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_4_4<false, R, T1, P1, P2, P3, P4,
-                                                   A1, A2, A3, A4>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4) const,
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4) {
-  return new _ConstTessMemberResultCallback_4_4<false, R, T1, P1, P2, P3, P4,
-                                                A1, A2, A3, A4>(obj, member, p1,
-                                                                p2, p3, p4);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_4_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessMemberResultCallback_4_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4>
-class _TessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2, A3,
-                                    A4> : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessMemberResultCallback_4_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_4_4<true, R, T1, P1, P2, P3, P4, A1,
-                                              A2, A3, A4>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _TessMemberResultCallback_4_4<true, R, T1, P1, P2, P3, P4, A1, A2,
-                                           A3, A4>(obj, member, p1, p2, p3, p4);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_4_4<false, R, T1, P1, P2, P3, P4, A1,
-                                              A2, A3, A4>::base*
-NewPermanentTessCallback(T1* obj,
-                         R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4) {
-  return new _TessMemberResultCallback_4_4<false, R, T1, P1, P2, P3, P4, A1, A2,
-                                           A3, A4>(obj, member, p1, p2, p3, p4);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4>
-class _TessFunctionResultCallback_4_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4>
-class _TessFunctionResultCallback_4_4<del, void, P1, P2, P3, P4, A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4>
-inline typename _TessFunctionResultCallback_4_4<true, R, P1, P2, P3, P4, A1, A2,
-                                                A3, A4>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _TessFunctionResultCallback_4_4<true, R, P1, P2, P3, P4, A1, A2,
-                                             A3, A4>(function, p1, p2, p3, p4);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4>
-inline typename _TessFunctionResultCallback_4_4<false, R, P1, P2, P3, P4, A1,
-                                                A2, A3, A4>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, P4, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4) {
-  return new _TessFunctionResultCallback_4_4<false, R, P1, P2, P3, P4, A1, A2,
-                                             A3, A4>(function, p1, p2, p3, p4);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_5_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _ConstTessMemberResultCallback_5_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1,
-                                         A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _ConstTessMemberResultCallback_5_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_5_4<true, R, T1, P1, P2, P3, P4,
-                                                   P5, A1, A2, A3, A4>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _ConstTessMemberResultCallback_5_4<true, R, T1, P1, P2, P3, P4, P5,
-                                                A1, A2, A3, A4>(obj, member, p1,
-                                                                p2, p3, p4, p5);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_5_4<false, R, T1, P1, P2, P3, P4,
-                                                   P5, A1, A2, A3, A4>::base*
-NewPermanentTessCallback(
-    const T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const,
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5) {
-  return new _ConstTessMemberResultCallback_5_4<false, R, T1, P1, P2, P3, P4,
-                                                P5, A1, A2, A3, A4>(
-      obj, member, p1, p2, p3, p4, p5);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_5_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessMemberResultCallback_5_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1, A2,
-                                    A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessMemberResultCallback_5_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_5_4<true, R, T1, P1, P2, P3, P4, P5,
-                                              A1, A2, A3, A4>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _TessMemberResultCallback_5_4<true, R, T1, P1, P2, P3, P4, P5, A1,
-                                           A2, A3, A4>(obj, member, p1, p2, p3,
-                                                       p4, p5);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_5_4<false, R, T1, P1, P2, P3, P4, P5,
-                                              A1, A2, A3, A4>::base*
-NewPermanentTessCallback(T1* obj,
-                         R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4,
-                         typename Identity<P5>::type p5) {
-  return new _TessMemberResultCallback_5_4<false, R, T1, P1, P2, P3, P4, P5, A1,
-                                           A2, A3, A4>(obj, member, p1, p2, p3,
-                                                       p4, p5);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_5_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, P5, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4>
-class _TessFunctionResultCallback_5_4<del, void, P1, P2, P3, P4, P5, A1, A2, A3,
-                                      A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, P5, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_5_4<true, R, P1, P2, P3, P4, P5, A1,
-                                                A2, A3, A4>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _TessFunctionResultCallback_5_4<true, R, P1, P2, P3, P4, P5, A1,
-                                             A2, A3, A4>(function, p1, p2, p3,
-                                                         p4, p5);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_5_4<false, R, P1, P2, P3, P4, P5,
-                                                A1, A2, A3, A4>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4,
-                         typename Identity<P5>::type p5) {
-  return new _TessFunctionResultCallback_5_4<false, R, P1, P2, P3, P4, P5, A1,
-                                             A2, A3, A4>(function, p1, p2, p3,
-                                                         p4, p5);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_6_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3,
-                                   A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _ConstTessMemberResultCallback_6_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      return result;
-    }
-    R result =
-        (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4>
-class _ConstTessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6,
-                                         A1, A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3,
-                                      A4) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _ConstTessMemberResultCallback_6_4(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-inline typename _ConstTessMemberResultCallback_6_4<
-    true, R, T1, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5,
-                typename Identity<P6>::type p6) {
-  return new _ConstTessMemberResultCallback_6_4<true, R, T1, P1, P2, P3, P4, P5,
-                                                P6, A1, A2, A3, A4>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-inline
-    typename _ConstTessMemberResultCallback_6_4<false, R, T1, P1, P2, P3, P4,
-                                                P5, P6, A1, A2, A3, A4>::base*
-    NewPermanentTessCallback(
-        const T1* obj,
-        R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const,
-        typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-        typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-        typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _ConstTessMemberResultCallback_6_4<false, R, T1, P1, P2, P3, P4,
-                                                P5, P6, A1, A2, A3, A4>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_6_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessMemberResultCallback_6_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      return result;
-    }
-    R result =
-        (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4>
-class _TessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6, A1,
-                                    A2, A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessMemberResultCallback_6_4(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_6_4<true, R, T1, P1, P2, P3, P4, P5,
-                                              P6, A1, A2, A3, A4>::base*
-NewTessCallback(T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5,
-                typename Identity<P6>::type p6) {
-  return new _TessMemberResultCallback_6_4<true, R, T1, P1, P2, P3, P4, P5, P6,
-                                           A1, A2, A3, A4>(obj, member, p1, p2,
-                                                           p3, p4, p5, p6);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4>
-inline typename _TessMemberResultCallback_6_4<false, R, T1, P1, P2, P3, P4, P5,
-                                              P6, A1, A2, A3, A4>::base*
-NewPermanentTessCallback(
-    T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4),
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _TessMemberResultCallback_6_4<false, R, T1, P1, P2, P3, P4, P5, P6,
-                                           A1, A2, A3, A4>(obj, member, p1, p2,
-                                                           p3, p4, p5, p6);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_6_4
-    : public TessResultCallback4<R, A1, A2, A3, A4> {
- public:
-  typedef TessResultCallback4<R, A1, A2, A3, A4> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : function_(function),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4>
-class _TessFunctionResultCallback_6_4<del, void, P1, P2, P3, P4, P5, P6, A1, A2,
-                                      A3, A4>
-    : public TessCallback4<A1, A2, A3, A4> {
- public:
-  typedef TessCallback4<A1, A2, A3, A4> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : function_(function),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_6_4<true, R, P1, P2, P3, P4, P5, P6,
-                                                A1, A2, A3, A4>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5,
-                typename Identity<P6>::type p6) {
-  return new _TessFunctionResultCallback_6_4<true, R, P1, P2, P3, P4, P5, P6,
-                                             A1, A2, A3, A4>(function, p1, p2,
-                                                             p3, p4, p5, p6);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4>
-inline typename _TessFunctionResultCallback_6_4<false, R, P1, P2, P3, P4, P5,
-                                                P6, A1, A2, A3, A4>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4,
-                         typename Identity<P5>::type p5,
-                         typename Identity<P6>::type p6) {
-  return new _TessFunctionResultCallback_6_4<false, R, P1, P2, P3, P4, P5, P6,
-                                             A1, A2, A3, A4>(function, p1, p2,
-                                                             p3, p4, p5, p6);
-}
-
-template <class A1, class A2, class A3, class A4, class A5>
-class TessCallback5 {
- public:
-  virtual ~TessCallback5() = default;
-  virtual void Run(A1, A2, A3, A4, A5) = 0;
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-class TessResultCallback5 {
- public:
-  virtual ~TessResultCallback5() = default;
-  virtual R Run(A1, A2, A3, A4, A5) = 0;
-};
-
-template <bool del, class R, class T, class A1, class A2, class A3, class A4,
-          class A5>
-class _ConstTessMemberResultCallback_0_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-
- public:
-  inline _ConstTessMemberResultCallback_0_5(const T* object,
-                                            MemberSignature member)
-      : object_(object), member_(member) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-
- public:
-  inline _ConstTessMemberResultCallback_0_5(const T* object,
-                                            MemberSignature member)
-      : object_(object), member_(member) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _ConstTessMemberResultCallback_0_5<true, R, T1, A1, A2, A3, A4,
-                                                   A5>::base*
-NewTessCallback(const T1* obj, R (T2::*member)(A1, A2, A3, A4, A5) const) {
-  return new _ConstTessMemberResultCallback_0_5<true, R, T1, A1, A2, A3, A4,
-                                                A5>(obj, member);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _ConstTessMemberResultCallback_0_5<false, R, T1, A1, A2, A3, A4,
-                                                   A5>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(A1, A2, A3, A4, A5) const) {
-  return new _ConstTessMemberResultCallback_0_5<false, R, T1, A1, A2, A3, A4,
-                                                A5>(obj, member);
-}
-#endif
-
-template <bool del, class R, class T, class A1, class A2, class A3, class A4,
-          class A5>
-class _TessMemberResultCallback_0_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-
- public:
-  inline _TessMemberResultCallback_0_5(T* object, MemberSignature member)
-      : object_(object), member_(member) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-
- public:
-  inline _TessMemberResultCallback_0_5(T* object, MemberSignature member)
-      : object_(object), member_(member) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _TessMemberResultCallback_0_5<true, R, T1, A1, A2, A3, A4,
-                                              A5>::base*
-NewTessCallback(T1* obj, R (T2::*member)(A1, A2, A3, A4, A5)) {
-  return new _TessMemberResultCallback_0_5<true, R, T1, A1, A2, A3, A4, A5>(
-      obj, member);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _TessMemberResultCallback_0_5<false, R, T1, A1, A2, A3, A4,
-                                              A5>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(A1, A2, A3, A4, A5)) {
-  return new _TessMemberResultCallback_0_5<false, R, T1, A1, A2, A3, A4, A5>(
-      obj, member);
-}
-#endif
-
-template <bool del, class R, class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_0_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-
- public:
-  inline explicit _TessFunctionResultCallback_0_5(FunctionSignature function)
-      : function_(function) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_0_5<del, void, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-
- public:
-  inline explicit _TessFunctionResultCallback_0_5(FunctionSignature function)
-      : function_(function) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-inline
-    typename _TessFunctionResultCallback_0_5<true, R, A1, A2, A3, A4, A5>::base*
-    NewTessCallback(R (*function)(A1, A2, A3, A4, A5)) {
-  return new _TessFunctionResultCallback_0_5<true, R, A1, A2, A3, A4, A5>(
-      function);
-}
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_0_5<false, R, A1, A2, A3, A4,
-                                                A5>::base*
-NewPermanentTessCallback(R (*function)(A1, A2, A3, A4, A5)) {
-  return new _TessFunctionResultCallback_0_5<false, R, A1, A2, A3, A4, A5>(
-      function);
-}
-
-template <bool del, class R, class T, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-class _ConstTessMemberResultCallback_1_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _ConstTessMemberResultCallback_1_5(const T* object,
-                                            MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class A1, class A2, class A3, class A4,
-          class A5>
-class _ConstTessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _ConstTessMemberResultCallback_1_5(const T* object,
-                                            MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _ConstTessMemberResultCallback_1_5<true, R, T1, P1, A1, A2, A3,
-                                                   A4, A5>::base*
-NewTessCallback(const T1* obj, R (T2::*member)(P1, A1, A2, A3, A4, A5) const,
-                typename Identity<P1>::type p1) {
-  return new _ConstTessMemberResultCallback_1_5<true, R, T1, P1, A1, A2, A3, A4,
-                                                A5>(obj, member, p1);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _ConstTessMemberResultCallback_1_5<false, R, T1, P1, A1, A2, A3,
-                                                   A4, A5>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, A1, A2, A3, A4, A5) const,
-                         typename Identity<P1>::type p1) {
-  return new _ConstTessMemberResultCallback_1_5<false, R, T1, P1, A1, A2, A3,
-                                                A4, A5>(obj, member, p1);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-class _TessMemberResultCallback_1_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessMemberResultCallback_1_5(T* object, MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class A1, class A2, class A3, class A4,
-          class A5>
-class _TessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessMemberResultCallback_1_5(T* object, MemberSignature member, P1 p1)
-      : object_(object), member_(member), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _TessMemberResultCallback_1_5<true, R, T1, P1, A1, A2, A3, A4,
-                                              A5>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1) {
-  return new _TessMemberResultCallback_1_5<true, R, T1, P1, A1, A2, A3, A4, A5>(
-      obj, member, p1);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _TessMemberResultCallback_1_5<false, R, T1, P1, A1, A2, A3, A4,
-                                              A5>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1) {
-  return new _TessMemberResultCallback_1_5<false, R, T1, P1, A1, A2, A3, A4,
-                                           A5>(obj, member, p1);
-}
-#endif
-
-template <bool del, class R, class P1, class A1, class A2, class A3, class A4,
-          class A5>
-class _TessFunctionResultCallback_1_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
-      : function_(function), p1_(p1) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_1_5<del, void, P1, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-
- public:
-  inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
-      : function_(function), p1_(p1) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_1_5<true, R, P1, A1, A2, A3, A4,
-                                                A5>::base*
-NewTessCallback(R (*function)(P1, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1) {
-  return new _TessFunctionResultCallback_1_5<true, R, P1, A1, A2, A3, A4, A5>(
-      function, p1);
-}
-
-template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_1_5<false, R, P1, A1, A2, A3, A4,
-                                                A5>::base*
-NewPermanentTessCallback(R (*function)(P1, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1) {
-  return new _TessFunctionResultCallback_1_5<false, R, P1, A1, A2, A3, A4, A5>(
-      function, p1);
-}
-
-template <bool del, class R, class T, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_2_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _ConstTessMemberResultCallback_2_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class A1, class A2, class A3,
-          class A4, class A5>
-class _ConstTessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4,
-                                         A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _ConstTessMemberResultCallback_2_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_2_5<true, R, T1, P1, P2, A1, A2,
-                                                   A3, A4, A5>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, A1, A2, A3, A4, A5) const,
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _ConstTessMemberResultCallback_2_5<true, R, T1, P1, P2, A1, A2, A3,
-                                                A4, A5>(obj, member, p1, p2);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_2_5<false, R, T1, P1, P2, A1, A2,
-                                                   A3, A4, A5>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, P2, A1, A2, A3, A4, A5) const,
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _ConstTessMemberResultCallback_2_5<false, R, T1, P1, P2, A1, A2,
-                                                A3, A4, A5>(obj, member, p1,
-                                                            p2);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-class _TessMemberResultCallback_2_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessMemberResultCallback_2_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class A1, class A2, class A3,
-          class A4, class A5>
-class _TessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessMemberResultCallback_2_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2)
-      : object_(object), member_(member), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_2_5<true, R, T1, P1, P2, A1, A2, A3,
-                                              A4, A5>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _TessMemberResultCallback_2_5<true, R, T1, P1, P2, A1, A2, A3, A4,
-                                           A5>(obj, member, p1, p2);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_2_5<false, R, T1, P1, P2, A1, A2, A3,
-                                              A4, A5>::base*
-NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, P2, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _TessMemberResultCallback_2_5<false, R, T1, P1, P2, A1, A2, A3, A4,
-                                           A5>(obj, member, p1, p2);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class A1, class A2, class A3,
-          class A4, class A5>
-class _TessFunctionResultCallback_2_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, P2, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1,
-                                         P2 p2)
-      : function_(function), p1_(p1), p2_(p2) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class A1, class A2, class A3, class A4,
-          class A5>
-class _TessFunctionResultCallback_2_5<del, void, P1, P2, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, P2, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-
- public:
-  inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1,
-                                         P2 p2)
-      : function_(function), p1_(p1), p2_(p2) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, p2_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, p2_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _TessFunctionResultCallback_2_5<true, R, P1, P2, A1, A2, A3, A4,
-                                                A5>::base*
-NewTessCallback(R (*function)(P1, P2, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1,
-                typename Identity<P2>::type p2) {
-  return new _TessFunctionResultCallback_2_5<true, R, P1, P2, A1, A2, A3, A4,
-                                             A5>(function, p1, p2);
-}
-
-template <class R, class P1, class P2, class A1, class A2, class A3, class A4,
-          class A5>
-inline typename _TessFunctionResultCallback_2_5<false, R, P1, P2, A1, A2, A3,
-                                                A4, A5>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2) {
-  return new _TessFunctionResultCallback_2_5<false, R, P1, P2, A1, A2, A3, A4,
-                                             A5>(function, p1, p2);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_3_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _ConstTessMemberResultCallback_3_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3,
-                                         A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _ConstTessMemberResultCallback_3_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_3_5<true, R, T1, P1, P2, P3, A1,
-                                                   A2, A3, A4, A5>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _ConstTessMemberResultCallback_3_5<true, R, T1, P1, P2, P3, A1, A2,
-                                                A3, A4, A5>(obj, member, p1, p2,
-                                                            p3);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_3_5<false, R, T1, P1, P2, P3, A1,
-                                                   A2, A3, A4, A5>::base*
-NewPermanentTessCallback(const T1* obj,
-                         R (T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5) const,
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _ConstTessMemberResultCallback_3_5<false, R, T1, P1, P2, P3, A1,
-                                                A2, A3, A4, A5>(obj, member, p1,
-                                                                p2, p3);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_3_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessMemberResultCallback_3_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4, class A5>
-class _TessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3, A4,
-                                    A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessMemberResultCallback_3_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_3_5<true, R, T1, P1, P2, P3, A1, A2,
-                                              A3, A4, A5>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _TessMemberResultCallback_3_5<true, R, T1, P1, P2, P3, A1, A2, A3,
-                                           A4, A5>(obj, member, p1, p2, p3);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_3_5<false, R, T1, P1, P2, P3, A1, A2,
-                                              A3, A4, A5>::base*
-NewPermanentTessCallback(T1* obj,
-                         R (T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _TessMemberResultCallback_3_5<false, R, T1, P1, P2, P3, A1, A2, A3,
-                                           A4, A5>(obj, member, p1, p2, p3);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class A1, class A2,
-          class A3, class A4, class A5>
-class _TessFunctionResultCallback_3_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, P2, P3, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4, class A5>
-class _TessFunctionResultCallback_3_5<del, void, P1, P2, P3, A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, P2, P3, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-
- public:
-  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, p2_, p3_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _TessFunctionResultCallback_3_5<true, R, P1, P2, P3, A1, A2, A3,
-                                                A4, A5>::base*
-NewTessCallback(R (*function)(P1, P2, P3, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3) {
-  return new _TessFunctionResultCallback_3_5<true, R, P1, P2, P3, A1, A2, A3,
-                                             A4, A5>(function, p1, p2, p3);
-}
-
-template <class R, class P1, class P2, class P3, class A1, class A2, class A3,
-          class A4, class A5>
-inline typename _TessFunctionResultCallback_3_5<false, R, P1, P2, P3, A1, A2,
-                                                A3, A4, A5>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3) {
-  return new _TessFunctionResultCallback_3_5<false, R, P1, P2, P3, A1, A2, A3,
-                                             A4, A5>(function, p1, p2, p3);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_4_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _ConstTessMemberResultCallback_4_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2,
-                                         A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _ConstTessMemberResultCallback_4_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_4_5<true, R, T1, P1, P2, P3, P4,
-                                                   A1, A2, A3, A4, A5>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _ConstTessMemberResultCallback_4_5<true, R, T1, P1, P2, P3, P4, A1,
-                                                A2, A3, A4, A5>(obj, member, p1,
-                                                                p2, p3, p4);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_4_5<false, R, T1, P1, P2, P3, P4,
-                                                   A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(
-    const T1* obj, R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const,
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
-  return new _ConstTessMemberResultCallback_4_5<false, R, T1, P1, P2, P3, P4,
-                                                A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_4_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessMemberResultCallback_4_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2, A3,
-                                    A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessMemberResultCallback_4_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4)
-      : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_4_5<true, R, T1, P1, P2, P3, P4, A1,
-                                              A2, A3, A4, A5>::base*
-NewTessCallback(T1* obj, R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _TessMemberResultCallback_4_5<true, R, T1, P1, P2, P3, P4, A1, A2,
-                                           A3, A4, A5>(obj, member, p1, p2, p3,
-                                                       p4);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_4_5<false, R, T1, P1, P2, P3, P4, A1,
-                                              A2, A3, A4, A5>::base*
-NewPermanentTessCallback(T1* obj,
-                         R (T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4) {
-  return new _TessMemberResultCallback_4_5<false, R, T1, P1, P2, P3, P4, A1, A2,
-                                           A3, A4, A5>(obj, member, p1, p2, p3,
-                                                       p4);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class A1,
-          class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_4_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4, class A5>
-class _TessFunctionResultCallback_4_5<del, void, P1, P2, P3, P4, A1, A2, A3, A4,
-                                      A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-
- public:
-  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_4_5<true, R, P1, P2, P3, P4, A1, A2,
-                                                A3, A4, A5>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3,
-                typename Identity<P4>::type p4) {
-  return new _TessFunctionResultCallback_4_5<true, R, P1, P2, P3, P4, A1, A2,
-                                             A3, A4, A5>(function, p1, p2, p3,
-                                                         p4);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class A1, class A2,
-          class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_4_5<false, R, P1, P2, P3, P4, A1,
-                                                A2, A3, A4, A5>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, P4, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4) {
-  return new _TessFunctionResultCallback_4_5<false, R, P1, P2, P3, P4, A1, A2,
-                                             A3, A4, A5>(function, p1, p2, p3,
-                                                         p4);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_5_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4,
-                                   A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _ConstTessMemberResultCallback_5_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1,
-                                         A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4,
-                                      A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _ConstTessMemberResultCallback_5_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_5_5<
-    true, R, T1, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5>::base*
-NewTessCallback(const T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const,
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _ConstTessMemberResultCallback_5_5<true, R, T1, P1, P2, P3, P4, P5,
-                                                A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-inline
-    typename _ConstTessMemberResultCallback_5_5<false, R, T1, P1, P2, P3, P4,
-                                                P5, A1, A2, A3, A4, A5>::base*
-    NewPermanentTessCallback(
-        const T1* obj,
-        R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const,
-        typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-        typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-        typename Identity<P5>::type p5) {
-  return new _ConstTessMemberResultCallback_5_5<false, R, T1, P1, P2, P3, P4,
-                                                P5, A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_5_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessMemberResultCallback_5_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1, A2,
-                                    A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessMemberResultCallback_5_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_5_5<true, R, T1, P1, P2, P3, P4, P5,
-                                              A1, A2, A3, A4, A5>::base*
-NewTessCallback(T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _TessMemberResultCallback_5_5<true, R, T1, P1, P2, P3, P4, P5, A1,
-                                           A2, A3, A4, A5>(obj, member, p1, p2,
-                                                           p3, p4, p5);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_5_5<false, R, T1, P1, P2, P3, P4, P5,
-                                              A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(
-    T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5),
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5) {
-  return new _TessMemberResultCallback_5_5<false, R, T1, P1, P2, P3, P4, P5, A1,
-                                           A2, A3, A4, A5>(obj, member, p1, p2,
-                                                           p3, p4, p5);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class P5,
-          class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_5_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_5_5<del, void, P1, P2, P3, P4, P5, A1, A2, A3,
-                                      A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-
- public:
-  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5)
-      : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_5_5<true, R, P1, P2, P3, P4, P5, A1,
-                                                A2, A3, A4, A5>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5) {
-  return new _TessFunctionResultCallback_5_5<true, R, P1, P2, P3, P4, P5, A1,
-                                             A2, A3, A4, A5>(function, p1, p2,
-                                                             p3, p4, p5);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class A1,
-          class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_5_5<false, R, P1, P2, P3, P4, P5,
-                                                A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(R (*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5),
-                         typename Identity<P1>::type p1,
-                         typename Identity<P2>::type p2,
-                         typename Identity<P3>::type p3,
-                         typename Identity<P4>::type p4,
-                         typename Identity<P5>::type p5) {
-  return new _TessFunctionResultCallback_5_5<false, R, P1, P2, P3, P4, P5, A1,
-                                             A2, A3, A4, A5>(function, p1, p2,
-                                                             p3, p4, p5);
-}
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_6_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4,
-                                   A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _ConstTessMemberResultCallback_6_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result =
-        (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4, class A5>
-class _ConstTessMemberResultCallback_6_5<del, void, T, P1, P2, P3, P4, P5, P6,
-                                         A1, A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4,
-                                      A5) const;
-
- private:
-  const T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _ConstTessMemberResultCallback_6_5(const T* object,
-                                            MemberSignature member, P1 p1,
-                                            P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-inline
-    typename _ConstTessMemberResultCallback_6_5<true, R, T1, P1, P2, P3, P4, P5,
-                                                P6, A1, A2, A3, A4, A5>::base*
-    NewTessCallback(
-        const T1* obj,
-        R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const,
-        typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-        typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-        typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _ConstTessMemberResultCallback_6_5<true, R, T1, P1, P2, P3, P4, P5,
-                                                P6, A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-inline typename _ConstTessMemberResultCallback_6_5<
-    false, R, T1, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(
-    const T1* obj,
-    R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const,
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _ConstTessMemberResultCallback_6_5<false, R, T1, P1, P2, P3, P4,
-                                                P5, P6, A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-template <bool del, class R, class T, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_6_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessMemberResultCallback_6_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result =
-          (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result =
-        (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    member_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4, class A5>
-class _TessMemberResultCallback_6_5<del, void, T, P1, P2, P3, P4, P5, P6, A1,
-                                    A2, A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4,
-                                      A5);
-
- private:
-  T* object_;
-  MemberSignature member_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessMemberResultCallback_6_5(T* object, MemberSignature member, P1 p1,
-                                       P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        member_(member),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    } else {
-      (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      member_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_6_5<true, R, T1, P1, P2, P3, P4, P5,
-                                              P6, A1, A2, A3, A4, A5>::base*
-NewTessCallback(T1* obj,
-                R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5,
-                typename Identity<P6>::type p6) {
-  return new _TessMemberResultCallback_6_5<true, R, T1, P1, P2, P3, P4, P5, P6,
-                                           A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-#ifndef SWIG
-template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
-          class P5, class P6, class A1, class A2, class A3, class A4, class A5>
-inline typename _TessMemberResultCallback_6_5<false, R, T1, P1, P2, P3, P4, P5,
-                                              P6, A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(
-    T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5),
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _TessMemberResultCallback_6_5<false, R, T1, P1, P2, P3, P4, P5, P6,
-                                           A1, A2, A3, A4, A5>(
-      obj, member, p1, p2, p3, p4, p5, p6);
-}
-#endif
-
-template <bool del, class R, class P1, class P2, class P3, class P4, class P5,
-          class P6, class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_6_5
-    : public TessResultCallback5<R, A1, A2, A3, A4, A5> {
- public:
-  typedef TessResultCallback5<R, A1, A2, A3, A4, A5> base;
-  using FunctionSignature = R (*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : function_(function),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      R result = (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      return result;
-    }
-    R result = (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    //  zero out the pointer to ensure segfault if used again
-    function_ = nullptr;
-    delete this;
-    return result;
-  }
-};
-
-template <bool del, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4, class A5>
-class _TessFunctionResultCallback_6_5<del, void, P1, P2, P3, P4, P5, P6, A1, A2,
-                                      A3, A4, A5>
-    : public TessCallback5<A1, A2, A3, A4, A5> {
- public:
-  typedef TessCallback5<A1, A2, A3, A4, A5> base;
-  using FunctionSignature = void (*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4,
-                                     A5);
-
- private:
-  FunctionSignature function_;
-  typename remove_reference<P1>::type p1_;
-  typename remove_reference<P2>::type p2_;
-  typename remove_reference<P3>::type p3_;
-  typename remove_reference<P4>::type p4_;
-  typename remove_reference<P5>::type p5_;
-  typename remove_reference<P6>::type p6_;
-
- public:
-  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1,
-                                         P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : function_(function),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-
-  virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    if (!del) {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-    } else {
-      (*function_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2, a3, a4, a5);
-      //  zero out the pointer to ensure segfault if used again
-      function_ = nullptr;
-      delete this;
-    }
-  }
-};
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_6_5<true, R, P1, P2, P3, P4, P5, P6,
-                                                A1, A2, A3, A4, A5>::base*
-NewTessCallback(R (*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5),
-                typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-                typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-                typename Identity<P5>::type p5,
-                typename Identity<P6>::type p6) {
-  return new _TessFunctionResultCallback_6_5<true, R, P1, P2, P3, P4, P5, P6,
-                                             A1, A2, A3, A4, A5>(
-      function, p1, p2, p3, p4, p5, p6);
-}
-
-template <class R, class P1, class P2, class P3, class P4, class P5, class P6,
-          class A1, class A2, class A3, class A4, class A5>
-inline typename _TessFunctionResultCallback_6_5<false, R, P1, P2, P3, P4, P5,
-                                                P6, A1, A2, A3, A4, A5>::base*
-NewPermanentTessCallback(
-    R (*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5),
-    typename Identity<P1>::type p1, typename Identity<P2>::type p2,
-    typename Identity<P3>::type p3, typename Identity<P4>::type p4,
-    typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
-  return new _TessFunctionResultCallback_6_5<false, R, P1, P2, P3, P4, P5, P6,
-                                             A1, A2, A3, A4, A5>(
-      function, p1, p2, p3, p4, p5, p6);
-}
-
 #endif  // TESS_CALLBACK_SPECIALIZATIONS_H_