From 813e93da96f34a4debe007805bcc8ac94d5511d8 Mon Sep 17 00:00:00 2001
From: Artem Alekseev <artem.alekseev@intel.com>
Date: Wed, 31 Jul 2019 10:42:47 +0300
Subject: [PATCH 1/4] ARROW-1562 initial implementation

---
 cpp/src/arrow/CMakeLists.txt                  |    1 +
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |    4 +-
 cpp/src/arrow/compute/kernels/add-test.cc     |   86 +
 cpp/src/arrow/compute/kernels/add.cc          |  183 +
 cpp/src/arrow/compute/kernels/add.h           |   80 +
 .../generated/arithmetic-codegen-internal.h   | 3796 +++++++++++++++++
 .../compute/kernels/generated/codegen.py      |   44 +-
 cpp/src/arrow/testing/gtest_util.cc           |    5 +
 8 files changed, 4197 insertions(+), 2 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/add-test.cc
 create mode 100644 cpp/src/arrow/compute/kernels/add.cc
 create mode 100644 cpp/src/arrow/compute/kernels/add.h
 create mode 100644 cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 10f067e187b..2a640354147 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -178,6 +178,7 @@ if(ARROW_COMPUTE)
       compute/kernels/hash.cc
       compute/kernels/filter.cc
       compute/kernels/mean.cc
+      compute/kernels/add.cc
       compute/kernels/sum.cc
       compute/kernels/take.cc
       compute/kernels/util-internal.cc
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 3d9da8bcc34..43508f10446 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -20,8 +20,10 @@ arrow_install_all_headers("arrow/compute/kernels")
 add_arrow_test(boolean-test PREFIX "arrow-compute")
 add_arrow_test(cast-test PREFIX "arrow-compute")
 add_arrow_test(hash-test PREFIX "arrow-compute")
-add_arrow_test(util-internal-test PREFIX "arrow-compute")
+add_arrow_test(add-test PREFIX "arrow-compute")
+#add_arrow_benchmark(add-benchmark PREFIX "arrow-compute")
 
+add_arrow_test(util-internal-test PREFIX "arrow-compute")
 # Aggregates
 add_arrow_test(aggregate-test PREFIX "arrow-compute")
 add_arrow_benchmark(aggregate-benchmark PREFIX "arrow-compute")
diff --git a/cpp/src/arrow/compute/kernels/add-test.cc b/cpp/src/arrow/compute/kernels/add-test.cc
new file mode 100644
index 00000000000..1b4428d0b5a
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/add-test.cc
@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/compute/kernel.h"
+#include "arrow/compute/kernels/add.h"
+#include "arrow/compute/test-util.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+
+#include "arrow/testing/gtest_common.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+
+namespace arrow {
+namespace compute {
+
+template <typename ResultType, typename LhsType, typename RhsType>
+class TestAddKernel : public ComputeFixture, public TestBase {
+ private:
+  void AssertAddArrays(const std::shared_ptr<Array> lhs, const std::shared_ptr<Array> rhs,
+                       const std::shared_ptr<Array> expected) {
+    std::shared_ptr<Array> actual;
+    ASSERT_OK(arrow::compute::Add(&this->ctx_, *lhs, *rhs, &actual));
+    ASSERT_OK(ValidateArray(*actual));
+    AssertArraysEqual(*expected, *actual);
+  }
+
+ protected:
+  virtual void AssertAdd(const std::string& lhs, const std::string& rhs,
+                         const std::string& expected) {
+    auto lhs_type = TypeTraits<LhsType>::type_singleton();
+    auto rhs_type = TypeTraits<RhsType>::type_singleton();
+    auto result_type = TypeTraits<ResultType>::type_singleton();
+    AssertAddArrays(ArrayFromJSON(lhs_type, lhs), ArrayFromJSON(rhs_type, rhs),
+                    ArrayFromJSON(result_type, expected));
+  }
+};
+
+#define ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(T1, T2, T3)                                \
+  class TestAddKernel##T1##T2##T3 : public TestAddKernel<T1##Type, T2##Type, T3##Type> { \
+  };                                                                                     \
+  TEST_F(TestAddKernel##T1##T2##T3, TestAdd) {                                           \
+    this->AssertAdd("[2, 5, 1]", "[5, 3, 12]", "[7, 8, 13]");                            \
+  }
+
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, Int32, Int32)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt32, UInt32, UInt32)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, UInt32, Int32)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, Int32, UInt32)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int64, Int64, UInt32)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt64, UInt64, UInt64)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt64, UInt8, UInt64)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int8, UInt8, Int8)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int16, UInt8, Int16)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int16, UInt16, Int8)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt16, UInt8, UInt16)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Double, Double, UInt16)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Double, Float, Double)
+ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Float, Float, UInt16)
+
+}  // namespace compute
+}  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/add.cc b/cpp/src/arrow/compute/kernels/add.cc
new file mode 100644
index 00000000000..5b0e1f8c52d
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/add.cc
@@ -0,0 +1,183 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/compute/kernels/add.h"
+#include "arrow/compute/context.h"
+#include "arrow/compute/kernels/generated/arithmetic-codegen-internal.h"
+
+namespace arrow {
+namespace compute {
+
+size_t GetSize(const std::shared_ptr<DataType>& type);
+
+template <typename TResult, typename TLhs, typename TRhs>
+class AddKernelImpl : public AddKernel {
+ private:
+  std::shared_ptr<DataType> result_type_;
+  using ArrowLhsElementType = typename CTypeTraits<TLhs>::ArrowType;
+  using ArrowRhsElementType = typename CTypeTraits<TRhs>::ArrowType;
+  using ArrowResultElementType = typename CTypeTraits<TResult>::ArrowType;
+  using LhsArray = NumericArray<ArrowLhsElementType>;
+  using RhsArray = NumericArray<ArrowRhsElementType>;
+  using ResultArray = NumericArray<ArrowResultElementType>;
+
+  Status Add(FunctionContext* ctx, const std::shared_ptr<LhsArray>& lhs,
+             const std::shared_ptr<RhsArray>& rhs, std::shared_ptr<Array>* result) {
+    std::shared_ptr<Buffer> buf;
+    size_t size = GetSize(result_type_) / 8;
+    RETURN_NOT_OK(AllocateBuffer(ctx->memory_pool(), lhs->length() * size, &buf));
+    auto res_data = reinterpret_cast<TResult*>(buf->mutable_data());
+    for (int i = 0; i < lhs->length(); i++) {
+      res_data[i] = lhs->Value(i) + rhs->Value(i);
+    }
+    *result = std::make_shared<ResultArray>(lhs->length(), buf);
+    return Status::OK();
+  }
+
+ public:
+  AddKernelImpl(std::shared_ptr<DataType> result_type) : result_type_(result_type) {}
+
+  Status Call(FunctionContext* ctx, const Datum& lhs, const Datum& rhs, Datum* out) {
+    if (!lhs.is_array() || !rhs.is_array()) {
+      return Status::Invalid("AddKernel expects array values");
+    }
+    if (lhs.length() != rhs.length()) {
+      return Status::Invalid("AddKernel expects arrays with the same length");
+    }
+    auto lhs_array = lhs.make_array();
+    auto rhs_array = rhs.make_array();
+    if (lhs_array->null_count() || rhs_array->null_count()) {
+      return Status::Invalid("AddKernel expects arrays without nulls");
+    }
+    std::shared_ptr<Array> result;
+    RETURN_NOT_OK(this->Add(ctx, lhs_array, rhs_array, &result));
+    *out = result;
+    return Status::OK();
+  }
+
+  std::shared_ptr<DataType> out_type() const override { return result_type_; }
+
+  virtual Status Add(FunctionContext* ctx, const std::shared_ptr<Array>& lhs,
+                     const std::shared_ptr<Array>& rhs, std::shared_ptr<Array>* result) {
+    auto lhs_array = std::static_pointer_cast<LhsArray>(lhs);
+    auto rhs_array = std::static_pointer_cast<RhsArray>(rhs);
+    return Add(ctx, lhs_array, rhs_array, result);
+  }
+};
+
+std::shared_ptr<DataType> MakeNumericType(bool sign, bool floating, size_t size) {
+  if (floating) {
+    switch (size) {
+      case 16:
+        return float16();
+      case 32:
+        return float32();
+      case 64:
+        return float64();
+      default:
+        return NULLPTR;
+    }
+  }
+  if (sign) {
+    switch (size) {
+      case 8:
+        return int8();
+      case 16:
+        return int16();
+      case 32:
+        return int32();
+      case 64:
+        return int64();
+      default:
+        return NULLPTR;
+    }
+  }
+
+  switch (size) {
+    case 8:
+      return uint8();
+    case 16:
+      return uint16();
+    case 32:
+      return uint32();
+    case 64:
+      return uint64();
+    default:
+      return NULLPTR;
+  }
+}
+
+bool IsUnsigned(const std::shared_ptr<DataType>& type) {
+  return type->Equals(uint8()) || type->Equals(uint16()) || type->Equals(uint32()) ||
+         type->Equals(uint64());
+}
+
+bool IsSigned(const std::shared_ptr<DataType>& type) {
+  return type->Equals(int8()) || type->Equals(int16()) || type->Equals(int32()) ||
+         type->Equals(int64());
+}
+
+bool IsFloating(const std::shared_ptr<DataType>& type) {
+  return type->Equals(float16()) || type->Equals(float32()) || type->Equals(float64());
+}
+
+size_t GetSize(const std::shared_ptr<DataType>& type) {
+  if (type->Equals(uint8()) || type->Equals(int8())) {
+    return 8;
+  }
+  if (type->Equals(float16()) || type->Equals(int16()) || type->Equals(uint16())) {
+    return 16;
+  }
+  if (type->Equals(float32()) || type->Equals(int32()) || type->Equals(uint32())) {
+    return 32;
+  }
+  if (type->Equals(float64()) || type->Equals(int64()) || type->Equals(uint64())) {
+    return 64;
+  }
+  return 1111;  // any number greater then 64 to make MakeNumericType fail
+}
+
+Status AddKernel::Make(const std::shared_ptr<DataType>& lhs_type,
+                       const std::shared_ptr<DataType>& rhs_type,
+                       std::unique_ptr<AddKernel>* out) {
+  auto result_type = MakeNumericType(IsSigned(lhs_type) || IsSigned(rhs_type),
+                                     IsFloating(lhs_type) || IsFloating(rhs_type),
+                                     std::max(GetSize(lhs_type), GetSize(rhs_type)));
+  if (!result_type) {
+    return Status::TypeError("AddKernel can not infer appropriate type");
+  }
+  AddKernel* kernel;
+  ARITHMETIC_TYPESWITCH(kernel, AddKernelImpl, result_type, lhs_type, rhs_type)
+  if(!kernel) {
+    return Status::TypeError("AddKernel can not infer appropriate type");
+  }
+  out->reset(kernel);
+  return Status::OK();
+}
+
+Status Add(FunctionContext* ctx, const Array& lhs, const Array& rhs,
+           std::shared_ptr<Array>* result) {
+  Datum result_datum;
+  std::unique_ptr<AddKernel> kernel;
+  RETURN_NOT_OK(AddKernel::Make(lhs.type(), rhs.type(), &kernel));
+  kernel->Call(ctx, Datum(lhs.data()), Datum(rhs.data()), &result_datum);
+  *result = result_datum.make_array();
+  return Status::OK();
+}
+
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file
diff --git a/cpp/src/arrow/compute/kernels/add.h b/cpp/src/arrow/compute/kernels/add.h
new file mode 100644
index 00000000000..09588284e5f
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/add.h
@@ -0,0 +1,80 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+
+#include "arrow/compute/kernel.h"
+#include "arrow/status.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+
+class Array;
+
+namespace compute {
+
+class FunctionContext;
+
+/// \brief Summarizes two arrays.
+///
+/// Summarizes two arrays with the same length.
+/// The output is an array with same length as input.
+/// Nulls are prohibited. The type size of result array will be equal
+/// to the max size of lhs and rhs types and will be unsigned if both
+/// lhs and rhs are unsigned.
+///
+/// For example given lhs = [1, 2, 3], rhs = [4, 5, 6], the output
+/// will be [5, 6, 7]
+///
+/// \param[in] ctx the FunctionContext
+/// \param[in] values array to sort
+/// \param[out] offsets indices that would sort an array
+
+ARROW_EXPORT
+Status Add(FunctionContext* ctx, const Array& lhs, const Array& rhs,
+           std::shared_ptr<Array>* result);
+
+/// \brief BinaryKernel implementing Add operation
+class ARROW_EXPORT AddKernel : public BinaryKernel {
+ public:
+  /// \brief BinaryKernel interface
+  ///
+  /// delegates to subclasses via Add()
+  Status Call(FunctionContext* ctx, const Datum& lhs, const Datum& rhs,
+              Datum* out) override = 0;
+
+  /// \brief output type of this kernel
+  std::shared_ptr<DataType> out_type() const override = 0;
+
+  /// \brief single-array implementation
+  virtual Status Add(FunctionContext* ctx, const std::shared_ptr<Array>& lhs,
+                     const std::shared_ptr<Array>& rhs,
+                     std::shared_ptr<Array>* result) = 0;
+
+  /// \brief factory for Add
+  ///
+  /// \param[in] value_type constructed AddKernel
+  /// \param[out] out created kernel
+  static Status Make(const std::shared_ptr<DataType>& lhs_type,
+                     const std::shared_ptr<DataType>& rhs_type,
+                     std::unique_ptr<AddKernel>* out);
+};
+
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file
diff --git a/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h b/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h
new file mode 100644
index 00000000000..5606ecf810e
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h
@@ -0,0 +1,3796 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT
+// Generated by codegen.py script
+#define ARITHMETIC_TYPESWITCH(OUT, TYPE, T1, T2, T3) \
+  switch(T1->id()) { \
+    case Type::INT8: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int8_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int8_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int8_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int8_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int8_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int8_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int8_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int8_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int8_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int8_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::UINT8: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint8_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint8_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint8_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint8_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint8_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint8_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint8_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint8_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint8_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint8_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::INT16: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int16_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int16_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int16_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int16_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int16_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int16_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int16_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int16_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int16_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int16_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::UINT16: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint16_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint16_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint16_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint16_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint16_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint16_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint16_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint16_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint16_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint16_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::INT32: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int32_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int32_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int32_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int32_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int32_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int32_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int32_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int32_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int32_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int32_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::UINT32: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint32_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint32_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint32_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint32_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint32_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint32_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint32_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint32_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint32_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint32_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::INT64: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<int64_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<int64_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<int64_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<int64_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<int64_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<int64_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<int64_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<int64_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<int64_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<int64_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::UINT64: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<uint64_t, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<uint64_t, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<uint64_t, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<uint64_t, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<uint64_t, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<uint64_t, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<uint64_t, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<uint64_t, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<uint64_t, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<uint64_t, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::FLOAT: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<float, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<float, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<float, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<float, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<float, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<float, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<float, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<float, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<float, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<float, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    case Type::DOUBLE: \
+      switch(T2->id()) { \
+        case Type::INT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, int8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, int8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, int8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, int8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, int8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, int8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, int8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, int8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, int8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, int8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT8: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, uint8_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, uint8_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, uint8_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, uint8_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, uint8_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, uint8_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, uint8_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, uint8_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, uint8_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, uint8_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, int16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, int16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, int16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, int16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, int16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, int16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, int16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, int16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, int16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, int16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT16: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, uint16_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, uint16_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, uint16_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, uint16_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, uint16_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, uint16_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, uint16_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, uint16_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, uint16_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, uint16_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, int32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, int32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, int32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, int32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, int32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, int32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, int32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, int32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, int32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, int32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT32: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, uint32_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, uint32_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, uint32_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, uint32_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, uint32_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, uint32_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, uint32_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, uint32_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, uint32_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, uint32_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::INT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, int64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, int64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, int64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, int64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, int64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, int64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, int64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, int64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, int64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, int64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::UINT64: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, uint64_t, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, uint64_t, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, uint64_t, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, uint64_t, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, uint64_t, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, uint64_t, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, uint64_t, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, uint64_t, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, uint64_t, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, uint64_t, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::FLOAT: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, float, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, float, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, float, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, float, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, float, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, float, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, float, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, float, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, float, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, float, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        case Type::DOUBLE: \
+          switch(T3->id()) { \
+            case Type::INT8: \
+              OUT = new TYPE<double, double, int8_t>(T1); \
+              break; \
+            case Type::UINT8: \
+              OUT = new TYPE<double, double, uint8_t>(T1); \
+              break; \
+            case Type::INT16: \
+              OUT = new TYPE<double, double, int16_t>(T1); \
+              break; \
+            case Type::UINT16: \
+              OUT = new TYPE<double, double, uint16_t>(T1); \
+              break; \
+            case Type::INT32: \
+              OUT = new TYPE<double, double, int32_t>(T1); \
+              break; \
+            case Type::UINT32: \
+              OUT = new TYPE<double, double, uint32_t>(T1); \
+              break; \
+            case Type::INT64: \
+              OUT = new TYPE<double, double, int64_t>(T1); \
+              break; \
+            case Type::UINT64: \
+              OUT = new TYPE<double, double, uint64_t>(T1); \
+              break; \
+            case Type::FLOAT: \
+              OUT = new TYPE<double, double, float>(T1); \
+              break; \
+            case Type::DOUBLE: \
+              OUT = new TYPE<double, double, double>(T1); \
+              break; \
+            default: \
+              OUT = NULLPTR; \
+            break; \
+          } \
+          break; \
+        default: \
+          OUT = NULLPTR; \
+        break; \
+      } \
+      break; \
+    default: \
+      OUT = NULLPTR; \
+    break; \
+  } \
+
diff --git a/cpp/src/arrow/compute/kernels/generated/codegen.py b/cpp/src/arrow/compute/kernels/generated/codegen.py
index c9db7eaa0dc..b7e89a8789c 100644
--- a/cpp/src/arrow/compute/kernels/generated/codegen.py
+++ b/cpp/src/arrow/compute/kernels/generated/codegen.py
@@ -31,11 +31,23 @@
 
 DATE_TIME_TYPES = ['Date32', 'Date64', 'Time32', 'Time64', 'Timestamp']
 
+ARITHMETIC_TYPES_MAP = {
+    'INT8': 'int8_t',
+    'UINT8': 'uint8_t',
+    'INT16': 'int16_t',
+    'UINT16': 'uint16_t',
+    'INT32': 'int32_t',
+    'UINT32': 'uint32_t',
+    'INT64': 'int64_t',
+    'UINT64': 'uint64_t',
+    'FLOAT': 'float',
+    'DOUBLE': 'double',
+}
+
 
 def _format_type(name):
     return name + "Type"
 
-
 class CastCodeGenerator(object):
 
     def __init__(self, type_name, out_types, parametric=False,
@@ -100,6 +112,33 @@ def generate_cast_code():
     return '\n'.join(blocks)
 
 
+def generate_arithmetic_code():
+    buf = io.StringIO()
+    print("#define ARITHMETIC_TYPESWITCH(OUT, TYPE, T1, T2, T3) \\", file=buf)
+
+    def generate_kernel_instantiation(tab, typs):
+        print("{0}OUT = new TYPE<{1}>(T1); \\".format("  " * (tab), 
+            ', '.join(typs)), file=buf)
+
+    def generate_type_switch(tab, cur_typ, typs):
+        if(len(typs) == 3):
+            generate_kernel_instantiation(tab+1, typs)
+            return
+
+        print("{0}switch({1}->id()) {{ \\".format("  " * (tab + 1), "T" + str(cur_typ)), file=buf)
+        for t, ctyp in ARITHMETIC_TYPES_MAP.items():
+            print("{0}case Type::{1}: \\".format("  " * (tab + 2), t), file=buf)
+            generate_type_switch(tab+2, cur_typ+1, typs + [ctyp])
+            print("{0}break; \\".format("  " * (tab + 3)), file=buf)
+        print("{0}default: \\".format("  " * (tab + 2)), file=buf)
+        print("{0}OUT = NULLPTR; \\".format("  " * (tab + 3)), file=buf)
+        print("{0}break; \\".format("  " * (tab + 2)), file=buf)
+        print("{0}}} \\".format("  " * (tab + 1)), file=buf)
+
+    generate_type_switch(0, 1, [])
+    print(file=buf)
+    return buf.getvalue()    
+
 def write_file_with_preamble(path, code):
     preamble = """// Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -132,6 +171,9 @@ def write_files():
     cast_code = generate_cast_code()
     write_file_with_preamble(os.path.join(here, 'cast-codegen-internal.h'),
                              cast_code)
+    arithmetic_code = generate_arithmetic_code()
+    write_file_with_preamble(os.path.join(here, 'arithmetic-codegen-internal.h'),
+                            arithmetic_code)
 
 
 if __name__ == '__main__':
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index 70870a74c45..1368376d7e7 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -66,6 +66,11 @@ void AssertTsEqual(const T& expected, const T& actual) {
 }
 
 void AssertArraysEqual(const Array& expected, const Array& actual) {
+  if (!expected.type()->Equals(actual.type())) {
+    FAIL() << "Got: \n"
+           << actual.type()->name() << "\nExpected: \n"
+           << expected.type()->name();
+  }
   AssertTsEqual(expected, actual);
 }
 

From 9280f592b72c46edf6e6e4c6f9006cbc4309c1ef Mon Sep 17 00:00:00 2001
From: Artem <artem.alekseev@intel.com>
Date: Fri, 18 Oct 2019 07:10:34 -0500
Subject: [PATCH 2/4] Remove type inference and add support for nulls

---
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |    3 +-
 cpp/src/arrow/compute/kernels/add-test.cc     |   78 +-
 cpp/src/arrow/compute/kernels/add.cc          |  166 +-
 cpp/src/arrow/compute/kernels/add.h           |   16 +-
 .../generated/arithmetic-codegen-internal.h   | 3796 -----------------
 .../compute/kernels/generated/codegen.py      |   44 +-
 6 files changed, 113 insertions(+), 3990 deletions(-)
 delete mode 100644 cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h

diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 0caa90e0a09..a54fd835193 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -17,16 +17,15 @@
 
 arrow_install_all_headers("arrow/compute/kernels")
 
-add_arrow_test(add-test PREFIX "arrow-compute")
 add_arrow_test(boolean_test PREFIX "arrow-compute")
 add_arrow_test(cast_test PREFIX "arrow-compute")
 add_arrow_test(hash_test PREFIX "arrow-compute")
 add_arrow_test(isin_test PREFIX "arrow-compute")
 add_arrow_test(sort_to_indices_test PREFIX "arrow-compute")
 add_arrow_test(util_internal_test PREFIX "arrow-compute")
+add_arrow_test(add-test PREFIX "arrow-compute")
 add_arrow_benchmark(sort_to_indices_benchmark PREFIX "arrow-compute")
 
-add_arrow_test(util-internal-test PREFIX "arrow-compute")
 # Aggregates
 add_arrow_test(aggregate_test PREFIX "arrow-compute")
 add_arrow_benchmark(aggregate_benchmark PREFIX "arrow-compute")
diff --git a/cpp/src/arrow/compute/kernels/add-test.cc b/cpp/src/arrow/compute/kernels/add-test.cc
index 1b4428d0b5a..89d2c90882d 100644
--- a/cpp/src/arrow/compute/kernels/add-test.cc
+++ b/cpp/src/arrow/compute/kernels/add-test.cc
@@ -26,7 +26,7 @@
 #include "arrow/array.h"
 #include "arrow/compute/kernel.h"
 #include "arrow/compute/kernels/add.h"
-#include "arrow/compute/test-util.h"
+#include "arrow/compute/test_util.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/checked_cast.h"
@@ -38,49 +38,69 @@
 namespace arrow {
 namespace compute {
 
-template <typename ResultType, typename LhsType, typename RhsType>
-class TestAddKernel : public ComputeFixture, public TestBase {
+template <typename ArrowType>
+class TestArithmeticKernel : public ComputeFixture, public TestBase {
  private:
   void AssertAddArrays(const std::shared_ptr<Array> lhs, const std::shared_ptr<Array> rhs,
                        const std::shared_ptr<Array> expected) {
     std::shared_ptr<Array> actual;
     ASSERT_OK(arrow::compute::Add(&this->ctx_, *lhs, *rhs, &actual));
-    ASSERT_OK(ValidateArray(*actual));
+    ASSERT_OK(actual->Validate());
     AssertArraysEqual(*expected, *actual);
   }
 
  protected:
   virtual void AssertAdd(const std::string& lhs, const std::string& rhs,
                          const std::string& expected) {
-    auto lhs_type = TypeTraits<LhsType>::type_singleton();
-    auto rhs_type = TypeTraits<RhsType>::type_singleton();
-    auto result_type = TypeTraits<ResultType>::type_singleton();
-    AssertAddArrays(ArrayFromJSON(lhs_type, lhs), ArrayFromJSON(rhs_type, rhs),
-                    ArrayFromJSON(result_type, expected));
+    auto type = TypeTraits<ArrowType>::type_singleton();
+    AssertAddArrays(ArrayFromJSON(type, lhs), ArrayFromJSON(type, rhs),
+                    ArrayFromJSON(type, expected));
   }
 };
 
-#define ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(T1, T2, T3)                                \
-  class TestAddKernel##T1##T2##T3 : public TestAddKernel<T1##Type, T2##Type, T3##Type> { \
-  };                                                                                     \
-  TEST_F(TestAddKernel##T1##T2##T3, TestAdd) {                                           \
-    this->AssertAdd("[2, 5, 1]", "[5, 3, 12]", "[7, 8, 13]");                            \
-  }
+template <typename ArrowType>
+class TestArithmeticKernelForReal : public TestArithmeticKernel<ArrowType> {};
+TYPED_TEST_CASE(TestArithmeticKernelForReal, RealArrowTypes);
+
+template <typename ArrowType>
+class TestArithmeticKernelForIntegral : public TestArithmeticKernel<ArrowType> {};
+TYPED_TEST_CASE(TestArithmeticKernelForIntegral, IntegralArrowTypes);
+
+TYPED_TEST(TestArithmeticKernelForReal, SortReal) {
+  this->AssertAdd("[]", "[]", "[]");
+
+  this->AssertAdd("[3.4, 2.6, 6.3]", "[1, 0, 2]", "[4.4, 2.6, 8.3]");
+
+  this->AssertAdd("[1.1, 2.4, 3.5, 4.3, 5.1, 6.8, 7.3]", "[0, 1, 2, 3, 4, 5, 6]",
+                  "[1.1, 3.4, 5.5, 7.3, 9.1, 11.8, 13.3]");
+
+  this->AssertAdd("[7, 6, 5, 4, 3, 2, 1]", "[6, 5, 4, 3, 2, 1, 0]",
+                  "[13, 11, 9, 7, 5, 3, 1]");
+
+  this->AssertAdd("[10.4, 12, 4.2, 50, 50.3, 32, 11]", "[2, 0, 6, 1, 5, 3, 4]",
+                  "[12.4, 12, 10.2, 51, 55.3, 35, 15]");
+
+  this->AssertAdd("[null, 1, 3.3, null, 2, 5.3]", "[1, 4, 2, 5, 0, 3]",
+                  "[null, 5, 5.3, null, 2, 8.3]");
+}
+
+TYPED_TEST(TestArithmeticKernelForIntegral, SortIntegral) {
+  this->AssertAdd("[]", "[]", "[]");
+
+  this->AssertAdd("[3, 2, 6]", "[1, 0, 2]", "[4, 2, 8]");
+
+  this->AssertAdd("[1, 2, 3, 4, 5, 6, 7]", "[0, 1, 2, 3, 4, 5, 6]",
+                  "[1, 3, 5, 7, 9, 11, 13]");
+
+  this->AssertAdd("[7, 6, 5, 4, 3, 2, 1]", "[6, 5, 4, 3, 2, 1, 0]",
+                  "[13, 11, 9, 7, 5, 3, 1]");
+
+  this->AssertAdd("[10, 12, 4, 50, 50, 32, 11]", "[2, 0, 6, 1, 5, 3, 4]",
+                  "[12, 12, 10, 51, 55, 35, 15]");
 
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, Int32, Int32)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt32, UInt32, UInt32)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, UInt32, Int32)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int32, Int32, UInt32)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int64, Int64, UInt32)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt64, UInt64, UInt64)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt64, UInt8, UInt64)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int8, UInt8, Int8)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int16, UInt8, Int16)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Int16, UInt16, Int8)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(UInt16, UInt8, UInt16)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Double, Double, UInt16)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Double, Float, Double)
-ARITHMETIC_KERNEL_TYPE_INFERENCE_TEST(Float, Float, UInt16)
+  this->AssertAdd("[null, 1, 3, null, 2, 5]", "[1, 4, 2, 5, 0, 3]",
+                  "[null, 5, 5, null, 2, 8]");
+}
 
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/add.cc b/cpp/src/arrow/compute/kernels/add.cc
index 5b0e1f8c52d..d6ff2e4306d 100644
--- a/cpp/src/arrow/compute/kernels/add.cc
+++ b/cpp/src/arrow/compute/kernels/add.cc
@@ -16,40 +16,35 @@
 // under the License.
 
 #include "arrow/compute/kernels/add.h"
+#include "arrow/builder.h"
 #include "arrow/compute/context.h"
-#include "arrow/compute/kernels/generated/arithmetic-codegen-internal.h"
+#include "arrow/type_traits.h"
 
 namespace arrow {
 namespace compute {
 
-size_t GetSize(const std::shared_ptr<DataType>& type);
-
-template <typename TResult, typename TLhs, typename TRhs>
+template <typename ArrowType>
 class AddKernelImpl : public AddKernel {
  private:
+  using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
   std::shared_ptr<DataType> result_type_;
-  using ArrowLhsElementType = typename CTypeTraits<TLhs>::ArrowType;
-  using ArrowRhsElementType = typename CTypeTraits<TRhs>::ArrowType;
-  using ArrowResultElementType = typename CTypeTraits<TResult>::ArrowType;
-  using LhsArray = NumericArray<ArrowLhsElementType>;
-  using RhsArray = NumericArray<ArrowRhsElementType>;
-  using ResultArray = NumericArray<ArrowResultElementType>;
 
-  Status Add(FunctionContext* ctx, const std::shared_ptr<LhsArray>& lhs,
-             const std::shared_ptr<RhsArray>& rhs, std::shared_ptr<Array>* result) {
-    std::shared_ptr<Buffer> buf;
-    size_t size = GetSize(result_type_) / 8;
-    RETURN_NOT_OK(AllocateBuffer(ctx->memory_pool(), lhs->length() * size, &buf));
-    auto res_data = reinterpret_cast<TResult*>(buf->mutable_data());
+  Status Add(FunctionContext* ctx, const std::shared_ptr<ArrayType>& lhs,
+             const std::shared_ptr<ArrayType>& rhs, std::shared_ptr<Array>* result) {
+    NumericBuilder<ArrowType> builder;
+    builder.Reserve(lhs->length());
     for (int i = 0; i < lhs->length(); i++) {
-      res_data[i] = lhs->Value(i) + rhs->Value(i);
+      if (lhs->IsNull(i) || rhs->IsNull(i)) {
+        builder.UnsafeAppendNull();
+      } else {
+        builder.UnsafeAppend(lhs->Value(i) + rhs->Value(i));
+      }
     }
-    *result = std::make_shared<ResultArray>(lhs->length(), buf);
-    return Status::OK();
+    return builder.Finish(result);
   }
 
  public:
-  AddKernelImpl(std::shared_ptr<DataType> result_type) : result_type_(result_type) {}
+  explicit AddKernelImpl(std::shared_ptr<DataType> result_type) : result_type_(result_type) {}
 
   Status Call(FunctionContext* ctx, const Datum& lhs, const Datum& rhs, Datum* out) {
     if (!lhs.is_array() || !rhs.is_array()) {
@@ -60,9 +55,6 @@ class AddKernelImpl : public AddKernel {
     }
     auto lhs_array = lhs.make_array();
     auto rhs_array = rhs.make_array();
-    if (lhs_array->null_count() || rhs_array->null_count()) {
-      return Status::Invalid("AddKernel expects arrays without nulls");
-    }
     std::shared_ptr<Array> result;
     RETURN_NOT_OK(this->Add(ctx, lhs_array, rhs_array, &result));
     *out = result;
@@ -73,97 +65,48 @@ class AddKernelImpl : public AddKernel {
 
   virtual Status Add(FunctionContext* ctx, const std::shared_ptr<Array>& lhs,
                      const std::shared_ptr<Array>& rhs, std::shared_ptr<Array>* result) {
-    auto lhs_array = std::static_pointer_cast<LhsArray>(lhs);
-    auto rhs_array = std::static_pointer_cast<RhsArray>(rhs);
+    auto lhs_array = std::static_pointer_cast<ArrayType>(lhs);
+    auto rhs_array = std::static_pointer_cast<ArrayType>(rhs);
     return Add(ctx, lhs_array, rhs_array, result);
   }
 };
 
-std::shared_ptr<DataType> MakeNumericType(bool sign, bool floating, size_t size) {
-  if (floating) {
-    switch (size) {
-      case 16:
-        return float16();
-      case 32:
-        return float32();
-      case 64:
-        return float64();
-      default:
-        return NULLPTR;
-    }
-  }
-  if (sign) {
-    switch (size) {
-      case 8:
-        return int8();
-      case 16:
-        return int16();
-      case 32:
-        return int32();
-      case 64:
-        return int64();
-      default:
-        return NULLPTR;
-    }
-  }
-
-  switch (size) {
-    case 8:
-      return uint8();
-    case 16:
-      return uint16();
-    case 32:
-      return uint32();
-    case 64:
-      return uint64();
-    default:
-      return NULLPTR;
-  }
-}
-
-bool IsUnsigned(const std::shared_ptr<DataType>& type) {
-  return type->Equals(uint8()) || type->Equals(uint16()) || type->Equals(uint32()) ||
-         type->Equals(uint64());
-}
-
-bool IsSigned(const std::shared_ptr<DataType>& type) {
-  return type->Equals(int8()) || type->Equals(int16()) || type->Equals(int32()) ||
-         type->Equals(int64());
-}
-
-bool IsFloating(const std::shared_ptr<DataType>& type) {
-  return type->Equals(float16()) || type->Equals(float32()) || type->Equals(float64());
-}
-
-size_t GetSize(const std::shared_ptr<DataType>& type) {
-  if (type->Equals(uint8()) || type->Equals(int8())) {
-    return 8;
-  }
-  if (type->Equals(float16()) || type->Equals(int16()) || type->Equals(uint16())) {
-    return 16;
-  }
-  if (type->Equals(float32()) || type->Equals(int32()) || type->Equals(uint32())) {
-    return 32;
-  }
-  if (type->Equals(float64()) || type->Equals(int64()) || type->Equals(uint64())) {
-    return 64;
-  }
-  return 1111;  // any number greater then 64 to make MakeNumericType fail
-}
-
-Status AddKernel::Make(const std::shared_ptr<DataType>& lhs_type,
-                       const std::shared_ptr<DataType>& rhs_type,
+Status AddKernel::Make(const std::shared_ptr<DataType>& value_type,
                        std::unique_ptr<AddKernel>* out) {
-  auto result_type = MakeNumericType(IsSigned(lhs_type) || IsSigned(rhs_type),
-                                     IsFloating(lhs_type) || IsFloating(rhs_type),
-                                     std::max(GetSize(lhs_type), GetSize(rhs_type)));
-  if (!result_type) {
-    return Status::TypeError("AddKernel can not infer appropriate type");
-  }
   AddKernel* kernel;
-  ARITHMETIC_TYPESWITCH(kernel, AddKernelImpl, result_type, lhs_type, rhs_type)
-  if(!kernel) {
-    return Status::TypeError("AddKernel can not infer appropriate type");
+  switch (value_type->id()) {
+    case Type::UINT8:
+      kernel = new AddKernelImpl<UInt8Type>(value_type);
+      break;
+    case Type::INT8:
+      kernel = new AddKernelImpl<Int8Type>(value_type);
+      break;
+    case Type::UINT16:
+      kernel = new AddKernelImpl<UInt16Type>(value_type);
+      break;
+    case Type::INT16:
+      kernel = new AddKernelImpl<Int16Type>(value_type);
+      break;
+    case Type::UINT32:
+      kernel = new AddKernelImpl<UInt32Type>(value_type);
+      break;
+    case Type::INT32:
+      kernel = new AddKernelImpl<Int32Type>(value_type);
+      break;
+    case Type::UINT64:
+      kernel = new AddKernelImpl<UInt64Type>(value_type);
+      break;
+    case Type::INT64:
+      kernel = new AddKernelImpl<Int64Type>(value_type);
+      break;
+    case Type::FLOAT:
+      kernel = new AddKernelImpl<FloatType>(value_type);
+      break;
+    case Type::DOUBLE:
+      kernel = new AddKernelImpl<DoubleType>(value_type);
+      break;
+    default:
+      return Status::NotImplemented("Arithmetic operations on ", *value_type, " arrays");
   }
   out->reset(kernel);
   return Status::OK();
@@ -173,11 +116,14 @@ Status Add(FunctionContext* ctx, const Array& lhs, const Array& rhs,
            std::shared_ptr<Array>* result) {
   Datum result_datum;
   std::unique_ptr<AddKernel> kernel;
-  RETURN_NOT_OK(AddKernel::Make(lhs.type(), rhs.type(), &kernel));
+  ARROW_RETURN_IF(
+      !lhs.type()->Equals(rhs.type()),
+      Status::Invalid("Array types should be equal to use arithmetic kernels"));
+  RETURN_NOT_OK(AddKernel::Make(lhs.type(), &kernel));
   kernel->Call(ctx, Datum(lhs.data()), Datum(rhs.data()), &result_datum);
   *result = result_datum.make_array();
   return Status::OK();
 }
 
 }  // namespace compute
-}  // namespace arrow
\ No newline at end of file
+}  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/add.h b/cpp/src/arrow/compute/kernels/add.h
index 09588284e5f..fe96ff23cc3 100644
--- a/cpp/src/arrow/compute/kernels/add.h
+++ b/cpp/src/arrow/compute/kernels/add.h
@@ -34,13 +34,11 @@ class FunctionContext;
 /// \brief Summarizes two arrays.
 ///
 /// Summarizes two arrays with the same length.
-/// The output is an array with same length as input.
-/// Nulls are prohibited. The type size of result array will be equal
-/// to the max size of lhs and rhs types and will be unsigned if both
-/// lhs and rhs are unsigned.
+/// The output is an array with same length and type as input.
+/// Types of both input arrays should be equal
 ///
-/// For example given lhs = [1, 2, 3], rhs = [4, 5, 6], the output
-/// will be [5, 6, 7]
+/// For example given lhs = [1, null, 3], rhs = [4, 5, 6], the output
+/// will be [5, null, 7]
 ///
 /// \param[in] ctx the FunctionContext
 /// \param[in] values array to sort
@@ -71,10 +69,8 @@ class ARROW_EXPORT AddKernel : public BinaryKernel {
   ///
   /// \param[in] value_type constructed AddKernel
   /// \param[out] out created kernel
-  static Status Make(const std::shared_ptr<DataType>& lhs_type,
-                     const std::shared_ptr<DataType>& rhs_type,
+  static Status Make(const std::shared_ptr<DataType>& value_type,
                      std::unique_ptr<AddKernel>* out);
 };
-
 }  // namespace compute
-}  // namespace arrow
\ No newline at end of file
+}  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h b/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h
deleted file mode 100644
index 5606ecf810e..00000000000
--- a/cpp/src/arrow/compute/kernels/generated/arithmetic-codegen-internal.h
+++ /dev/null
@@ -1,3796 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT
-// Generated by codegen.py script
-#define ARITHMETIC_TYPESWITCH(OUT, TYPE, T1, T2, T3) \
-  switch(T1->id()) { \
-    case Type::INT8: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int8_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int8_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int8_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int8_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int8_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int8_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int8_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int8_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int8_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int8_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::UINT8: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint8_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint8_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint8_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint8_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint8_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint8_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint8_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint8_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint8_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint8_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::INT16: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int16_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int16_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int16_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int16_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int16_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int16_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int16_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int16_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int16_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int16_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::UINT16: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint16_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint16_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint16_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint16_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint16_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint16_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint16_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint16_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint16_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint16_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::INT32: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int32_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int32_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int32_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int32_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int32_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int32_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int32_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int32_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int32_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int32_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::UINT32: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint32_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint32_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint32_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint32_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint32_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint32_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint32_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint32_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint32_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint32_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::INT64: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<int64_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<int64_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<int64_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<int64_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<int64_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<int64_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<int64_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<int64_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<int64_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<int64_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::UINT64: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<uint64_t, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<uint64_t, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<uint64_t, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<uint64_t, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<uint64_t, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<uint64_t, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<uint64_t, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<uint64_t, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<uint64_t, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<uint64_t, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::FLOAT: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<float, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<float, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<float, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<float, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<float, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<float, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<float, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<float, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<float, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<float, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    case Type::DOUBLE: \
-      switch(T2->id()) { \
-        case Type::INT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, int8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, int8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, int8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, int8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, int8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, int8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, int8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, int8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, int8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, int8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT8: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, uint8_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, uint8_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, uint8_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, uint8_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, uint8_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, uint8_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, uint8_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, uint8_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, uint8_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, uint8_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, int16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, int16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, int16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, int16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, int16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, int16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, int16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, int16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, int16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, int16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT16: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, uint16_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, uint16_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, uint16_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, uint16_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, uint16_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, uint16_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, uint16_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, uint16_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, uint16_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, uint16_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, int32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, int32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, int32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, int32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, int32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, int32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, int32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, int32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, int32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, int32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT32: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, uint32_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, uint32_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, uint32_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, uint32_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, uint32_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, uint32_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, uint32_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, uint32_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, uint32_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, uint32_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::INT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, int64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, int64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, int64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, int64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, int64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, int64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, int64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, int64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, int64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, int64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::UINT64: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, uint64_t, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, uint64_t, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, uint64_t, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, uint64_t, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, uint64_t, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, uint64_t, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, uint64_t, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, uint64_t, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, uint64_t, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, uint64_t, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::FLOAT: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, float, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, float, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, float, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, float, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, float, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, float, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, float, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, float, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, float, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, float, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        case Type::DOUBLE: \
-          switch(T3->id()) { \
-            case Type::INT8: \
-              OUT = new TYPE<double, double, int8_t>(T1); \
-              break; \
-            case Type::UINT8: \
-              OUT = new TYPE<double, double, uint8_t>(T1); \
-              break; \
-            case Type::INT16: \
-              OUT = new TYPE<double, double, int16_t>(T1); \
-              break; \
-            case Type::UINT16: \
-              OUT = new TYPE<double, double, uint16_t>(T1); \
-              break; \
-            case Type::INT32: \
-              OUT = new TYPE<double, double, int32_t>(T1); \
-              break; \
-            case Type::UINT32: \
-              OUT = new TYPE<double, double, uint32_t>(T1); \
-              break; \
-            case Type::INT64: \
-              OUT = new TYPE<double, double, int64_t>(T1); \
-              break; \
-            case Type::UINT64: \
-              OUT = new TYPE<double, double, uint64_t>(T1); \
-              break; \
-            case Type::FLOAT: \
-              OUT = new TYPE<double, double, float>(T1); \
-              break; \
-            case Type::DOUBLE: \
-              OUT = new TYPE<double, double, double>(T1); \
-              break; \
-            default: \
-              OUT = NULLPTR; \
-            break; \
-          } \
-          break; \
-        default: \
-          OUT = NULLPTR; \
-        break; \
-      } \
-      break; \
-    default: \
-      OUT = NULLPTR; \
-    break; \
-  } \
-
diff --git a/cpp/src/arrow/compute/kernels/generated/codegen.py b/cpp/src/arrow/compute/kernels/generated/codegen.py
index ab05bd23ca3..76d27ad3344 100644
--- a/cpp/src/arrow/compute/kernels/generated/codegen.py
+++ b/cpp/src/arrow/compute/kernels/generated/codegen.py
@@ -33,23 +33,11 @@
 DATE_TIME_TYPES = ['Date32', 'Date64', 'Time32', 'Time64', 'Timestamp',
                    'Duration']
 
-ARITHMETIC_TYPES_MAP = {
-    'INT8': 'int8_t',
-    'UINT8': 'uint8_t',
-    'INT16': 'int16_t',
-    'UINT16': 'uint16_t',
-    'INT32': 'int32_t',
-    'UINT32': 'uint32_t',
-    'INT64': 'int64_t',
-    'UINT64': 'uint64_t',
-    'FLOAT': 'float',
-    'DOUBLE': 'double',
-}
-
 
 def _format_type(name):
     return name + "Type"
 
+
 class CastCodeGenerator(object):
 
     def __init__(self, type_name, out_types, parametric=False,
@@ -115,33 +103,6 @@ def generate_cast_code():
     return '\n'.join(blocks)
 
 
-def generate_arithmetic_code():
-    buf = io.StringIO()
-    print("#define ARITHMETIC_TYPESWITCH(OUT, TYPE, T1, T2, T3) \\", file=buf)
-
-    def generate_kernel_instantiation(tab, typs):
-        print("{0}OUT = new TYPE<{1}>(T1); \\".format("  " * (tab), 
-            ', '.join(typs)), file=buf)
-
-    def generate_type_switch(tab, cur_typ, typs):
-        if(len(typs) == 3):
-            generate_kernel_instantiation(tab+1, typs)
-            return
-
-        print("{0}switch({1}->id()) {{ \\".format("  " * (tab + 1), "T" + str(cur_typ)), file=buf)
-        for t, ctyp in ARITHMETIC_TYPES_MAP.items():
-            print("{0}case Type::{1}: \\".format("  " * (tab + 2), t), file=buf)
-            generate_type_switch(tab+2, cur_typ+1, typs + [ctyp])
-            print("{0}break; \\".format("  " * (tab + 3)), file=buf)
-        print("{0}default: \\".format("  " * (tab + 2)), file=buf)
-        print("{0}OUT = NULLPTR; \\".format("  " * (tab + 3)), file=buf)
-        print("{0}break; \\".format("  " * (tab + 2)), file=buf)
-        print("{0}}} \\".format("  " * (tab + 1)), file=buf)
-
-    generate_type_switch(0, 1, [])
-    print(file=buf)
-    return buf.getvalue()    
-
 def write_file_with_preamble(path, code):
     preamble = """// Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -174,9 +135,6 @@ def write_files():
     cast_code = generate_cast_code()
     write_file_with_preamble(os.path.join(here, 'cast_codegen_internal.h'),
                              cast_code)
-    arithmetic_code = generate_arithmetic_code()
-    write_file_with_preamble(os.path.join(here, 'arithmetic-codegen-internal.h'),
-                            arithmetic_code)
 
 
 if __name__ == '__main__':

From 21ba0187522057384e406a8cd931aa847e6ca09a Mon Sep 17 00:00:00 2001
From: Artem <artem.alekseev@intel.com>
Date: Fri, 18 Oct 2019 07:25:10 -0500
Subject: [PATCH 3/4] fix lint warning

---
 cpp/src/arrow/compute/kernels/add.cc | 12 +++++++-----
 cpp/src/arrow/compute/kernels/add.h  |  5 +++--
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/add.cc b/cpp/src/arrow/compute/kernels/add.cc
index d6ff2e4306d..e6295ce806b 100644
--- a/cpp/src/arrow/compute/kernels/add.cc
+++ b/cpp/src/arrow/compute/kernels/add.cc
@@ -32,7 +32,7 @@ class AddKernelImpl : public AddKernel {
   Status Add(FunctionContext* ctx, const std::shared_ptr<ArrayType>& lhs,
              const std::shared_ptr<ArrayType>& rhs, std::shared_ptr<Array>* result) {
     NumericBuilder<ArrowType> builder;
-    builder.Reserve(lhs->length());
+    RETURN_NOT_OK(builder.Reserve(lhs->length()));
     for (int i = 0; i < lhs->length(); i++) {
       if (lhs->IsNull(i) || rhs->IsNull(i)) {
         builder.UnsafeAppendNull();
@@ -44,9 +44,11 @@ class AddKernelImpl : public AddKernel {
   }
 
  public:
-  explicit AddKernelImpl(std::shared_ptr<DataType> result_type) : result_type_(result_type) {}
+  explicit AddKernelImpl(std::shared_ptr<DataType> result_type)
+      : result_type_(result_type) {}
 
-  Status Call(FunctionContext* ctx, const Datum& lhs, const Datum& rhs, Datum* out) {
+  Status Call(FunctionContext* ctx, const Datum& lhs, const Datum& rhs,
+              Datum* out) override {
     if (!lhs.is_array() || !rhs.is_array()) {
       return Status::Invalid("AddKernel expects array values");
     }
@@ -63,8 +65,8 @@ class AddKernelImpl : public AddKernel {
 
   std::shared_ptr<DataType> out_type() const override { return result_type_; }
 
-  virtual Status Add(FunctionContext* ctx, const std::shared_ptr<Array>& lhs,
-                     const std::shared_ptr<Array>& rhs, std::shared_ptr<Array>* result) {
+  Status Add(FunctionContext* ctx, const std::shared_ptr<Array>& lhs,
+             const std::shared_ptr<Array>& rhs, std::shared_ptr<Array>* result) override {
     auto lhs_array = std::static_pointer_cast<ArrayType>(lhs);
     auto rhs_array = std::static_pointer_cast<ArrayType>(rhs);
     return Add(ctx, lhs_array, rhs_array, result);
diff --git a/cpp/src/arrow/compute/kernels/add.h b/cpp/src/arrow/compute/kernels/add.h
index fe96ff23cc3..19991aa4473 100644
--- a/cpp/src/arrow/compute/kernels/add.h
+++ b/cpp/src/arrow/compute/kernels/add.h
@@ -41,8 +41,9 @@ class FunctionContext;
 /// will be [5, null, 7]
 ///
 /// \param[in] ctx the FunctionContext
-/// \param[in] values array to sort
-/// \param[out] offsets indices that would sort an array
+/// \param[in] lhs the first array
+/// \param[in] rhs the second array
+/// \param[out] result the sum of first and second arrays
 
 ARROW_EXPORT
 Status Add(FunctionContext* ctx, const Array& lhs, const Array& rhs,

From 0381a8f4f35461b774cd756f491ecb9792bfb188 Mon Sep 17 00:00:00 2001
From: Artem <artem.alekseev@intel.com>
Date: Mon, 21 Oct 2019 02:58:04 -0500
Subject: [PATCH 4/4] fix compilation warnings

---
 cpp/src/arrow/compute/kernels/add.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/add.cc b/cpp/src/arrow/compute/kernels/add.cc
index e6295ce806b..19eb153b5cd 100644
--- a/cpp/src/arrow/compute/kernels/add.cc
+++ b/cpp/src/arrow/compute/kernels/add.cc
@@ -122,7 +122,7 @@ Status Add(FunctionContext* ctx, const Array& lhs, const Array& rhs,
       !lhs.type()->Equals(rhs.type()),
       Status::Invalid("Array types should be equal to use arithmetic kernels"));
   RETURN_NOT_OK(AddKernel::Make(lhs.type(), &kernel));
-  kernel->Call(ctx, Datum(lhs.data()), Datum(rhs.data()), &result_datum);
+  RETURN_NOT_OK(kernel->Call(ctx, Datum(lhs.data()), Datum(rhs.data()), &result_datum));
   *result = result_datum.make_array();
   return Status::OK();
 }