JIT: fix crash and shortcut function for conditions 80/17380/3
Calixte DENIZET [Fri, 23 Oct 2015 08:22:18 +0000 (10:22 +0200)]
Change-Id: I5dea7b1e779b0d9cfb20a5211653dd0f9eda01d5

38 files changed:
scilab/modules/ast/Makefile.am
scilab/modules/ast/Makefile.in
scilab/modules/ast/ast.vcxproj
scilab/modules/ast/ast.vcxproj.filters
scilab/modules/ast/includes/analysis/Chrono.hxx
scilab/modules/ast/includes/analysis/data/MacroSignature.hxx
scilab/modules/ast/includes/jit/Cast.hxx
scilab/modules/ast/includes/jit/Debug.hxx
scilab/modules/ast/includes/jit/JITArrayofs.hxx
scilab/modules/ast/includes/jit/JITInfo.hxx
scilab/modules/ast/includes/jit/JITScalars.hxx
scilab/modules/ast/includes/jit/JITScilabVal.hxx
scilab/modules/ast/includes/jit/JITVisitor.hxx
scilab/modules/ast/includes/jit/Jitter.hxx
scilab/modules/ast/includes/jit/base/IOArgs.hxx
scilab/modules/ast/includes/jit/base/addition.hxx
scilab/modules/ast/includes/jit/base/and.hxx
scilab/modules/ast/includes/jit/base/binary_functors.hxx
scilab/modules/ast/includes/jit/base/exponentiation.hxx
scilab/modules/ast/includes/jit/base/vectorization.hxx
scilab/modules/ast/includes/jit/calls/JITShortcutBinOpCall.hxx
scilab/modules/ast/includes/jit/funs_interf.bak.2 [deleted file]
scilab/modules/ast/includes/jit/funs_interf.h
scilab/modules/ast/src/cpp/analysis/Chrono.cpp [new file with mode: 0644]
scilab/modules/ast/src/cpp/analysis/PolymorphicMacroCache.cpp
scilab/modules/ast/src/cpp/jit/BaseFunctions2.cpp
scilab/modules/ast/src/cpp/jit/BaseFunctions3.cpp
scilab/modules/ast/src/cpp/jit/BaseFunctions4.cpp
scilab/modules/ast/src/cpp/jit/BaseFunctions5.cpp
scilab/modules/ast/src/cpp/jit/Debug.cpp
scilab/modules/ast/src/cpp/jit/JITBinOpCall.cpp
scilab/modules/ast/src/cpp/jit/JITCall.cpp
scilab/modules/ast/src/cpp/jit/JITCallExp.cpp
scilab/modules/ast/src/cpp/jit/JITComplexVal.cpp
scilab/modules/ast/src/cpp/jit/JITMakeScilabCall.cpp
scilab/modules/ast/src/cpp/jit/JITShortcutBinOpCall.cpp
scilab/modules/ast/src/cpp/jit/JITVisitor.cpp
scilab/modules/ast/src/cpp/jit/Jitter.cpp

index 2ef8ad9..9fe3d62 100644 (file)
@@ -109,6 +109,7 @@ src/cpp/types/tostring_common.cpp \
 src/cpp/types/types.cpp \
 src/cpp/types/types_tools.cpp \
 src/cpp/types/void.cpp \
+src/cpp/analysis/Chrono.cpp \
 src/cpp/analysis/AnalysisVisitor.cpp \
 src/cpp/analysis/ArgnAnalyzer.cpp \
 src/cpp/analysis/Block.cpp \
index da00fbf..05976d3 100644 (file)
@@ -243,6 +243,7 @@ am__libsciast_la_SOURCES_DIST = src/c/operations/doublecomplex.c \
        src/cpp/types/threadId.cpp src/cpp/types/tlist.cpp \
        src/cpp/types/tostring_common.cpp src/cpp/types/types.cpp \
        src/cpp/types/types_tools.cpp src/cpp/types/void.cpp \
+       src/cpp/analysis/Chrono.cpp \
        src/cpp/analysis/AnalysisVisitor.cpp \
        src/cpp/analysis/ArgnAnalyzer.cpp src/cpp/analysis/Block.cpp \
        src/cpp/analysis/Checkers.cpp \
@@ -496,6 +497,7 @@ am_libsciast_la_OBJECTS =  \
        src/cpp/types/libsciast_la-types.lo \
        src/cpp/types/libsciast_la-types_tools.lo \
        src/cpp/types/libsciast_la-void.lo \
+       src/cpp/analysis/libsciast_la-Chrono.lo \
        src/cpp/analysis/libsciast_la-AnalysisVisitor.lo \
        src/cpp/analysis/libsciast_la-ArgnAnalyzer.lo \
        src/cpp/analysis/libsciast_la-Block.lo \
@@ -1147,6 +1149,7 @@ libsciast_la_SOURCES = src/c/operations/doublecomplex.c \
        src/cpp/types/threadId.cpp src/cpp/types/tlist.cpp \
        src/cpp/types/tostring_common.cpp src/cpp/types/types.cpp \
        src/cpp/types/types_tools.cpp src/cpp/types/void.cpp \
+       src/cpp/analysis/Chrono.cpp \
        src/cpp/analysis/AnalysisVisitor.cpp \
        src/cpp/analysis/ArgnAnalyzer.cpp src/cpp/analysis/Block.cpp \
        src/cpp/analysis/Checkers.cpp \
@@ -2009,6 +2012,9 @@ src/cpp/analysis/$(am__dirstamp):
 src/cpp/analysis/$(DEPDIR)/$(am__dirstamp):
        @$(MKDIR_P) src/cpp/analysis/$(DEPDIR)
        @: > src/cpp/analysis/$(DEPDIR)/$(am__dirstamp)
+src/cpp/analysis/libsciast_la-Chrono.lo:  \
+       src/cpp/analysis/$(am__dirstamp) \
+       src/cpp/analysis/$(DEPDIR)/$(am__dirstamp)
 src/cpp/analysis/libsciast_la-AnalysisVisitor.lo:  \
        src/cpp/analysis/$(am__dirstamp) \
        src/cpp/analysis/$(DEPDIR)/$(am__dirstamp)
@@ -2613,6 +2619,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-Block.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-CeilAnalyzer.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-Checkers.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-Chrono.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-CompleteMacroSignature.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-ConstantValue.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/analysis/$(DEPDIR)/libsciast_la-ConstantVisitor.Plo@am__quote@
@@ -3604,6 +3611,13 @@ src/cpp/types/libsciast_la-void.lo: src/cpp/types/void.cpp
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o src/cpp/types/libsciast_la-void.lo `test -f 'src/cpp/types/void.cpp' || echo '$(srcdir)/'`src/cpp/types/void.cpp
 
+src/cpp/analysis/libsciast_la-Chrono.lo: src/cpp/analysis/Chrono.cpp
+@am__fastdepCXX_TRUE@  $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT src/cpp/analysis/libsciast_la-Chrono.lo -MD -MP -MF src/cpp/analysis/$(DEPDIR)/libsciast_la-Chrono.Tpo -c -o src/cpp/analysis/libsciast_la-Chrono.lo `test -f 'src/cpp/analysis/Chrono.cpp' || echo '$(srcdir)/'`src/cpp/analysis/Chrono.cpp
+@am__fastdepCXX_TRUE@  $(AM_V_at)$(am__mv) src/cpp/analysis/$(DEPDIR)/libsciast_la-Chrono.Tpo src/cpp/analysis/$(DEPDIR)/libsciast_la-Chrono.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@     $(AM_V_CXX)source='src/cpp/analysis/Chrono.cpp' object='src/cpp/analysis/libsciast_la-Chrono.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o src/cpp/analysis/libsciast_la-Chrono.lo `test -f 'src/cpp/analysis/Chrono.cpp' || echo '$(srcdir)/'`src/cpp/analysis/Chrono.cpp
+
 src/cpp/analysis/libsciast_la-AnalysisVisitor.lo: src/cpp/analysis/AnalysisVisitor.cpp
 @am__fastdepCXX_TRUE@  $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT src/cpp/analysis/libsciast_la-AnalysisVisitor.lo -MD -MP -MF src/cpp/analysis/$(DEPDIR)/libsciast_la-AnalysisVisitor.Tpo -c -o src/cpp/analysis/libsciast_la-AnalysisVisitor.lo `test -f 'src/cpp/analysis/AnalysisVisitor.cpp' || echo '$(srcdir)/'`src/cpp/analysis/AnalysisVisitor.cpp
 @am__fastdepCXX_TRUE@  $(AM_V_at)$(am__mv) src/cpp/analysis/$(DEPDIR)/libsciast_la-AnalysisVisitor.Tpo src/cpp/analysis/$(DEPDIR)/libsciast_la-AnalysisVisitor.Plo
index fa39023..b8fe40b 100644 (file)
@@ -660,6 +660,7 @@ lib /DEF:"$(ProjectDir)string_import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Platform
     <ClCompile Include="src\cpp\analysis\check_____times____.cpp" />
     <ClCompile Include="src\cpp\analysis\check_____transp____.cpp" />
     <ClCompile Include="src\cpp\analysis\check_____unaryminus____.cpp" />
+    <ClCompile Include="src\cpp\analysis\Chrono.cpp" />
     <ClCompile Include="src\cpp\analysis\CompleteMacroSignature.cpp" />
     <ClCompile Include="src\cpp\analysis\ConstantValue.cpp" />
     <ClCompile Include="src\cpp\analysis\ConstantVisitor.cpp" />
index a3299a6..e073007 100644 (file)
     <ClCompile Include="src\cpp\jit\Debug.cpp">
       <Filter>Source Files\jit</Filter>
     </ClCompile>
+    <ClCompile Include="src\cpp\analysis\Chrono.cpp">
+      <Filter>Source Files\analysis</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file
index a24d814..33dda6e 100644 (file)
 #ifndef __CHRONO_HXX__
 #define __CHRONO_HXX__
 
+#include <string>
 #include <chrono>
 #include <iostream>
 
 namespace analysis
 {
 
-    class Chrono
+class Chrono
+{
+    std::chrono::steady_clock::time_point start;
+    std::chrono::steady_clock::time_point end;
+
+    static std::chrono::steady_clock::time_point _tic;
+
+public:
+
+    void start_chrono()
+    {
+        start = std::chrono::steady_clock::now();
+    }
+
+    void stop_chrono()
+    {
+        end = std::chrono::steady_clock::now();
+    }
+
+    double get_duration() const
     {
-        std::chrono::steady_clock::time_point start;
-        std::chrono::steady_clock::time_point end;
-
-    public:
-
-       void start_chrono()
-            {
-                start = std::chrono::steady_clock::now();
-            }
-       
-        void stop_chrono()
-            {
-                end = std::chrono::steady_clock::now();
-            }
-       
-        double get_duration() const
-            {
-                return (double)std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() * 1e-9;
-            } 
-
-       friend std::wostream & operator<<(std::wostream & out, const Chrono & chrono)
-           {
-               out << L"Elapsed time: " << chrono.get_duration() << L" s.";
-               return out;
-           }
-    };
-    
+        return (double)std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() * 1e-9;
+    }
+
+    inline static void tic()
+    {
+        _tic = std::chrono::steady_clock::now();
+    }
+
+    inline static double toc(const std::wstring & mark = L"")
+    {
+        const double duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - _tic).count() * 1e-9;
+        if (!mark.empty())
+        {
+            std::wcerr << L"Elapsed time: " << duration << L" s (" << mark << L")" << std::endl;
+        }
+        return duration;
+    }
+
+    friend std::wostream & operator<<(std::wostream & out, const Chrono & chrono)
+    {
+        out << L"Elapsed time: " << chrono.get_duration() << L" s.";
+        return out;
+    }
+};
+
 } // namespace analysis
 
 #endif // __CHRONO_HXX__
index 2e43946..badafc1 100644 (file)
@@ -24,9 +24,6 @@
 namespace analysis
 {
 
-class MacroDef;
-class DataManager;
-
 /**
  * \struct MacroSignature
  * \brief A MacroSignature is defined by a macro name, the number of LHS and the types of the arguments
@@ -37,7 +34,7 @@ struct MacroSignature
     const unsigned int lhs;
     TITypeSignatureTuple tuple;
 
-    MacroSignature(MacroDef & macrodef, const unsigned int _lhs, const std::vector<TIType> & in) : name(macrodef.getName()), lhs(_lhs), tuple(in) { }
+    MacroSignature(const std::wstring & _name, const unsigned int _lhs, const std::vector<TIType> & in) : name(_name), lhs(_lhs), tuple(in) { }
 
     friend std::wostream & operator<<(std::wostream & out, const MacroSignature & signature)
     {
index 6ab68fc..25dc4d4 100644 (file)
 namespace jit
 {
 
-    class Cast
-    {
+class Cast
+{
 
-    public:
+public:
 
-        template<typename T>
-        inline static llvm::Value * cast(llvm::Value * v, const bool sgn, JITVisitor & jit)
-            {
-                return v->getType()->isIntegerTy() ? __Cast<T, std::is_integral<T>::value, true>::get(v, sgn, jit) : __Cast<T, std::is_integral<T>::value, false>::get(v, sgn, jit);
-            }
+    template<typename T>
+    inline static llvm::Value * cast(llvm::Value * v, const bool sgn, JITVisitor & jit)
+    {
+        return v->getType()->isIntegerTy() ? __Cast<T, std::is_integral<T>::value, true>::get(v, sgn, jit) : __Cast<T, std::is_integral<T>::value, false>::get(v, sgn, jit);
+    }
+
+    /**
+     * Promote value according to Scilab's rules:
+     *  - int_X+int_Y => int_max(X,Y)
+     *  - uint_X+int_Y => uint_max(X,Y)
+     *  - int_X+uint_Y => uint_max(X,Y)
+     *  - uint_X+uint_Y => uint_max(X,Y)
+     *  - double+(u)int_X => (u)int_X
+     */
+    inline static void promoteScilabValue(const bool lsign, llvm::Value *& l, const bool rsign, llvm::Value *& r, llvm::IRBuilder<> & builder)
+    {
+        llvm::Type * lt = l->getType();
+        llvm::Type * rt = r->getType();
 
-        /**
-         * Promote value according to Scilab's rules:
-         *  - int_X+int_Y => int_max(X,Y)
-         *  - uint_X+int_Y => uint_max(X,Y)
-         *  - int_X+uint_Y => uint_max(X,Y)
-         *  - uint_X+uint_Y => uint_max(X,Y)
-         *  - double+(u)int_X => (u)int_X
-         */
-        inline static void promoteScilabValue(const bool lsign, llvm::Value *& l, const bool rsign, llvm::Value *& r, llvm::IRBuilder<> & builder)
+        if (lt != rt)
+        {
+            if (lt->isIntegerTy())
             {
-                llvm::Type * lt = l->getType();
-                llvm::Type * rt = r->getType();
-
-                if (lt != rt)
+                if (rt->isIntegerTy())
                 {
-                    if (lt->isIntegerTy())
+                    if (lt->getIntegerBitWidth() > rt->getIntegerBitWidth())
                     {
-                        if (rt->isIntegerTy())
-                        {
-                            if (lt->getIntegerBitWidth() > rt->getIntegerBitWidth())
-                            {
-                                r = rsign ? builder.CreateSExt(r, lt) : builder.CreateZExt(r, lt);
-                            }
-                            else
-                            {
-                                l = lsign ? builder.CreateSExt(l, rt) : builder.CreateZExt(l, rt);
-                            }
-                        }
-                        else
-                        {
-                            r = lsign ? builder.CreateFPToSI(r, lt) : builder.CreateFPToUI(r, lt);
-                        }
+                        r = rsign ? builder.CreateSExt(r, lt) : builder.CreateZExt(r, lt);
                     }
                     else
                     {
-                        if (rt->isIntegerTy())
-                        {
-                            l = rsign ? builder.CreateFPToSI(l, rt) : builder.CreateFPToUI(l, rt);
-                        }
-                        else
-                        {
-                            if (lt->getPrimitiveSizeInBits() > rt->getPrimitiveSizeInBits())
-                            {
-                                r = builder.CreateFPExt(r, lt);
-                            }
-                            else
-                            {
-                                l = builder.CreateFPExt(l, rt);
-                            }
-                        }
+                        l = lsign ? builder.CreateSExt(l, rt) : builder.CreateZExt(l, rt);
                     }
                 }
-            }
-
-       inline static void castInt64(llvm::Value *& v, JITVisitor & jit)
-           {
-               if (v->getType() == jit.getTy<int64_t>())
-               {
-                   v = jit.getBuilder().CreateUIToFP(v, jit.getTy<double>());
-               }
-           }
-
-       inline static void castInt1(llvm::Value *& v, JITVisitor & jit)
-           {
-               if (v->getType() == jit.getTy<bool>())
-               {
-                   v = jit.getBuilder().CreateZExt(v, jit.getTy<int32_t>());
-               }
-           }
-
-    private:
-
-       template<typename T>
-       struct __BitCastHelper
-       {
-           inline uint64_t operator()(T & x) const
-               {
-                   return (uint64_t)*reinterpret_cast<typename std::make_unsigned<T>::type *>(&x);
-               }
-       };
-
-       template<typename T>
-       struct __BitCastHelper<T *>
-       {
-           inline uint64_t operator()(T * & x) const
-               {
-                   return (uint64_t)((uintptr_t)x);
-               }
-       };
-
-    public:
-
-       template<typename T>
-       inline static uint64_t bit_cast(T && x)
-           {
-               T _x = x;
-               return __BitCastHelper<typename std::remove_reference<typename std::remove_cv<T>::type>::type>()(_x);
-           }
-
-       template<typename T>
-       inline static uint64_t bit_cast(const T & x)
-           {
-               return __BitCastHelper<typename std::remove_reference<typename std::remove_cv<T>::type>::type>()(x);
-           }
-
-
-    private:
-
-        // First bool is for if typename is integral
-        // Second is for if v is integral
-        template<typename, bool, bool>
-        struct __Cast
-        {
-            inline static llvm::Value * get(llvm::Value * v, JITVisitor & jit);
-        };
-
-        template<typename T>
-        struct __Cast<T, true, true>
-        {
-            inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+                else
                 {
-                    return jit.getBuilder().CreateIntCast(v, jit.getTy<T>(), std::is_signed<T>::value);
+                    r = lsign ? builder.CreateFPToSI(r, lt) : builder.CreateFPToUI(r, lt);
                 }
-        };
-
-        template<typename T>
-        struct __Cast<T, true, false>
-        {
-            inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+            }
+            else
+            {
+                if (rt->isIntegerTy())
                 {
-                    // Workaround for bug: http://llvm.org/bugs/show_bug.cgi?id=21130
-                    // TODO: remove it when it will be fixed in llvm trunk
-                    llvm::Type * ty = jit.getTy<int64_t>();
-                    llvm::Value * i = std::is_signed<T>::value ? jit.getBuilder().CreateFPToSI(v, ty) : jit.getBuilder().CreateFPToUI(v, ty);
-                    return jit.getBuilder().CreateIntCast(i, jit.getTy<T>(), std::is_signed<T>::value);
+                    l = rsign ? builder.CreateFPToSI(l, rt) : builder.CreateFPToUI(l, rt);
                 }
-        };
-
-        template<typename T>
-        struct __Cast<T, false, true>
-        {
-            inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+                else
                 {
-                    return sgn ? jit.getBuilder().CreateSIToFP(v, jit.getTy<T>()) : jit.getBuilder().CreateUIToFP(v, jit.getTy<T>());
+                    if (lt->getPrimitiveSizeInBits() > rt->getPrimitiveSizeInBits())
+                    {
+                        r = builder.CreateFPExt(r, lt);
+                    }
+                    else
+                    {
+                        l = builder.CreateFPExt(l, rt);
+                    }
                 }
-        };
+            }
+        }
+    }
 
-        template<typename T>
-        struct __Cast<T, false, false>
+    inline static void castInt64(llvm::Value *& v, JITVisitor & jit)
+    {
+        if (v->getType() == jit.getTy<int64_t>())
         {
-            inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
-                {
-                    return jit.getBuilder().CreateFPCast(v, jit.getTy<T>());
-                }
-        };
+            v = jit.getBuilder().CreateUIToFP(v, jit.getTy<double>());
+        }
+    }
 
-    };
-
-    template<>
-    struct jit::Cast::__BitCastHelper<double>
+    inline static void castInt1(llvm::Value *& v, JITVisitor & jit)
     {
-       inline uint64_t operator()(const double & x) const
-           {
-               return *reinterpret_cast<const uint64_t *>(&x);
-           }
-    };
-
-    // try to find the Scilab type in operation
-    template<bool, bool, typename, typename>
-    struct __ScilabType_Helper;
-
-    template<bool, typename, typename>
-    struct __ScilabTypeII_Helper;
-
-    template<bool, typename, typename>
-    struct __GreaterType_Helper;
+        if (v->getType() == jit.getTy<bool>())
+        {
+            v = jit.getBuilder().CreateZExt(v, jit.getTy<int32_t>());
+        }
+    }
 
-    template<typename, typename>
-    struct __GreaterType;
+private:
 
-    template<typename T, typename U>
-    struct __GreaterType_Helper<true, T, U>
+    template<typename T>
+    struct __BitCastHelper
     {
-        typedef T type;
+        inline uint64_t operator()(T & x) const
+        {
+            return (uint64_t) * reinterpret_cast<typename std::make_unsigned<T>::type *>(&x);
+        }
     };
 
-    template<typename T, typename U>
-    struct __GreaterType_Helper<false, T, U>
+    template<typename T>
+    struct __BitCastHelper<T *>
     {
-        typedef U type;
+        inline uint64_t operator()(T * & x) const
+        {
+            return (uint64_t)((uintptr_t)x);
+        }
     };
 
-    template<typename T, typename U>
-    struct __GreaterType
-    {
-        typedef typename __GreaterType_Helper<sizeof(T) >= sizeof(U), T, U>::type type;
-    };
+public:
 
-    template<typename T, typename U>
-    struct __ScilabTypeII_Helper<true, T, U>
+    template<typename T>
+    inline static uint64_t bit_cast(T && x)
     {
-        typedef typename std::make_unsigned<typename __GreaterType<T, U>::type>::type type;
-    };
+        T _x = x;
+        return __BitCastHelper<typename std::remove_reference<typename std::remove_cv<T>::type>::type>()(_x);
+    }
 
-    template<typename T, typename U>
-    struct __ScilabTypeII_Helper<false, T, U>
+    template<typename T>
+    inline static uint64_t bit_cast(const T & x)
     {
-        typedef typename __GreaterType<T, U>::type type;
-    };
+        return __BitCastHelper<typename std::remove_reference<typename std::remove_cv<T>::type>::type>()(x);
+    }
 
-    template<typename T, typename U>
-    struct __ScilabTypeII
-    {
-        typedef typename __ScilabTypeII_Helper<std::is_unsigned<T>::value || std::is_unsigned<U>::value, T, U>::type type;
-    };
 
-    template<typename T, typename U>
-    struct __ScilabType_Helper<true, true, T, U>
-    {
-        typedef typename __ScilabTypeII<T, U>::type type;
-    };
+private:
 
-    template<typename U>
-    struct __ScilabType_Helper<true, true, bool, U>
+    // First bool is for if typename is integral
+    // Second is for if v is integral
+    template<typename, bool, bool>
+    struct __Cast
     {
-        typedef U type;
+        inline static llvm::Value * get(llvm::Value * v, JITVisitor & jit);
     };
 
     template<typename T>
-    struct __ScilabType_Helper<true, true, T, bool>
+    struct __Cast<T, true, true>
     {
-        typedef T type;
+        inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+        {
+            return jit.getBuilder().CreateIntCast(v, jit.getTy<T>(), std::is_signed<T>::value);
+        }
     };
 
-    template<>
-    struct __ScilabType_Helper<true, true, bool, bool>
+    template<typename T>
+    struct __Cast<T, true, false>
     {
-        typedef bool type;
+        inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+        {
+            // Workaround for bug: http://llvm.org/bugs/show_bug.cgi?id=21130
+            // TODO: remove it when it will be fixed in llvm trunk
+            llvm::Type * ty = jit.getTy<int64_t>();
+            llvm::Value * i = std::is_signed<T>::value ? jit.getBuilder().CreateFPToSI(v, ty) : jit.getBuilder().CreateFPToUI(v, ty);
+            return jit.getBuilder().CreateIntCast(i, jit.getTy<T>(), std::is_signed<T>::value);
+        }
     };
 
-    template<typename T, typename U>
-    struct __ScilabType_Helper<true, false, T, U>
+    template<typename T>
+    struct __Cast<T, false, true>
     {
-        typedef T type;
+        inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+        {
+            return sgn ? jit.getBuilder().CreateSIToFP(v, jit.getTy<T>()) : jit.getBuilder().CreateUIToFP(v, jit.getTy<T>());
+        }
     };
 
-    template<typename U>
-    struct __ScilabType_Helper<true, false, bool, U>
+    template<typename T>
+    struct __Cast<T, false, false>
     {
-        typedef U type;
+        inline static llvm::Value * get(llvm::Value * v, const bool sgn, JITVisitor & jit)
+        {
+            return jit.getBuilder().CreateFPCast(v, jit.getTy<T>());
+        }
     };
 
-    template<typename T, typename U>
-    struct __ScilabType_Helper<false, true, T, U>
-    {
-        typedef U type;
-    };
+};
 
-    template<typename T>
-    struct __ScilabType_Helper<false, true, T, bool>
+template<>
+struct jit::Cast::__BitCastHelper<double>
+{
+    inline uint64_t operator()(const double & x) const
     {
-        typedef T type;
-    };
+        return *reinterpret_cast<const uint64_t *>(&x);
+    }
+};
 
-    template<typename T, typename U>
-    struct __ScilabType_Helper<false, false, T, U>
-    {
-        typedef T type;
-    };
+// try to find the Scilab type in operation
+template<bool, bool, typename, typename>
+struct __ScilabType_Helper;
 
-    template<typename T, typename U>
-    struct ScilabType
-    {
-        typedef typename __ScilabType_Helper<std::is_integral<T>::value, std::is_integral<U>::value, T, U>::type type;
-    };
+template<bool, typename, typename>
+struct __ScilabTypeII_Helper;
 
-    template<typename T>
-    struct is_pure_integral
-    {
-       const static bool value = std::is_integral<T>::value && !std::is_same<T, bool>::value;
-    };
+template<bool, typename, typename>
+struct __GreaterType_Helper;
+
+template<typename, typename>
+struct __GreaterType;
+
+template<typename T, typename U>
+struct __GreaterType_Helper<true, T, U>
+{
+    typedef T type;
+};
+
+template<typename T, typename U>
+struct __GreaterType_Helper<false, T, U>
+{
+    typedef U type;
+};
+
+template<typename T, typename U>
+struct __GreaterType
+{
+    typedef typename __GreaterType_Helper<sizeof(T) >= sizeof(U), T, U >::type type;
+};
+
+template<typename T, typename U>
+struct __ScilabTypeII_Helper<true, T, U>
+{
+    typedef typename std::make_unsigned<typename __GreaterType<T, U>::type>::type type;
+};
+
+template<typename T, typename U>
+struct __ScilabTypeII_Helper<false, T, U>
+{
+    typedef typename __GreaterType<T, U>::type type;
+};
+
+template<typename T, typename U>
+struct __ScilabTypeII
+{
+    typedef typename __ScilabTypeII_Helper < std::is_unsigned<T>::value || std::is_unsigned<U>::value, T, U >::type type;
+};
+
+template<typename T, typename U>
+struct __ScilabType_Helper<true, true, T, U>
+{
+    typedef typename __ScilabTypeII<T, U>::type type;
+};
+
+template<typename U>
+struct __ScilabType_Helper<true, true, bool, U>
+{
+    typedef U type;
+};
+
+template<typename T>
+struct __ScilabType_Helper<true, true, T, bool>
+{
+    typedef T type;
+};
+
+template<>
+struct __ScilabType_Helper<true, true, bool, bool>
+{
+    typedef bool type;
+};
+
+template<typename T, typename U>
+struct __ScilabType_Helper<true, false, T, U>
+{
+    typedef T type;
+};
+
+template<typename U>
+struct __ScilabType_Helper<true, false, bool, U>
+{
+    typedef U type;
+};
+
+template<typename T, typename U>
+struct __ScilabType_Helper<false, true, T, U>
+{
+    typedef U type;
+};
+
+template<typename T>
+struct __ScilabType_Helper<false, true, T, bool>
+{
+    typedef T type;
+};
+
+template<typename T, typename U>
+struct __ScilabType_Helper<false, false, T, U>
+{
+    typedef T type;
+};
+
+template<typename T, typename U>
+struct ScilabType
+{
+    typedef typename __ScilabType_Helper<std::is_integral<T>::value, std::is_integral<U>::value, T, U>::type type;
+};
+
+template<typename T>
+struct is_pure_integral
+{
+    const static bool value = std::is_integral<T>::value && !std::is_same<T, bool>::value;
+};
 
 } // namespace jit
 
index 5a7c8bc..c625b12 100644 (file)
 namespace jit
 {
 
-    class JITVisitor;
-    
-    class Debug
-    {
-
-    public:
-
-       static void printI8(JITVisitor & jit, llvm::Value * x);
-       static void printUI8(JITVisitor & jit, llvm::Value * x);
-       static void printI16(JITVisitor & jit, llvm::Value * x);
-       static void printUI16(JITVisitor & jit, llvm::Value * x);
-       static void printI32(JITVisitor & jit, llvm::Value * x);
-       static void printUI32(JITVisitor & jit, llvm::Value * x);
-       static void printI64(JITVisitor & jit, llvm::Value * x);
-       static void printUI64(JITVisitor & jit, llvm::Value * x);
-       static void printD(JITVisitor & jit, llvm::Value * x);
-       static void printB(JITVisitor & jit, llvm::Value * x);
-
-    };
+class JITVisitor;
+
+class Debug
+{
+
+public:
+
+    static void printI8(JITVisitor & jit, llvm::Value * x);
+    static void printUI8(JITVisitor & jit, llvm::Value * x);
+    static void printI16(JITVisitor & jit, llvm::Value * x);
+    static void printUI16(JITVisitor & jit, llvm::Value * x);
+    static void printI32(JITVisitor & jit, llvm::Value * x);
+    static void printUI32(JITVisitor & jit, llvm::Value * x);
+    static void printI64(JITVisitor & jit, llvm::Value * x);
+    static void printUI64(JITVisitor & jit, llvm::Value * x);
+    static void printD(JITVisitor & jit, llvm::Value * x);
+    static void printB(JITVisitor & jit, llvm::Value * x);
+    static void printPtr(JITVisitor & jit, llvm::Value * x);
+
+};
 
 } // namespace jit
 
index 6adbf4f..3cf6516 100644 (file)
 
 namespace jit
 {
-    template<typename T>
-    class JITArrayofT : public JITArrayof
-    {
+template<typename T>
+class JITArrayofT : public JITArrayof
+{
+
+public:
+
+    JITArrayofT(llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const std::string & name) : JITArrayof(data, rows, cols, refCount, name) { }
+
+    JITArrayofT(JITVisitor & jit, const std::string & name) : JITArrayof(jit.getAlloca<T *>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), name) { }
 
-    public:
+    JITArrayofT(JITVisitor & jit, const std::string & name, const bool init) : JITArrayof(init ? jit.getValue((T *)nullptr, true) : jit.getAlloca<T *>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), name) { }
 
-        JITArrayofT(llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const std::string & name) : JITArrayof(data, rows, cols, refCount, name) { }
+    JITArrayofT(JITVisitor & jit, const T * data, const int64_t rows, const int64_t cols, const std::string & name) : JITArrayof(jit.getValue(data, true), jit.getValue(rows, true), jit.getValue(cols, true), jit.getValue<int64_t>(0), name) { }
+
+    JITArrayofT(JITVisitor & jit, llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const std::string & name) : JITArrayof(jit, data, rows, cols, refCount, name) { }
+
+    JITArrayofT(JITVisitor & jit, llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const bool alloc, const std::string & name) : JITArrayof(jit, data, rows, cols, refCount, alloc, name) { }
+
+    virtual ~JITArrayofT() { }
+
+    bool isSigned() const override
+    {
+        return std::is_integral<T>::value && std::is_signed<T>::value;
+    }
+
+};
+
+typedef JITArrayofT<double> JITArrayofDouble;
+typedef JITArrayofT<int8_t> JITArrayofInt8;
+typedef JITArrayofT<int16_t> JITArrayofInt16;
+typedef JITArrayofT<int32_t> JITArrayofInt32;
+typedef JITArrayofT<int64_t> JITArrayofInt64;
+typedef JITArrayofT<uint8_t> JITArrayofUInt8;
+typedef JITArrayofT<uint16_t> JITArrayofUInt16;
+typedef JITArrayofT<uint32_t> JITArrayofUInt32;
+typedef JITArrayofT<uint64_t> JITArrayofUInt64;
+typedef JITArrayofT<int32_t> JITArrayofBool;
+typedef JITArrayofT<wchar_t> JITArrayofString;
+
+class JITArrayofComplex : public JITArrayof
+{
 
-        JITArrayofT(JITVisitor & jit, const std::string & name) : JITArrayof(jit.getAlloca<T *>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), name) { }
+    llvm::Value * imag;
 
-        JITArrayofT(JITVisitor & jit, const std::string & name, const bool init) : JITArrayof(init ? jit.getValue((T *)nullptr, true) : jit.getAlloca<T *>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), name) { }
+public:
 
-        JITArrayofT(JITVisitor & jit, const T * data, const int64_t rows, const int64_t cols, const std::string & name) : JITArrayof(jit.getValue(data, true), jit.getValue(rows, true), jit.getValue(cols, true), jit.getValue<int64_t>(0), name) { }
+    JITArrayofComplex(llvm::Value * const _real, llvm::Value * const _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const std::string & _name) : JITArrayof(_real, _rows, _cols, _refCount, _name), imag(_imag)
+    {
+        if (!_name.empty())
+        {
+            imag->setName(_name);
+        }
+    }
 
-        JITArrayofT(JITVisitor & jit, llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const std::string & name) : JITArrayof(jit, data, rows, cols, refCount, name) { }
+    JITArrayofComplex(JITVisitor & jit, const std::string & name) : JITArrayof(jit.getAlloca<double *>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), name), imag(jit.getAlloca<double *>())
+    {
+        if (!name.empty())
+        {
+            imag->setName(name);
+        }
+    }
 
-        JITArrayofT(JITVisitor & jit, llvm::Value * const data, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const bool alloc, const std::string & name) : JITArrayof(jit, data, rows, cols, refCount, alloc, name) { }
+    JITArrayofComplex(JITVisitor & jit, const std::string & name, const bool init) : JITArrayof(init ? jit.getValue((double *)nullptr, true) : jit.getAlloca<double *>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), name), imag(init ? jit.getValue((double *)nullptr, true) : jit.getAlloca<double *>())
+    {
+        if (!name.empty())
+        {
+            imag->setName(name);
+        }
+    }
 
-        virtual ~JITArrayofT() { }
+    JITArrayofComplex(JITVisitor & jit, const double * _real, const double * _imag, const int64_t _rows, const int64_t _cols, const std::string & _name) : JITArrayof(jit.getValue(_real, true), jit.getValue(_rows, true), jit.getValue(_cols, true), jit.getValue<int64_t>(0), _name), imag(jit.getValue(_imag, true))
+    {
+        if (!_name.empty())
+        {
+            imag->setName(_name);
+        }
+    }
 
-        bool isSigned() const override
-            {
-                return std::is_integral<T>::value && std::is_signed<T>::value;
-            }
+    JITArrayofComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * const _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const std::string & _name) : JITArrayof(jit, _real, _rows, _cols, _refCount, _name), imag(_imag)
+    {
+        if (!_name.empty())
+        {
+            imag->setName(_name);
+        }
+    }
 
-    };
+    JITArrayofComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const bool _alloc, const std::string & _name) : JITArrayof(jit, _real, _rows, _cols, _refCount, _alloc, _name), imag(jit.getValue(_imag, _alloc))
+    {
+        if (!_name.empty())
+        {
+            imag->setName(_name);
+        }
+    }
 
-    typedef JITArrayofT<double> JITArrayofDouble;
-    typedef JITArrayofT<int8_t> JITArrayofInt8;
-    typedef JITArrayofT<int16_t> JITArrayofInt16;
-    typedef JITArrayofT<int32_t> JITArrayofInt32;
-    typedef JITArrayofT<int64_t> JITArrayofInt64;
-    typedef JITArrayofT<uint8_t> JITArrayofUInt8;
-    typedef JITArrayofT<uint16_t> JITArrayofUInt16;
-    typedef JITArrayofT<uint32_t> JITArrayofUInt32;
-    typedef JITArrayofT<uint64_t> JITArrayofUInt64;
-    typedef JITArrayofT<int32_t> JITArrayofBool;
-    typedef JITArrayofT<wchar_t> JITArrayofString;
+    virtual ~JITArrayofComplex() { }
 
-    class JITArrayofComplex : public JITArrayof
+    bool isSigned() const override
+    {
+        return false;
+    }
+    bool isComplex() const override
     {
+        return true;
+    }
+
+    llvm::Value * loadReal(JITVisitor & jit) override;
+    llvm::Value * loadImag(JITVisitor & jit) override;
+    llvm::Value * getImag(JITVisitor & jit) const override;
+
+    std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit) override;
+    void storeImag(JITVisitor & jit, llvm::Value * _imag) override;
+    void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> reim) override;
+    void setImag(llvm::Value * imag) override;
 
-        llvm::Value * imag;
-
-    public:
-
-        JITArrayofComplex(llvm::Value * const _real, llvm::Value * const _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const std::string & _name) : JITArrayof(_real, _rows, _cols, _refCount, _name), imag(_imag)
-            {
-                if (!_name.empty())
-                {
-                    imag->setName(_name);
-                }
-            }
-
-        JITArrayofComplex(JITVisitor & jit, const std::string & name) : JITArrayof(jit.getAlloca<double *>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), jit.getAlloca<int64_t>(), name), imag(jit.getAlloca<double *>())
-            {
-                if (!name.empty())
-                {
-                    imag->setName(name);
-                }
-            }
-
-        JITArrayofComplex(JITVisitor & jit, const std::string & name, const bool init) : JITArrayof(init ? jit.getValue((double *)nullptr, true) : jit.getAlloca<double *>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), init ? jit.getValue(int64_t(0), true) : jit.getAlloca<int64_t>(), name), imag(init ? jit.getValue((double *)nullptr, true) : jit.getAlloca<double *>())
-            {
-                if (!name.empty())
-                {
-                    imag->setName(name);
-                }
-            }
-
-        JITArrayofComplex(JITVisitor & jit, const double * _real, const double * _imag, const int64_t _rows, const int64_t _cols, const std::string & _name) : JITArrayof(jit.getValue(_real, true), jit.getValue(_rows, true), jit.getValue(_cols, true), jit.getValue<int64_t>(0), _name), imag(jit.getValue(_imag, true))
-            {
-                if (!_name.empty())
-                {
-                    imag->setName(_name);
-                }
-            }
-
-        JITArrayofComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * const _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const std::string & _name) : JITArrayof(jit, _real, _rows, _cols, _refCount, _name), imag(_imag)
-            {
-                if (!_name.empty())
-                {
-                    imag->setName(_name);
-                }
-            }
-
-        JITArrayofComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * _imag, llvm::Value * const _rows, llvm::Value * const _cols, llvm::Value * const _refCount, const bool _alloc, const std::string & _name) : JITArrayof(jit, _real, _rows, _cols, _refCount, _alloc, _name), imag(jit.getValue(_imag, _alloc))
-            {
-                if (!_name.empty())
-                {
-                    imag->setName(_name);
-                }
-            }
-
-        virtual ~JITArrayofComplex() { }
-
-       bool isSigned() const override { return false; }
-       bool isComplex() const override { return true; }
-
-        llvm::Value * loadReal(JITVisitor & jit) override;
-        llvm::Value * loadImag(JITVisitor & jit) override;
-        llvm::Value * getImag(JITVisitor & jit) const override;
-
-        std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit) override;
-        void storeImag(JITVisitor & jit, llvm::Value * _imag) override;
-        void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> reim) override;
-        void setImag(llvm::Value * imag) override;
-
-    };
+};
 
 }
 
index a81809a..901da70 100644 (file)
 namespace jit
 {
 
-    class JITInfo
+class JITInfo
+{
+    const std::string name;
+    analysis::TITypeSignatureTuple inSignature;
+    analysis::TITypeSignatureTuple outSignature;
+    void * wrapper;
+
+public:
+
+    JITInfo(const std::string & _name) : name(_name), wrapper(nullptr) { }
+
+    inline const std::string & getName() const
     {
-       const std::string name;
-       analysis::TITypeSignatureTuple inSignature;
-       analysis::TITypeSignatureTuple outSignature;
-       void * wrapper;
+        return name;
+    }
 
-    public:
+    inline void setWrapper(void * _wrapper)
+    {
+        wrapper = _wrapper;
+    }
 
-       JITInfo(const std::string & _name) : name(_name), wrapper(nullptr) { }
+    inline void * getWrapper() const
+    {
+        return wrapper;
+    }
 
-       inline const std::string & getName() const
-           {
-               return name;
-           }
-       
-       inline void setWrapper(void * _wrapper)
-           {
-               wrapper = _wrapper;
-           }
+    inline void addToOutSignature(const bool scalar, const analysis::TIType::Type type)
+    {
+        outSignature.emplace(scalar, type);
+    }
 
-       inline void * getWrapper() const
-           {
-               return wrapper;
-           }
+    inline const analysis::TITypeSignatureTuple & getOutSignature() const
+    {
+        return outSignature;
+    }
 
-       inline void addToOutSignature(const bool scalar, const analysis::TIType::Type type)
-           {
-               outSignature.emplace(scalar, type);
-           }
-       
-       inline const analysis::TITypeSignatureTuple & getOutSignature() const
-           {
-               return outSignature;
-           }
+    inline void addToInSignature(const bool scalar, const analysis::TIType::Type type)
+    {
+        inSignature.emplace(scalar, type);
+    }
 
-       inline void addToInSignature(const bool scalar, const analysis::TIType::Type type)
-           {
-               inSignature.emplace(scalar, type);
-           }
-       
-       inline const analysis::TITypeSignatureTuple & getInSignature() const
-           {
-               return inSignature;
-           }
-    };
+    inline const analysis::TITypeSignatureTuple & getInSignature() const
+    {
+        return inSignature;
+    }
+};
 
 } // namespace jit
 
index bee2d18..c8f350a 100644 (file)
 namespace jit
 {
 
-    template<typename T>
-    class JITScalT : public JITScalar
+template<typename T>
+class JITScalT : public JITScalar
+{
+
+public:
+
+    JITScalT(JITVisitor & jit, const std::string & name) : JITScalar(jit.getAlloca<T>(), true, name) { }
+
+    JITScalT(JITVisitor & jit, const T value, const bool alloc, const std::string & name) : JITScalar(jit.getValue(value, alloc), alloc, name) { }
+
+    JITScalT(JITVisitor & jit, llvm::Value * const data, const bool alloc, const std::string & name) : JITScalar(jit.getValue(data, alloc, name), alloc, name) { }
+
+    JITScalT(llvm::Value * const data, const bool alloc = false, const std::string & name = "") : JITScalar(data, alloc, name) { }
+
+    virtual ~JITScalT() { }
+
+    bool isSigned() const override
+    {
+        return std::is_integral<T>::value && std::is_signed<T>::value;
+    }
+};
+
+typedef JITScalT<double> JITScalDouble;
+typedef JITScalT<int8_t> JITScalInt8;
+typedef JITScalT<int16_t> JITScalInt16;
+typedef JITScalT<int32_t> JITScalInt32;
+typedef JITScalT<int64_t> JITScalInt64;
+typedef JITScalT<uint8_t> JITScalUInt8;
+typedef JITScalT<uint16_t> JITScalUInt16;
+typedef JITScalT<uint32_t> JITScalUInt32;
+typedef JITScalT<uint64_t> JITScalUInt64;
+typedef JITScalT<int32_t> JITScalBool;
+typedef JITScalT<wchar_t> JITScalString;
+
+class JITScalComplex : public JITScalar
+{
+
+    llvm::Value * imag;
+
+public:
+
+    JITScalComplex() : JITScalar() { }
+
+    JITScalComplex(JITVisitor & jit, const std::string & name) : JITScalar(jit.getAlloca<double>(), true, name + "_re"), imag(jit.getAlloca<double>(name + "_im"))
+    {
+    }
+
+    JITScalComplex(JITVisitor & jit, const std::complex<double> value, const bool alloc, const std::string & name) : JITScalar(jit.getValue(value.real(), alloc), alloc, name), imag(jit.getValue(value.imag(), alloc))
     {
-       
-    public:
-
-       JITScalT(JITVisitor & jit, const std::string & name) : JITScalar(jit.getAlloca<T>(), true, name) { }
-
-       JITScalT(JITVisitor & jit, const T value, const bool alloc, const std::string & name) : JITScalar(jit.getValue(value, alloc), alloc, name) { }
-       
-       JITScalT(JITVisitor & jit, llvm::Value * const data, const bool alloc, const std::string & name) : JITScalar(jit.getValue(data, alloc, name), alloc, name) { }
-
-       JITScalT(llvm::Value * const data, const bool alloc = false, const std::string & name = "") : JITScalar(data, alloc, name) { }
-
-       virtual ~JITScalT() { }
-
-       bool isSigned() const override
-           {
-               return std::is_integral<T>::value && std::is_signed<T>::value;
-           }
-    };
-
-    typedef JITScalT<double> JITScalDouble;
-    typedef JITScalT<int8_t> JITScalInt8;
-    typedef JITScalT<int16_t> JITScalInt16;
-    typedef JITScalT<int32_t> JITScalInt32;
-    typedef JITScalT<int64_t> JITScalInt64;
-    typedef JITScalT<uint8_t> JITScalUInt8;
-    typedef JITScalT<uint16_t> JITScalUInt16;
-    typedef JITScalT<uint32_t> JITScalUInt32;
-    typedef JITScalT<uint64_t> JITScalUInt64;
-    typedef JITScalT<int32_t> JITScalBool;
-    typedef JITScalT<wchar_t> JITScalString;
-
-    class JITScalComplex : public JITScalar
+        if (!name.empty())
+        {
+            imag->setName(name);
+        }
+    }
+
+    JITScalComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * const _imag, const bool alloc, const std::string & name) : JITScalar(jit.getValue(_real, alloc, name), alloc, name), imag(jit.getValue(_imag, alloc, name))
     {
+        if (!name.empty())
+        {
+            imag->setName(name);
+        }
+    }
+
+    JITScalComplex(llvm::Value * const _real, llvm::Value * const _imag, const bool alloc = false, const std::string & name = "") : JITScalar(_real, alloc, name), imag(_imag)
+    {
+        if (!name.empty())
+        {
+            imag->setName(name);
+        }
+    }
+
+    virtual ~JITScalComplex() { }
+
+    bool isSigned() const override
+    {
+        return false;
+    }
+    bool isComplex() const override
+    {
+        return true;
+    }
+
+    llvm::Value * loadReal(JITVisitor & jit) override;
+    llvm::Value * loadImag(JITVisitor & jit) override;
+    llvm::Value * getImag(JITVisitor & jit) const override;
+
+    std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit) override;
+    void storeImag(JITVisitor & jit, llvm::Value * _imag) override;
+    void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> reim) override;
+    void setImag(llvm::Value * imag) override;
+
 
-       llvm::Value * imag;
-       
-    public:
-
-       JITScalComplex() : JITScalar() { }
-       
-       JITScalComplex(JITVisitor & jit, const std::string & name) : JITScalar(jit.getAlloca<double>(), true, name + "_re"), imag(jit.getAlloca<double>(name + "_im"))
-           {
-           }
-
-       JITScalComplex(JITVisitor & jit, const std::complex<double> value, const bool alloc, const std::string & name) : JITScalar(jit.getValue(value.real(), alloc), alloc, name), imag(jit.getValue(value.imag(), alloc))
-           {
-               if (!name.empty())
-               {
-                   imag->setName(name);
-               }
-           }
-       
-       JITScalComplex(JITVisitor & jit, llvm::Value * const _real, llvm::Value * const _imag, const bool alloc, const std::string & name) : JITScalar(jit.getValue(_real, alloc, name), alloc, name), imag(jit.getValue(_imag, alloc, name))
-           {
-               if (!name.empty())
-               {
-                   imag->setName(name);
-               }
-           }
-
-       JITScalComplex(llvm::Value * const _real, llvm::Value * const _imag, const bool alloc = false, const std::string & name = "") : JITScalar(_real, alloc, name), imag(_imag)
-           {
-               if (!name.empty())
-               {
-                   imag->setName(name);
-               }
-           }
-
-       virtual ~JITScalComplex() { }
-
-       bool isSigned() const override { return false; }
-       bool isComplex() const override { return true; }
-
-       llvm::Value * loadReal(JITVisitor & jit) override;
-       llvm::Value * loadImag(JITVisitor & jit) override;
-       llvm::Value * getImag(JITVisitor & jit) const override;
-       
-       std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit) override;
-       void storeImag(JITVisitor & jit, llvm::Value * _imag) override;
-       void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> reim) override;
-       void setImag(llvm::Value * imag) override;
-       
-       
-       static llvm::Type * getCpx128Ty(JITVisitor & jit);
-    };
+    static llvm::Type * getCpx128Ty(JITVisitor & jit);
+};
 }
 
 #endif // __JIT_SCALARS_HXX__
index a7d383e..092af20 100644 (file)
 
 namespace jit
 {
-    class JITScilabVal
-    {
+class JITScilabVal
+{
+
+public:
 
-    public:
+    virtual ~JITScilabVal() { }
 
-       virtual ~JITScilabVal() { }
-       
-       virtual bool isValid() const = 0;
-       virtual llvm::Value * getRows(JITVisitor & jit) const = 0;
-       virtual llvm::Value * getCols(JITVisitor & jit) const = 0;
-       virtual llvm::Value * loadRows(JITVisitor & jit) const = 0;
-       virtual llvm::Value * loadCols(JITVisitor & jit) const = 0;
-       virtual void setData(llvm::Value * data) = 0;
-       virtual void setRows(llvm::Value * rows) = 0;
-       virtual void setCols(llvm::Value * cols) = 0;
-       virtual void setRefCount(llvm::Value * refCount) = 0;
-       virtual void storeRows(JITVisitor & jit, llvm::Value * rows) = 0;
-       virtual void storeCols(JITVisitor & jit, llvm::Value * cols) = 0;
-       virtual bool isScalar() const = 0;
-       virtual llvm::Value * getData(JITVisitor & jit) const = 0;
-       virtual llvm::Value * getReal(JITVisitor & jit) const { return getData(jit); }
-       virtual llvm::Value * getImag(JITVisitor & jit) const { return nullptr; }
-       virtual llvm::Value * loadData(JITVisitor & jit) = 0;
-       virtual llvm::Value * loadReal(JITVisitor & jit) { return loadData(jit); }
-       virtual llvm::Value * loadImag(JITVisitor & jit) { return nullptr; }
-       virtual std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit) { return std::pair<llvm::Value *, llvm::Value *>(nullptr, nullptr); }
-       virtual void storeData(JITVisitor & jit, llvm::Value * data) = 0;
-       virtual void storeReal(JITVisitor & jit, llvm::Value * real) { storeData(jit, real); }
-       virtual void storeImag(JITVisitor & jit, llvm::Value * imag) { }
-       virtual void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> imag) { }
-       virtual void setReal(llvm::Value * real) { setData(real); }
-       virtual void setImag(llvm::Value * imag) { }
-       //virtual types::InternalType::ScilabId getScilabId() const = 0;
-       //virtual void setScilabId(const types::InternalType::ScilabId id) = 0;
-       virtual llvm::Value * getRefCount(JITVisitor & jit) const = 0;
-       virtual llvm::Value * loadRefCount(JITVisitor & jit) const = 0;
-       virtual void incRefCount(JITVisitor & jit) = 0;
-       virtual void decRefCount(JITVisitor & jit) = 0;
-       virtual bool isSigned() const = 0;
-       virtual bool isComplex() const { return false; }
-    };
+    virtual bool isValid() const = 0;
+    virtual llvm::Value * getRows(JITVisitor & jit) const = 0;
+    virtual llvm::Value * getCols(JITVisitor & jit) const = 0;
+    virtual llvm::Value * loadRows(JITVisitor & jit) const = 0;
+    virtual llvm::Value * loadCols(JITVisitor & jit) const = 0;
+    virtual void setData(llvm::Value * data) = 0;
+    virtual void setRows(llvm::Value * rows) = 0;
+    virtual void setCols(llvm::Value * cols) = 0;
+    virtual void setRefCount(llvm::Value * refCount) = 0;
+    virtual void storeRows(JITVisitor & jit, llvm::Value * rows) = 0;
+    virtual void storeCols(JITVisitor & jit, llvm::Value * cols) = 0;
+    virtual bool isScalar() const = 0;
+    virtual llvm::Value * getData(JITVisitor & jit) const = 0;
+    virtual llvm::Value * getReal(JITVisitor & jit) const
+    {
+        return getData(jit);
+    }
+    virtual llvm::Value * getImag(JITVisitor & jit) const
+    {
+        return nullptr;
+    }
+    virtual llvm::Value * loadData(JITVisitor & jit) = 0;
+    virtual llvm::Value * loadReal(JITVisitor & jit)
+    {
+        return loadData(jit);
+    }
+    virtual llvm::Value * loadImag(JITVisitor & jit)
+    {
+        return nullptr;
+    }
+    virtual std::pair<llvm::Value *, llvm::Value *> loadReIm(JITVisitor & jit)
+    {
+        return std::pair<llvm::Value *, llvm::Value *>(nullptr, nullptr);
+    }
+    virtual void storeData(JITVisitor & jit, llvm::Value * data) = 0;
+    virtual void storeReal(JITVisitor & jit, llvm::Value * real)
+    {
+        storeData(jit, real);
+    }
+    virtual void storeImag(JITVisitor & jit, llvm::Value * imag) { }
+    virtual void storeReIm(JITVisitor & jit, std::pair<llvm::Value *, llvm::Value *> imag) { }
+    virtual void setReal(llvm::Value * real)
+    {
+        setData(real);
+    }
+    virtual void setImag(llvm::Value * imag) { }
+    //virtual types::InternalType::ScilabId getScilabId() const = 0;
+    //virtual void setScilabId(const types::InternalType::ScilabId id) = 0;
+    virtual llvm::Value * getRefCount(JITVisitor & jit) const = 0;
+    virtual llvm::Value * loadRefCount(JITVisitor & jit) const = 0;
+    virtual void incRefCount(JITVisitor & jit) = 0;
+    virtual void decRefCount(JITVisitor & jit) = 0;
+    virtual bool isSigned() const = 0;
+    virtual bool isComplex() const
+    {
+        return false;
+    }
+};
 
 }
 
index 3533938..3b9500f 100644 (file)
@@ -53,6 +53,7 @@
 #include "allvar.hxx"
 #include "AnalysisVisitor.hxx"
 #include "JITInfo.hxx"
+#include "Debug.hxx"
 
 #include "calls/JITBinOpCall.hxx"
 #include "calls/JITUnaryOpCall.hxx"
@@ -85,7 +86,7 @@ class EXTERN_AST JITVisitor : public ast::ConstVisitor, public analysis::FBlockE
             int32_t boolean;
             double cpx[2];
             void * ptr;
-           void * cpx_ptr[2];
+            void * cpx_ptr[2];
         };
 
         analysis::TIType::Type type;
@@ -140,7 +141,7 @@ class EXTERN_AST JITVisitor : public ast::ConstVisitor, public analysis::FBlockE
     std::unordered_map<std::string, llvm::Value *> specialVars;
     std::unordered_map<std::string, llvm::Function *> llvmFunctions;
     std::unordered_map<uint64_t, JITInfo> info;
-    
+
 public:
 
     JITAddition addition;
@@ -241,7 +242,7 @@ public:
 
     inline llvm::Type * getTy(const analysis::TIType & ty, const unsigned char level = 0) const
     {
-       return getTy(ty.type);
+        return getTy(ty.type);
     }
 
     inline unsigned int getTySizeInBytes(const llvm::Type * ty) const
@@ -409,7 +410,7 @@ public:
         {
             return temps[id + 1];
         }
-       return temps[0];
+        return temps[0];
     }
 
     inline void addGlobal(const std::string & name, llvm::GlobalVariable * gv)
@@ -449,27 +450,32 @@ public:
 
     inline void addFunction(const std::string & name, llvm::Function * F)
     {
-       llvmFunctions.emplace(name, F);
+        llvmFunctions.emplace(name, F);
     }
-    
+
     inline llvm::Function * getFunction(const std::string & name) const
     {
-       auto i = llvmFunctions.find(name);
-       if (i != llvmFunctions.end())
-       {
-           return i->second;
-       }
-       return nullptr;
+        auto i = llvmFunctions.find(name);
+        if (i != llvmFunctions.end())
+        {
+            return i->second;
+        }
+        return nullptr;
     }
 
     inline const JITInfo * getInfo(const uint64_t id)
     {
-       auto i = info.find(id);
-       if (i != info.end())
-       {
-           return &(i->second);
-       }
-       return nullptr;
+        auto i = info.find(id);
+        if (i != info.end())
+        {
+            return &(i->second);
+        }
+        return nullptr;
+    }
+
+    inline const JITSymbolMap & getVariables() const
+    {
+        return variables;
     }
 
     void makeCallFromScilab(const uint64_t functionId, const types::typed_list & in, types::typed_list & out);
@@ -484,9 +490,10 @@ public:
     JITScilabPtr getMatrix(llvm::Value * const re, llvm::Value * const im, llvm::Value * const rows, llvm::Value * const cols, llvm::Value * const refCount, const analysis::TIType::Type ty, const bool alloc, const std::string & name);
     JITScilabPtr getMatrix(const analysis::TIType::Type ty, const std::string & name, const bool init = false);
     JITScilabPtr getMatrix(const analysis::TypeLocal & ty, const std::string & name, const bool init = false);
+    llvm::Value * getPtrFromIndex(const ast::CallExp & ce);
     void reset();
     void compile();
-    
+
     llvm::FunctionType * getFunctionType(const analysis::TIType & out, const std::vector<const analysis::TIType *> & types);
 
 private:
@@ -520,12 +527,12 @@ private:
     inline void makeCpxArg(std::vector<llvm::Value *> & args, types::Double * pDbl)
     {
         double * const x = pDbl->get();
-       double * const y = pDbl->getImg();
+        double * const y = pDbl->getImg();
         const int64_t r = pDbl->getRows();
         const int64_t c = pDbl->getCols();
         const int64_t refc = pDbl->getRef();
         args.emplace_back(getValue(x));
-       args.emplace_back(getValue(y));
+        args.emplace_back(getValue(y));
         args.emplace_back(getValue(r));
         args.emplace_back(getValue(c));
         args.emplace_back(getValue(refc));
@@ -580,7 +587,6 @@ private:
 
     void action(analysis::FunctionBlock & fblock);
     llvm::Type * getType(const analysis::TIType::Type ty, const bool scalar);
-    llvm::Value * getPtrFromIndex(const ast::CallExp & ce);
     void runOptimizationPasses();
     void cloneSyms(const ast::Exp & e);
     void makeSwitch(const ast::IntSelectExp & e, const std::map<int64_t, ast::Exp *> & map);
index 58b8709..07d6aae 100644 (file)
 
 namespace ast
 {
-    class CallExp;
+class CallExp;
 }
 
 namespace jit
 {
 
-    class JITVisitor;
-    
-    class Jitter
-    {
-    public:
-       
-       static bool analyzeAndJIT(const ast::CallExp & ce, const types::typed_list & in, types::typed_list & out);
-       
-    };
+class JITVisitor;
+
+class Jitter
+{
+public:
+
+    static bool analyzeAndJIT(const ast::CallExp & ce, const types::typed_list & in, types::typed_list & out);
+
+};
 }
 
 #endif // __JIT_JITTER_HXX__
index c27b676..358e71d 100644 (file)
 namespace jit
 {
 
-    template<typename T, typename U>
-    inline void push(void * list, const T x)
-    {
-       reinterpret_cast<types::typed_list *>(list)->push_back(new U(x));
-    }
-    
+template<typename T, typename U>
+inline void push(void * list, const T x)
+{
+    reinterpret_cast<types::typed_list *>(list)->push_back(new U(x));
+}
+
 }
index 92beea4..0ffbd5e 100644 (file)
 
 namespace jit
 {
-    namespace op
+namespace op
+{
+
+template<typename T, typename U, typename V>
+struct Add
+{
+
+    inline V operator()(T x, U y)
+    {
+        return (V)x + (V)y;
+    }
+};
+
+template<typename U>
+struct Add<const std::complex<double> &, U, std::complex<double>>
+{
+
+    inline std::complex<double> operator()(const std::complex<double> & x, U y)
+    {
+        return x + (double)y;
+    }
+};
+
+template<typename T>
+struct Add<T, const std::complex<double> &, std::complex<double>>
+{
+
+    inline std::complex<double> operator()(T x, const std::complex<double> & y)
+    {
+        return (double)x + y;
+    }
+};
+
+template<>
+struct Add<const std::complex<double> &, const std::complex<double> &, std::complex<double>>
+{
+
+    inline std::complex<double> operator()(const std::complex<double> & x, const std::complex<double> & y)
     {
+        return x + y;
+    }
+};
 
-       template<typename T, typename U, typename V>
-       struct Add
-       {
-
-           inline V operator()(T x, U y)
-               {
-                   return (V)x + (V)y;
-               }
-       };
-       
-       template<typename U>
-       struct Add<const std::complex<double> &, U, std::complex<double>>
-       {
-
-           inline std::complex<double> operator()(const std::complex<double> & x, U y)
-               {
-                   return x + (double)y;
-               }
-       };
-
-       template<typename T>
-       struct Add<T, const std::complex<double> &, std::complex<double>>
-       {
-
-           inline std::complex<double> operator()(T x, const std::complex<double> & y)
-               {
-                   return (double)x + y;
-               }
-       };
-
-       template<>
-       struct Add<const std::complex<double> &, const std::complex<double> &, std::complex<double>>
-       {
-
-           inline std::complex<double> operator()(const std::complex<double> & x, const std::complex<double> & y)
-               {
-                   return x + y;
-               }
-       };
-
-    } // namespace op
+} // namespace op
 
 } // namespace jit
 
index f33e259..90284ff 100644 (file)
 
 namespace jit
 {
-    namespace op
+namespace op
+{
+
+template<bool are_integral, typename T, typename U, typename V>
+struct __And_helper;
+
+template<typename T, typename U, typename V>
+struct __And_helper<true, T, U, V>
+{
+    inline V operator()(T x, U y)
+    {
+        return (V)x & (V)y;
+    }
+};
+
+template<typename T, typename U, typename V>
+struct __And_helper<false, T, U, V>
+{
+    inline V operator()(T x, U y)
+    {
+        return (x != 0) && (y != 0);
+    }
+};
+
+template<typename U, typename V>
+struct __And_helper<false, const std::complex<double> &, U, V>
+{
+
+    inline V operator()(const std::complex<double> & x, U y)
+    {
+        return (x != 0.) && ((double)y != 0);
+    }
+};
+
+template<typename T, typename V>
+struct __And_helper<false, T, const std::complex<double> &, V>
+{
+
+    inline V operator()(T x, const std::complex<double> & y)
+    {
+        return ((double)x != 0.) && (y != 0.);
+    }
+};
+
+template<typename V>
+struct __And_helper<false, const std::complex<double> &, const std::complex<double> &, V>
+{
+
+    inline V operator()(const std::complex<double> & x, const std::complex<double> & y)
+    {
+        return (x != 0.) && (y != 0.);
+    }
+};
+
+template<typename T, typename U, typename V>
+struct And
+{
+    inline V operator()(T x, U y)
     {
+        return __And_helper < jit::is_pure_integral<T>::value && jit::is_pure_integral<U>::value, T, U, V > ()(x, y);
+    }
+};
 
-       template<bool are_integral, typename T, typename U, typename V>
-       struct __And_helper;
-
-       template<typename T, typename U, typename V>
-       struct __And_helper<true, T, U, V>
-       {
-           inline V operator()(T x, U y)
-               {
-                   return (V)x & (V)y;
-               }
-       };
-
-       template<typename T, typename U, typename V>
-       struct __And_helper<false, T, U, V>
-       {
-           inline V operator()(T x, U y)
-               {
-                   return (x != 0) && (y != 0);
-               }
-       };
-
-       template<typename U, typename V>
-       struct __And_helper<false, const std::complex<double> &, U, V>
-       {
-
-           inline V operator()(const std::complex<double> & x, U y)
-               {
-                   return (x != 0.) && ((double)y != 0);
-               }
-       };
-
-       template<typename T, typename V>
-       struct __And_helper<false, T, const std::complex<double> &, V>
-       {
-
-           inline V operator()(T x, const std::complex<double> & y)
-               {
-                   return ((double)x != 0.) && (y != 0.);
-               }
-       };
-
-       template<typename V>
-       struct __And_helper<false, const std::complex<double> &, const std::complex<double> &, V>
-       {
-
-           inline V operator()(const std::complex<double> & x, const std::complex<double> & y)
-               {
-                   return (x != 0.) && (y != 0.);
-               }
-       };
-
-       template<typename T, typename U, typename V>
-       struct And
-       {
-           inline V operator()(T x, U y)
-               {
-                   return __And_helper<jit::is_pure_integral<T>::value && jit::is_pure_integral<U>::value, T, U, V>()(x, y);
-               }
-       };
-
-    } // namespace op
+} // namespace op
 
 } // namespace jit
 
index a4e138b..20c14c1 100644 (file)
 
 namespace jit
 {
-    namespace functors
+namespace functors
+{
+template<typename Functor>
+struct Binary
+{
+
+    template<typename T, typename U, typename V>
+    inline void operator()(jit::vect::WrapVecIn<T> && x, jit::vect::WrapVecIn<U> && y, jit::vect::WrapOut<V> && o, const int64_t i)
+    {
+        o[i] = Functor()(x[i], y[i]);
+    }
+};
+
+template<typename Functor>
+struct BinaryOp
+{
+
+    template<typename T, typename U>
+    inline bool operator()(jit::vect::WrapVecIn<T> && x, jit::vect::WrapVecIn<U> && y, const int64_t i)
     {
-       template<typename Functor>
-       struct Binary
-       {
-           
-           template<typename T, typename U, typename V>
-           inline void operator()(jit::vect::WrapVecIn<T> && x, jit::vect::WrapVecIn<U> && y, jit::vect::WrapOut<V> && o, const int64_t i)
-               {
-                   o[i] = Functor()(x[i], y[i]);
-               }
-       };
+        return Functor()(x[i], y[i]);
+    }
+};
+
+template<typename T, typename U, typename V>
+using add = Binary<jit::op::Add<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using sub = Binary<jit::op::Sub<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using dottimes = Binary<jit::op::Prod<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using dotpower = Binary<jit::op::Pow<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using dotldiv = Binary<jit::op::Ldiv<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using dotrdiv = Binary<jit::op::Rdiv<T, U, V>>;
+
+template<typename T, typename U, typename V>
+using neq = Binary<jit::op::Neq<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using add = Binary<jit::op::Add<T, U, V>>;
+template<typename T, typename U>
+using shortcut_neq = BinaryOp<jit::op::Neq<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using sub = Binary<jit::op::Sub<T, U, V>>;
+template<typename T, typename U, typename V>
+using eq = Binary<jit::op::Eq<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using dottimes = Binary<jit::op::Prod<T, U, V>>;
+template<typename T, typename U>
+using shortcut_eq = BinaryOp<jit::op::Eq<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using dotpower = Binary<jit::op::Pow<T, U, V>>;
+template<typename T, typename U, typename V>
+using gt = Binary<jit::op::Gt<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using dotldiv = Binary<jit::op::Ldiv<T, U, V>>;
+template<typename T, typename U>
+using shortcut_gt = BinaryOp<jit::op::Gt<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using dotrdiv = Binary<jit::op::Rdiv<T, U, V>>;
+template<typename T, typename U, typename V>
+using ge = Binary<jit::op::Ge<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using neq = Binary<jit::op::Neq<T, U, V>>;
+template<typename T, typename U>
+using shortcut_ge = BinaryOp<jit::op::Ge<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using eq = Binary<jit::op::Eq<T, U, V>>;
+template<typename T, typename U, typename V>
+using lt = Binary<jit::op::Lt<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using gt = Binary<jit::op::Gt<T, U, V>>;
+template<typename T, typename U>
+using shortcut_lt = BinaryOp<jit::op::Lt<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using ge = Binary<jit::op::Ge<T, U, V>>;
+template<typename T, typename U, typename V>
+using le = Binary<jit::op::Le<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using lt = Binary<jit::op::Lt<T, U, V>>;
+template<typename T, typename U>
+using shortcut_le = BinaryOp<jit::op::Le<T, U, bool>>;
 
-       template<typename T, typename U, typename V>
-       using le = Binary<jit::op::Le<T, U, V>>;
+template<typename T, typename U, typename V>
+using And = Binary<jit::op::And<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using And = Binary<jit::op::And<T, U, V>>;
+template<typename T, typename U, typename V>
+using Or = Binary<jit::op::Or<T, U, V>>;
 
-       template<typename T, typename U, typename V>
-       using Or = Binary<jit::op::Or<T, U, V>>;
-       
-    } // namespace functors
+} // namespace functors
 
 } // namespace jit
 
index e9fed03..b707ab2 100644 (file)
 
 namespace jit
 {
-    namespace op
-    {
+namespace op
+{
 
-        template<typename T, typename U, typename V>
-        struct Pow
-        {
+template<typename T, typename U, typename V>
+struct Pow
+{
 
-            inline V operator()(T x, U y)
-                {
-                    return (V)std::pow((V)x, (V)y);
-                }
-        };
+    inline V operator()(T x, U y)
+    {
+        return (V)std::pow((V)x, (V)y);
+    }
+};
 
-        template<typename U>
-        struct Pow<const std::complex<double> &, U, std::complex<double>>
-        {
+template<typename U>
+struct Pow<const std::complex<double> &, U, std::complex<double>>
+{
 
-            inline std::complex<double> operator()(const std::complex<double> & x, U y)
-            {
-                return std::pow(x, (double)y);
-            }
-        };
+    inline std::complex<double> operator()(const std::complex<double> & x, U y)
+    {
+        return std::pow(x, (double)y);
+    }
+};
 
-        template<typename T>
-        struct Pow<T, const std::complex<double> &, std::complex<double>>
-        {
+template<typename T>
+struct Pow<T, const std::complex<double> &, std::complex<double>>
+{
 
-            inline std::complex<double> operator()(T x, const std::complex<double> & y)
-            {
-                return std::pow((double)x, y);
-            }
-        };
+    inline std::complex<double> operator()(T x, const std::complex<double> & y)
+    {
+        return std::pow((double)x, y);
+    }
+};
 
-        template<>
-        struct Pow<const std::complex<double> &, const std::complex<double> &, std::complex<double>>
-        {
+template<>
+struct Pow<const std::complex<double> &, const std::complex<double> &, std::complex<double>>
+{
 
-            inline std::complex<double> operator()(const std::complex<double> & x, const std::complex<double> & y)
-            {
-                return std::pow(x, y);
-            }
-        };
+    inline std::complex<double> operator()(const std::complex<double> & x, const std::complex<double> & y)
+    {
+        return std::pow(x, y);
+    }
+};
 
-    } // namespace op
+} // namespace op
 
-    namespace exponentiation
-    {
+namespace exponentiation
+{
 
-       template<typename T>
-       inline void SQ22(T * x)
-       {
-           const T bc = x[1] * x[2];
-           const T a_d = x[0] + x[3];
-           x[0] = x[0] * x[0] + bc;
-           x[1] *= a_d;
-           x[2] *= a_d;
-           x[3] = x[3] * x[3] + bc;
-       }
-
-       template<typename T>
-        inline void POWM22(T * x, uint64_t n)
+template<typename T>
+inline void SQ22(T * x)
+{
+    const T bc = x[1] * x[2];
+    const T a_d = x[0] + x[3];
+    x[0] = x[0] * x[0] + bc;
+    x[1] *= a_d;
+    x[2] *= a_d;
+    x[3] = x[3] * x[3] + bc;
+}
+
+template<typename T>
+inline void POWM22(T * x, uint64_t n)
+{
+    switch (n)
+    {
+        case 0:
+            x[0] = x[3] = 1;
+            x[1] = x[2] = 0;
+            return;
+        case 1:
+            return;
+        case 2:
+        {
+            SQ22(x);
+            return;
+        }
+        default:
         {
-            switch (n)
+            T y0, y1, y2, y3;
+            if (n & 1)
             {
-            case 0:
-                x[0] = x[3] = 1;
-                x[1] = x[2] = 0;
-                return;
-            case 1:
-                return;
-            case 2:
+                y0 = x[0];
+                y1 = x[1];
+                y2 = x[2];
+                y3 = x[3];
+            }
+            else
             {
-                SQ22(x);
-                return;
+                y0 = 1;
+                y1 = 0;
+                y2 = 0;
+                y3 = 1;
             }
-            default:
+
+            while (n >>= 1)
             {
-                T y0, y1, y2, y3;
+                SQ22(x);
                 if (n & 1)
                 {
-                    y0 = x[0];
-                    y1 = x[1];
-                    y2 = x[2];
-                    y3 = x[3];
-                }
-                else
-                {
-                    y0 = 1;
-                    y1 = 0;
-                    y2 = 0;
-                    y3 = 1;
+                    T a, b;
+                    a = y0 * x[0] + y2 * x[1];
+                    y2 = y0 * x[2] + y2 * x[3];
+                    b = y1 * x[0] + y3 * x[1];
+                    y3 = y1 * x[2] + y3 * x[3];
+                    y0 = a;
+                    y1 = b;
                 }
 
-                while (n >>= 1)
-                {
-                    SQ22(x);
-                    if (n & 1)
-                    {
-                        T a, b;
-                        a = y0 * x[0] + y2 * x[1];
-                        y2 = y0 * x[2] + y2 * x[3];
-                        b = y1 * x[0] + y3 * x[1];
-                        y3 = y1 * x[2] + y3 * x[3];
-                        y0 = a;
-                        y1 = b;
-                    }
+            }
 
-                }
+            x[0] = y0;
+            x[1] = y1;
+            x[2] = y2;
+            x[3] = y3;
+        }
+    }
+}
 
-                x[0] = y0;
-                x[1] = y1;
-                x[2] = y2;
-                x[3] = y3;
-            }
+inline void POWM(const double * x, const int64_t x_r, double * o, uint64_t n)
+{
+    /*
+      This is not exactly the fast pow algorithm.
+      I slightly modified it to avoid the dcopys.
+      The idea is easy: we want the result in o so
+      if N is even then o = t1*t1 else o=x*t1 and t1=o*o
+      and we can replace n by n/2.
+      If we were in the first case and n is even then t1=o*o
+      else o=x*t1 and t1=o*o,...
+      So to generate the dgemms we need to begin with the most signifiant bit.
+      For example:
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, x, &x_r, &zero, o, &x_r); // x^2
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, o, &x_r, &zero, t1, &x_r); // x^3
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, t1, &x_r, t1, &x_r, &zero, o, &x_r); // x^6
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, o, &x_r, o, &x_r, &zero, t1, &x_r); // x^12
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, t1, &x_r, &zero, o, &x_r); // x^13
+
+      The goal is to have one temp array, no memcpy and the final multiplication must put its result in o.
+    */
+
+    if (x_r == 2)
+    {
+        o[0] = x[0];
+        o[1] = x[1];
+        o[2] = x[2];
+        o[3] = x[3];
+        POWM22(o, n);
+        return;
+    }
+
+    const int64_t size = x_r * x_r;
+    int x_r_i = (int)x_r;
+
+    switch (n)
+    {
+        case 0:
+        {
+            // Identity matrix
+            std::memset(o, 0, size * sizeof(double));
+            for (int64_t i = 0; i < x_r; ++i)
+            {
+                o[i * (x_r + 1)] = 1;
             }
+            return;
         }
+        case 1:
+        {
+            // x itself
+            std::memcpy(o, x, size * sizeof(double));
+            return;
+        }
+        case 2:
+        {
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
+            return;
+        }
+        default:
+            break;
+    }
+
+    //const unsigned int nbits = 8 * sizeof(uint64_t) - __builtin_clzll(n);
+    //const bool parity = (nbits - __builtin_popcountll(n)) & 1;
+    // since n >= 3, then nbits >= 2
+    const unsigned int nbits = 8 * sizeof(uint64_t) - analysis::tools::clzll(n);
+    const bool parity = (nbits - analysis::tools::popcount(n)) & 1;
+    unsigned int mask = 1 << (nbits - 2);
+    double * tmp = new double[size];
+
+    // Trip cost is [log2(n)] (=nbits-1)
+    // Except the most signifiant bit, for each 1 in binary representation of n we have 2 dgemms
+    // and for each 0 we have 1 dgemm.
+    // E.g. for n=13=0x1101, the cost is 2 * 2 + 1 dgemms.
+
+    if (n & mask)
+    {
+        if (parity)
+        {
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o); // o = x^2
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, o, tmp); // tmp = x^3
+            std::swap(o, tmp); // o <--> tmp => o = x^3 & tmp = x^2
+        }
+        else
+        {
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp); // tmp = x^2
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o); // o = x^3
+        }
+    }
+    else
+    {
+        if (parity)
+        {
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o); // o = x^2
+        }
+        else
+        {
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp); // tmp = x^2
+            std::swap(o, tmp); // o <--> tmp => o = x^2 & tmp = ?
+        }
+    }
 
-        inline void POWM(const double * x, const int64_t x_r, double * o, uint64_t n)
+    while (mask >>= 1)
+    {
+        multiplication::DGEMM(o, x_r_i, x_r_i, x_r_i, o, tmp); // tmp = o^2
+        if (n & mask)
         {
-            /*
-              This is not exactly the fast pow algorithm.
-              I slightly modified it to avoid the dcopys.
-              The idea is easy: we want the result in o so
-              if N is even then o = t1*t1 else o=x*t1 and t1=o*o
-              and we can replace n by n/2.
-              If we were in the first case and n is even then t1=o*o
-              else o=x*t1 and t1=o*o,...
-              So to generate the dgemms we need to begin with the most signifiant bit.
-              For example:
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, x, &x_r, &zero, o, &x_r); // x^2
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, o, &x_r, &zero, t1, &x_r); // x^3
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, t1, &x_r, t1, &x_r, &zero, o, &x_r); // x^6
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, o, &x_r, o, &x_r, &zero, t1, &x_r); // x^12
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, t1, &x_r, &zero, o, &x_r); // x^13
-
-              The goal is to have one temp array, no memcpy and the final multiplication must put its result in o.
-            */
+            multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o); // o = x * tmp
+        }
+        else
+        {
+            std::swap(o, tmp); // o <--> tmp
+        }
+    }
 
-            if (x_r == 2)
+    delete[] tmp;
+}
+
+inline void POWM(const cpx_t * x, const int64_t x_r, cpx_t * o, uint64_t n)
+{
+    /*
+      This is not exactly the fast pow algorithm.
+      I slightly modified it to avoid the dcopys.
+      The idea is easy: we want the result in o so
+      if N is even then o = t1*t1 else o=x*t1 and t1=o*o
+      and we can replace n by n/2.
+      If we were in the first case and n is even then t1=o*o
+      else o=x*t1 and t1=o*o,...
+      So to generate the dgemms we need to begin with the most signifiant bit.
+      For example:
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, x, &x_r, &zero, o, &x_r); // x^2
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, o, &x_r, &zero, t1, &x_r); // x^3
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, t1, &x_r, t1, &x_r, &zero, o, &x_r); // x^6
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, o, &x_r, o, &x_r, &zero, t1, &x_r); // x^12
+      C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, t1, &x_r, &zero, o, &x_r); // x^13
+
+      The goal is to have one temp array, no memcpy and the final multiplication must put its result in o.
+    */
+
+    if (x_r == 2)
+    {
+        o[0] = x[0];
+        o[1] = x[1];
+        o[2] = x[2];
+        o[3] = x[3];
+        POWM22(o, n);
+        return;
+    }
+
+    const int64_t size = x_r * x_r;
+    int x_r_i = (int)x_r;
+
+    switch (n)
+    {
+        case 0:
+        {
+            // Identity matrix
+            std::memset(o, 0, size * sizeof(cpx_t));
+            for (int64_t i = 0; i < x_r; ++i)
             {
-               o[0] = x[0];
-               o[1] = x[1];
-               o[2] = x[2];
-               o[3] = x[3];
-                POWM22(o, n);
-                return;
+                o[i * (x_r + 1)] = 1;
             }
+            return;
+        }
+        case 1:
+        {
+            // x itself
+            std::memcpy(o, x, size * sizeof(cpx_t));
+            return;
+        }
+        case 2:
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
+            return;
+        }
+        default:
+            break;
+    }
+
+    //const unsigned int nbits = 8 * sizeof(uint64_t) - __builtin_clzll(n);
+    //const bool parity = (nbits - __builtin_popcountll(n)) & 1;
+    const unsigned int nbits = 8 * sizeof(uint64_t) - analysis::tools::clzll(n);
+    const bool parity = (nbits - analysis::tools::popcount(n)) & 1;
+    unsigned int mask = 1 << (nbits - 2);
+    cpx_t * tmp = new cpx_t[size];
+
+    // Trip cost is [log2(n)] (=nbits-1)
+    // Except the most signifiant bit, for each 1 in binary representation of n we have 2 dgemms
+    // and for each 0 we have 1 dgemm.
+    // E.g. for n=13=0x1101, the cost is 2 * 2 + 1 dgemms.
+
+    if (n & mask)
+    {
+        if (parity)
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, o, tmp);
+            std::swap(o, tmp);
+        }
+        else
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
+        }
+    }
+    else
+    {
+        if (parity)
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
+        }
+        else
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
+            std::swap(o, tmp);
+        }
+    }
 
-            const int64_t size = x_r * x_r;
-            int x_r_i = (int)x_r;
+    while (mask >>= 1)
+    {
+        multiplication::ZGEMM(o, x_r_i, x_r_i, x_r_i, o, tmp);
+        if (n & mask)
+        {
+            multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
+        }
+        else
+        {
+            std::swap(o, tmp);
+        }
+    }
 
-            switch (n)
-            {
-            case 0:
-            {
-                // Identity matrix
-                std::memset(o, 0, size * sizeof(double));
-                for (int64_t i = 0; i < x_r; ++i)
-                {
-                    o[i * (x_r + 1)] = 1;
-                }
-                return;
-            }
-            case 1:
-            {
-                // x itself
-                std::memcpy(o, x, size * sizeof(double));
-                return;
-            }
-            case 2:
-            {
-                multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                return;
-            }
-            default:
-                break;
-            }
+    delete[] tmp;
+}
 
-            //const unsigned int nbits = 8 * sizeof(uint64_t) - __builtin_clzll(n);
-            //const bool parity = (nbits - __builtin_popcountll(n)) & 1;
-            const unsigned int nbits = 8 * sizeof(uint64_t) - analysis::tools::clzll(n);
-            const bool parity = (nbits - analysis::tools::popcount(n)) & 1;
-            unsigned int mask = 1 << (nbits - 2);
-            double * tmp = new double[size];
+template<typename T>
+inline void powMSi64(const int64_t x_r, const T * x, const int64_t expo, T ** o)
+{
+    const int64_t x_size = x_r * x_r;
+    double * _x = new double[x_size];
+    double * _o = new double[x_size];
+    for (int64_t i = 0; i < x_size; ++i)
+    {
+        _x[i] = (double)x[i];
+    }
+    if (expo > 0)
+    {
+        POWM(_x, x_r, _o, (uint64_t)expo);
+    }
+    else
+    {
+        POWM(_x, x_r, _o, (uint64_t)(-expo));
+        int x_r_i = (int)x_r;
+        rdivision::DINV(_o, x_r_i);
+    }
+    delete[] _x;
+
+    T * __o;
+    if (*o)
+    {
+        __o = *o;
+    }
+    else
+    {
+        *o = new T[x_r * x_r];
+        __o = *o;
+    }
+    for (int64_t i = 0; i < x_size; ++i)
+    {
+        __o[i] = (T)_o[i];
+    }
+    delete[] _o;
+}
 
-            // Trip cost is [log2(n)] (=nbits-1)
-            // Except the most signifiant bit, for each 1 in binary representation of n we have 2 dgemms
-            // and for each 0 we have 1 dgemm.
-            // E.g. for n=13=0x1101, the cost is 2 * 2 + 1 dgemms.
+template<>
+inline void powMSi64<double>(const int64_t x_r, const double * x, const int64_t expo, double ** o)
+{
+    // TODO: x^d => donne un complexe en general ca veut dire que meme ds le cas ou expo est correct
+    // il faut prevoir de mettre o_im a null
+    if (!*o)
+    {
+        *o = new double[x_r * x_r];
+    }
+    if (expo > 0)
+    {
+        POWM(x, x_r, *o, (uint64_t)expo);
+    }
+    else
+    {
+        POWM(x, x_r, *o, (uint64_t)(-expo));
+        if (x_r == 2)
+        {
+            double * _o = *o;
+            const double d = _o[0] * _o[3] - _o[1] * _o[2];
+            const double x = _o[0] / d;
+            _o[0] = _o[3] / d;
+            _o[3] = x;
+            _o[1] = -_o[1] / d;
+            _o[2] = -_o[2] / d;
+        }
+        else
+        {
+            int x_r_i = (int)x_r;
+            rdivision::DINV(*o, x_r_i);
+        }
+    }
+}
 
-            if (n & mask)
-            {
-                if (parity)
-                {
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, o, tmp);
-                    std::swap(o, tmp);
-                }
-                else
-                {
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
-                }
-            }
-            else
-            {
-                if (parity)
-                {
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                }
-                else
-                {
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
-                    std::swap(o, tmp);
-                }
-            }
+inline void powMcSi64(const int64_t x_r, const double * x_re, const double * x_im, const int64_t expo, double ** o_re, double ** o_im)
+{
+    const int64_t size = x_r * x_r;
+    if (!*o_re)
+    {
+        *o_re = new double[size];
+    }
 
-            while (mask >>= 1)
-            {
-                multiplication::DGEMM(o, x_r_i, x_r_i, x_r_i, o, tmp);
-                if (n & mask)
-                {
-                    multiplication::DGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
-                }
-                else
-                {
-                    std::swap(o, tmp);
-                }
-            }
+    if (x_im)
+    {
+        cpx_t * x = new cpx_t[size];
+        cpx_t * o = new cpx_t[size];
 
-            delete[] tmp;
+        for (int64_t i = 0; i < size; ++i)
+        {
+            x[i] = cpx_t(x_re[i], x_im[i]);
         }
 
-       inline void POWM(const cpx_t * x, const int64_t x_r, cpx_t * o, uint64_t n)
+        if (!*o_im)
         {
-            /*
-              This is not exactly the fast pow algorithm.
-              I slightly modified it to avoid the dcopys.
-              The idea is easy: we want the result in o so
-              if N is even then o = t1*t1 else o=x*t1 and t1=o*o
-              and we can replace n by n/2.
-              If we were in the first case and n is even then t1=o*o
-              else o=x*t1 and t1=o*o,...
-              So to generate the dgemms we need to begin with the most signifiant bit.
-              For example:
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, x, &x_r, &zero, o, &x_r); // x^2
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, o, &x_r, &zero, t1, &x_r); // x^3
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, t1, &x_r, t1, &x_r, &zero, o, &x_r); // x^6
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, o, &x_r, o, &x_r, &zero, t1, &x_r); // x^12
-              C2F(dgemm)(&n, &n, &x_r, &x_r, &x_r, &one, x, &x_r, t1, &x_r, &zero, o, &x_r); // x^13
-
-              The goal is to have one temp array, no memcpy and the final multiplication must put its result in o.
-            */
+            *o_im = new double[size];
+        }
+        double * _o_re = *o_re;
+        double * _o_im = *o_im;
 
+        if (expo > 0)
+        {
+            POWM(x, x_r, o, (uint64_t)expo);
+            delete[] x;
+        }
+        else
+        {
+            POWM(x, x_r, o, (uint64_t)(-expo));
+            delete[] x;
             if (x_r == 2)
             {
-               o[0] = x[0];
-               o[1] = x[1];
-               o[2] = x[2];
-               o[3] = x[3];
-                POWM22(o, n);
-                return;
-            }
-
-            const int64_t size = x_r * x_r;
-            int x_r_i = (int)x_r;
+                const cpx_t d = o[0] * o[3] - o[1] * o[2];
+                const cpx_t x = o[0] / d;
+                o[0] = o[3] / d;
+                o[3] = x;
+                o[1] = -o[1] / d;
+                o[2] = -o[2] / d;
 
-            switch (n)
-            {
-            case 0:
-            {
-                // Identity matrix
-                std::memset(o, 0, size * sizeof(cpx_t));
-                for (int64_t i = 0; i < x_r; ++i)
-                {
-                    o[i * (x_r + 1)] = 1;
-                }
-                return;
-            }
-            case 1:
-            {
-                // x itself
-                std::memcpy(o, x, size * sizeof(cpx_t));
-                return;
-            }
-            case 2:
-            {
-                multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                return;
-            }
-            default:
-                break;
-            }
-
-            //const unsigned int nbits = 8 * sizeof(uint64_t) - __builtin_clzll(n);
-            //const bool parity = (nbits - __builtin_popcountll(n)) & 1;
-            const unsigned int nbits = 8 * sizeof(uint64_t) - analysis::tools::clzll(n);
-            const bool parity = (nbits - analysis::tools::popcount(n)) & 1;
-            unsigned int mask = 1 << (nbits - 2);
-            cpx_t * tmp = new cpx_t[size];
-
-            // Trip cost is [log2(n)] (=nbits-1)
-            // Except the most signifiant bit, for each 1 in binary representation of n we have 2 dgemms
-            // and for each 0 we have 1 dgemm.
-            // E.g. for n=13=0x1101, the cost is 2 * 2 + 1 dgemms.
-
-            if (n & mask)
-            {
-                if (parity)
-                {
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, o, tmp);
-                    std::swap(o, tmp);
-                }
-                else
-                {
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
-                }
             }
             else
             {
-                if (parity)
-                {
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, o);
-                }
-                else
-                {
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, x, tmp);
-                    std::swap(o, tmp);
-                }
+                int x_r_i = (int)x_r;
+                rdivision::ZINV(o, x_r_i);
             }
-
-            while (mask >>= 1)
-            {
-                multiplication::ZGEMM(o, x_r_i, x_r_i, x_r_i, o, tmp);
-                if (n & mask)
-                {
-                    multiplication::ZGEMM(x, x_r_i, x_r_i, x_r_i, tmp, o);
-                }
-                else
-                {
-                    std::swap(o, tmp);
-                }
-            }
-
-            delete[] tmp;
         }
+        for (int64_t i = 0; i < size; ++i)
+        {
+            _o_re[i] = o[i].real();
+            _o_im[i] = o[i].imag();
+        }
+        delete[] o;
+    }
+    else
+    {
+        powMSi64<double>(x_r, x_re, expo, o_re);
+    }
+}
 
-       template<typename T>
-       inline void powMSi64(const int64_t x_r, const T * x, const int64_t expo, T ** o)
-       {
-           const int64_t x_size = x_r * x_r;
-           double * _x = new double[x_size];
-            double * _o = new double[x_size];
-           for (int64_t i = 0; i < x_size; ++i)
-            {
-                _x[i] = (double)x[i];
-            }
-           if (expo > 0)
-           {
-               POWM(_x, x_r, _o, (uint64_t)expo);
-           }
-           else
-           {
-               POWM(_x, x_r, _o, (uint64_t)(-expo));
-               int x_r_i = (int)x_r;
-               rdivision::DINV(_o, x_r_i);
-           }
-           delete[] _x;
-           
-           T * __o;
-           if (*o)
-           {
-               __o = *o;
-           }
-           else
-           {
-               *o = new T[x_r * x_r];
-               __o = *o;
-           }
-           for (int64_t i = 0; i < x_size; ++i)
-            {
-                __o[i] = (T)_o[i];
-            }
-           delete[] _o;
-       }
-       
-       template<>
-       inline void powMSi64<double>(const int64_t x_r, const double * x, const int64_t expo, double ** o)
-       {
-           // TODO: x^d => donne un complexe en general ca veut dire que meme ds le cas ou expo est correct
-           // il faut prevoir de mettre o_im a null
-           if (!*o)
-           {
-               *o = new double[x_r * x_r];
-           }
-           if (expo > 0)
-           {
-               POWM(x, x_r, *o, (uint64_t)expo);
-           }
-           else
-           {
-               POWM(x, x_r, *o, (uint64_t)(-expo));
-               if (x_r == 2)
-               {
-                   double * _o = *o;
-                   const double d = _o[0] * _o[3] - _o[1] * _o[2];
-                   const double x = _o[0] / d;
-                   _o[0] = _o[3] / d;
-                   _o[3] = x;
-                   _o[1] = -_o[1] / d;
-                   _o[2] = -_o[2] / d;
-               }
-               else
-               {
-                   int x_r_i = (int)x_r;
-                   rdivision::DINV(*o, x_r_i);
-               }
-           }
-       }
-
-       inline void powMcSi64(const int64_t x_r, const double * x_re, const double * x_im, const int64_t expo, double ** o_re, double ** o_im)
-       {
-           const int64_t size = x_r * x_r;
-           if (!*o_re)
-           {
-               *o_re = new double[size];
-           }
-
-           if (x_im)
-           {
-               cpx_t * x = new cpx_t[size];
-               cpx_t * o = new cpx_t[size];
-
-               for (int64_t i = 0; i < size; ++i)
-               {
-                   x[i] = cpx_t(x_re[i], x_im[i]);
-               }
-
-               if (!*o_im)
-               {
-                   *o_im = new double[size];
-               }
-               double * _o_re = *o_re;
-               double * _o_im = *o_im;
-               
-               if (expo > 0)
-               {
-                   POWM(x, x_r, o, (uint64_t)expo);
-                   delete[] x;
-               }
-               else
-               {
-                   POWM(x, x_r, o, (uint64_t)(-expo));
-                   delete[] x;
-                   if (x_r == 2)
-                   {
-                       const cpx_t d = o[0] * o[3] - o[1] * o[2];
-                       const cpx_t x = o[0] / d;
-                       o[0] = o[3] / d;
-                       o[3] = x;
-                       o[1] = -o[1] / d;
-                       o[2] = -o[2] / d;                       
-                       
-                   }
-                   else
-                   {
-                       int x_r_i = (int)x_r;
-                       rdivision::ZINV(o, x_r_i);
-                   }
-               }
-               for (int64_t i = 0; i < size; ++i)
-               {
-                   _o_re[i] = o[i].real();
-                   _o_im[i] = o[i].imag();
-               }
-               delete[] o;
-           }
-           else
-           {
-               powMSi64<double>(x_r, x_re, expo, o_re);
-           }
-       }
-
-    } // namespace exponentiation
+} // namespace exponentiation
 
 } // namespace jit
 
index e735d65..fea6269 100644 (file)
 
 namespace jit
 {
-    
-    namespace vect
+
+namespace vect
+{
+
+template<bool as_usual, typename Functor, typename T, typename U>
+struct __Vect_Helper;
+
+template<typename Functor, typename T, typename U>
+struct __Vect_Helper<true, Functor, T, U>
+{
+    inline void operator()(const int64_t size, WrapVecIn<T> && x, WrapOut<U> && o)
     {
+        o.init(size);
+        for (int64_t i = 0; i < size; ++i)
+        {
+            Functor()(std::move(x), std::move(o), i);
+        }
+    }
+};
 
-       template<bool as_usual, typename Functor, typename T, typename U>
-       struct __Vect_Helper;
-       
-       template<typename Functor, typename T, typename U>
-       struct __Vect_Helper<true, Functor, T, U>
-       {
-           inline void operator()(const int64_t size, WrapVecIn<T> && x, WrapOut<U> && o)
-               {
-                   o.init(size);
-                   for (int64_t i = 0; i < size; ++i)
-                   {
-                       Functor()(std::move(x), std::move(o), i);
-                   }
-               }
-       };
+template<typename Functor, typename T>
+struct __Vect_Helper<false, Functor, T, jit::cpx_t>
+{
+    inline void operator()(const int64_t size, WrapVecIn<T> && x, WrapOut<jit::cpx_t> && o)
+    {
+        o.initRe(size);
+        for (int64_t i = 0; i < size; ++i)
+        {
+            Functor()(std::move(x), std::move(o), i, size);
+        }
+    }
+};
 
-       template<typename Functor, typename T>
-       struct __Vect_Helper<false, Functor, T, jit::cpx_t>
-       {
-           inline void operator()(const int64_t size, WrapVecIn<T> && x, WrapOut<jit::cpx_t> && o)
-               {
-                   o.initRe(size);
-                   for (int64_t i = 0; i < size; ++i)
-                   {
-                       Functor()(std::move(x), std::move(o), i, size);
-                   }
-               }
-       };
+template<typename Functor, typename T, typename U>
+inline void unary(const int64_t size, WrapVecIn<T> && x, WrapOut<U> && o)
+{
+    __Vect_Helper<Functor::as_usual, Functor, T, U>()(size, std::move(x), std::move(o));
+}
 
-       template<typename Functor, typename T, typename U>
-       inline void unary(const int64_t size, WrapVecIn<T> && x, WrapOut<U> && o)
-       {
-           __Vect_Helper<Functor::as_usual, Functor, T, U>()(size, std::move(x), std::move(o));
-       }
+template<typename Functor, typename T, typename U, typename V>
+inline void binary(const int64_t size, WrapVecIn<T> && x, WrapVecIn<U> && y, WrapOut<V> && o)
+{
+    o.init(size);
+    for (int64_t i = 0; i < size; ++i)
+    {
+        Functor()(std::move(x), std::move(y), std::move(o), i);
+    }
+}
 
-       template<typename Functor, typename T, typename U, typename V>
-       inline void binary(const int64_t size, WrapVecIn<T> && x, WrapVecIn<U> && y, WrapOut<V> && o)
-       {
-           o.init(size);
-           for (int64_t i = 0; i < size; ++i)
-           {
-               Functor()(std::move(x), std::move(y), std::move(o), i);
-           }
-       }
+template<bool B, typename Functor, typename T, typename U>
+inline int32_t breakOn(const int64_t size, WrapVecIn<T> && x, WrapVecIn<U> && y)
+{
+    for (int64_t i = 0; i < size; ++i)
+    {
+        if (Functor()(std::move(x), std::move(y), i) == B)
+        {
+            return B;
+        }
+    }
+    return !B;
+}
 
 /*     template<typename F, typename T>
        inline void unary_cpx(const int64_t size, WrapVecIn<T> && x, WrapOut<std::complex<double>> && o)
@@ -97,32 +110,32 @@ namespace jit
         }
 */
 
-        // use it with frexp
-        /*template<typename T, typename U, typename V, V (F)(T, U *), typename W = V>
-        inline void vectorize(const T * x, const int64_t x_r, const int64_t x_c, V * o1, W * o2)
-        {
-            for (int64_t i = 0; i < x_r * x_c; ++i)
-            {
-                U t;
-                o1[i] = (V)F(x[i], &t);
-                o2[i] = (W)t;
-            }
-        }
+// use it with frexp
+/*template<typename T, typename U, typename V, V (F)(T, U *), typename W = V>
+inline void vectorize(const T * x, const int64_t x_r, const int64_t x_c, V * o1, W * o2)
+{
+    for (int64_t i = 0; i < x_r * x_c; ++i)
+    {
+        U t;
+        o1[i] = (V)F(x[i], &t);
+        o2[i] = (W)t;
+    }
+}
+
+// use it with rand()
+template<typename T, T (F)(), typename U = T>
+inline void vectorize(const int64_t x_r, const int64_t x_c, U ** o)
+{
+const int64_t size = x_r * x_c;
+    U * _o = getPtr(o, size);
+    for (int64_t i = 0; i < x_r * x_c; ++i)
+    {
+        o[i] = (T)F();
+    }
+}*/
+
+} // namespace vect
 
-        // use it with rand()
-        template<typename T, T (F)(), typename U = T>
-        inline void vectorize(const int64_t x_r, const int64_t x_c, U ** o)
-        {
-           const int64_t size = x_r * x_c;
-            U * _o = getPtr(o, size);
-            for (int64_t i = 0; i < x_r * x_c; ++i)
-            {
-                o[i] = (T)F();
-            }
-           }*/
-       
-    } // namespace vect
-    
 } // namespace jit
 
 #endif // __BASE_VECTORISATION_HXX__
index 67a0e35..425fc37 100644 (file)
 namespace jit
 {
 
-    // TODO: add shortcut for not operator (~)
-    
-    class JITShortcutBinOpCall : public JITCall
-    {
-
-       const std::string scilabName;
-       
-    public:
-       
-        JITShortcutBinOpCall(const std::string & _scilabName) : scilabName(_scilabName) { }
-       
-       virtual ~JITShortcutBinOpCall() { }
-
-       virtual bool invoke(const ast::Exp & e, const std::vector<analysis::TIType> & typesOut, std::vector<JITScilabPtr> & out, JITVisitor & jit);
-       virtual void init(const std::vector<analysis::TIType> & args, JITVisitor & jit) { }
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit) = 0;
-       virtual JITScilabPtr SM(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       virtual JITScilabPtr MS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       virtual JITScilabPtr MM(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-    };
-
-    class JITShortcutEq : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutEq() : JITShortcutBinOpCall("breakOn_eq") { }
-       ~JITShortcutEq() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-    
-    class JITShortcutNe : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutNe() : JITShortcutBinOpCall("breakOn_ne") { }
-       ~JITShortcutNe() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-
-    class JITShortcutGt : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutGt() : JITShortcutBinOpCall("breakOn_gt") { }
-       ~JITShortcutGt() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-
-    class JITShortcutLt : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutLt() : JITShortcutBinOpCall("breakOn_lt") { }
-       ~JITShortcutLt() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-
-    class JITShortcutGe : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutGe() : JITShortcutBinOpCall("breakOn_ge") { }
-       ~JITShortcutGe() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-
-    class JITShortcutLe : public JITShortcutBinOpCall
-    {
-
-    public:
-       
-        JITShortcutLe() : JITShortcutBinOpCall("breakOn_le") { }
-       ~JITShortcutLe() { }
-
-       virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
-       
-    };
-
-    
+// TODO: add shortcut for not operator (~)
+
+class JITShortcutBinOpCall : public JITCall
+{
+
+    const std::string scilabName;
+
+public:
+
+    JITShortcutBinOpCall(const std::string & _scilabName) : scilabName(_scilabName) { }
+
+    virtual ~JITShortcutBinOpCall() { }
+
+    virtual bool invoke(const ast::Exp & e, const std::vector<analysis::TIType> & typesOut, std::vector<JITScilabPtr> & out, JITVisitor & jit);
+    virtual void init(const std::vector<analysis::TIType> & args, JITVisitor & jit) { }
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit) = 0;
+    virtual JITScilabPtr SM(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+    virtual JITScilabPtr MS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+    virtual JITScilabPtr MM(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+    virtual JITScilabPtr vectorize(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+};
+
+class JITShortcutEq : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutEq() : JITShortcutBinOpCall("shortcut_eq") { }
+    ~JITShortcutEq() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+class JITShortcutNe : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutNe() : JITShortcutBinOpCall("shortcut_ne") { }
+    ~JITShortcutNe() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+class JITShortcutGt : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutGt() : JITShortcutBinOpCall("shortcut_gt") { }
+    ~JITShortcutGt() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+class JITShortcutLt : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutLt() : JITShortcutBinOpCall("shortcut_lt") { }
+    ~JITShortcutLt() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+class JITShortcutGe : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutGe() : JITShortcutBinOpCall("shortcut_ge") { }
+    ~JITShortcutGe() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+class JITShortcutLe : public JITShortcutBinOpCall
+{
+
+public:
+
+    JITShortcutLe() : JITShortcutBinOpCall("shortcut_le") { }
+    ~JITShortcutLe() { }
+
+    virtual JITScilabPtr SS(JITScilabPtr & L, const analysis::TIType & Ltype, JITScilabPtr & R, const analysis::TIType & Rtype, JITVisitor & jit);
+
+};
+
+
 } // namespace jit
 
 #endif // __JIT_SHORTCUT_BINOP_CALL_HXX__
diff --git a/scilab/modules/ast/includes/jit/funs_interf.bak.2 b/scilab/modules/ast/includes/jit/funs_interf.bak.2
deleted file mode 100644 (file)
index 0835d2b..0000000
+++ /dev/null
@@ -1,9233 +0,0 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2014-2015 - Scilab Enterprises - Calixte DENIZET
- *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-// This file has been generated, so don't modify it by hand !!
-
-#ifndef __FUNS_INTERF_H__
-#define __FUNS_INTERF_H__
-
-______DOTPOWER_____MM__(b, int32_t, b, int32_t, double)
-______DOTPOWER_____MM__(b, int32_t, c, double, double)
-______DOTPOWER_____MM__(b, int32_t, d, double, double)
-______DOTPOWER_____MM__(b, int32_t, i16, int16_t, int16_t)
-______DOTPOWER_____MM__(b, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____MM__(b, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(b, int32_t, i8, int8_t, int8_t)
-______DOTPOWER_____MM__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MM__(c, double, b, int32_t, double)
-______DOTPOWER_____MM__(c, double, c, double, double)
-______DOTPOWER_____MM__(c, double, d, double, double)
-______DOTPOWER_____MM__(d, double, b, int32_t, double)
-______DOTPOWER_____MM__(d, double, c, double, double)
-______DOTPOWER_____MM__(d, double, d, double, double)
-______DOTPOWER_____MM__(d, double, i16, int16_t, int16_t)
-______DOTPOWER_____MM__(d, double, i32, int32_t, int32_t)
-______DOTPOWER_____MM__(d, double, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(d, double, i8, int8_t, int8_t)
-______DOTPOWER_____MM__(d, double, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(d, double, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(d, double, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(d, double, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MM__(i16, int16_t, b, int32_t, int16_t)
-______DOTPOWER_____MM__(i16, int16_t, d, double, int16_t)
-______DOTPOWER_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______DOTPOWER_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______DOTPOWER_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______DOTPOWER_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____MM__(i32, int32_t, b, int32_t, int32_t)
-______DOTPOWER_____MM__(i32, int32_t, d, double, int32_t)
-______DOTPOWER_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______DOTPOWER_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______DOTPOWER_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____MM__(i64, int64_t, b, int32_t, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, d, double, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______DOTPOWER_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____MM__(i8, int8_t, b, int32_t, int8_t)
-______DOTPOWER_____MM__(i8, int8_t, d, double, int8_t)
-______DOTPOWER_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______DOTPOWER_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______DOTPOWER_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______DOTPOWER_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______DOTPOWER_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MM__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTPOWER_____MM__(ui16, uint16_t, d, double, uint16_t)
-______DOTPOWER_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTPOWER_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTPOWER_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____MM__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, d, double, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____MM__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, d, double, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____MM__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTPOWER_____MM__(ui8, uint8_t, d, double, uint8_t)
-______DOTPOWER_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTPOWER_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTPOWER_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MS__(b, int32_t, b, int32_t, double)
-______DOTPOWER_____MS__(b, int32_t, c, double, double)
-______DOTPOWER_____MS__(b, int32_t, d, double, double)
-______DOTPOWER_____MS__(b, int32_t, i16, int16_t, int16_t)
-______DOTPOWER_____MS__(b, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____MS__(b, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(b, int32_t, i8, int8_t, int8_t)
-______DOTPOWER_____MS__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MS__(c, double, b, int32_t, double)
-______DOTPOWER_____MS__(c, double, c, double, double)
-______DOTPOWER_____MS__(c, double, d, double, double)
-______DOTPOWER_____MS__(d, double, b, int32_t, double)
-______DOTPOWER_____MS__(d, double, c, double, double)
-______DOTPOWER_____MS__(d, double, d, double, double)
-______DOTPOWER_____MS__(d, double, i16, int16_t, int16_t)
-______DOTPOWER_____MS__(d, double, i32, int32_t, int32_t)
-______DOTPOWER_____MS__(d, double, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(d, double, i8, int8_t, int8_t)
-______DOTPOWER_____MS__(d, double, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(d, double, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(d, double, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(d, double, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MS__(i16, int16_t, b, int32_t, int16_t)
-______DOTPOWER_____MS__(i16, int16_t, d, double, int16_t)
-______DOTPOWER_____MS__(i16, int16_t, i16, int16_t, int16_t)
-______DOTPOWER_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______DOTPOWER_____MS__(i16, int16_t, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(i16, int16_t, i8, int8_t, int16_t)
-______DOTPOWER_____MS__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____MS__(i32, int32_t, b, int32_t, int32_t)
-______DOTPOWER_____MS__(i32, int32_t, d, double, int32_t)
-______DOTPOWER_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______DOTPOWER_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____MS__(i32, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______DOTPOWER_____MS__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____MS__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____MS__(i64, int64_t, b, int32_t, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, d, double, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, i16, int16_t, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, i32, int32_t, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, i8, int8_t, int64_t)
-______DOTPOWER_____MS__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____MS__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____MS__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____MS__(i8, int8_t, b, int32_t, int8_t)
-______DOTPOWER_____MS__(i8, int8_t, d, double, int8_t)
-______DOTPOWER_____MS__(i8, int8_t, i16, int16_t, int16_t)
-______DOTPOWER_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______DOTPOWER_____MS__(i8, int8_t, i64, int64_t, int64_t)
-______DOTPOWER_____MS__(i8, int8_t, i8, int8_t, int8_t)
-______DOTPOWER_____MS__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____MS__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTPOWER_____MS__(ui16, uint16_t, d, double, uint16_t)
-______DOTPOWER_____MS__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTPOWER_____MS__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MS__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MS__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTPOWER_____MS__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____MS__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, d, double, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MS__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____MS__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, d, double, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____MS__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTPOWER_____MS__(ui8, uint8_t, d, double, uint8_t)
-______DOTPOWER_____MS__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTPOWER_____MS__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTPOWER_____MS__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTPOWER_____MS__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTPOWER_____MS__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____MS__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____MS__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____MS__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____SM__(b, int32_t, b, int32_t, double)
-______DOTPOWER_____SM__(b, int32_t, c, double, double)
-______DOTPOWER_____SM__(b, int32_t, d, double, double)
-______DOTPOWER_____SM__(b, int32_t, i16, int16_t, int16_t)
-______DOTPOWER_____SM__(b, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____SM__(b, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(b, int32_t, i8, int8_t, int8_t)
-______DOTPOWER_____SM__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____SM__(c, double, b, int32_t, double)
-______DOTPOWER_____SM__(c, double, c, double, double)
-______DOTPOWER_____SM__(c, double, d, double, double)
-______DOTPOWER_____SM__(d, double, b, int32_t, double)
-______DOTPOWER_____SM__(d, double, c, double, double)
-______DOTPOWER_____SM__(d, double, d, double, double)
-______DOTPOWER_____SM__(d, double, i16, int16_t, int16_t)
-______DOTPOWER_____SM__(d, double, i32, int32_t, int32_t)
-______DOTPOWER_____SM__(d, double, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(d, double, i8, int8_t, int8_t)
-______DOTPOWER_____SM__(d, double, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(d, double, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(d, double, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(d, double, ui8, uint8_t, uint8_t)
-______DOTPOWER_____SM__(i16, int16_t, b, int32_t, int16_t)
-______DOTPOWER_____SM__(i16, int16_t, d, double, int16_t)
-______DOTPOWER_____SM__(i16, int16_t, i16, int16_t, int16_t)
-______DOTPOWER_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______DOTPOWER_____SM__(i16, int16_t, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(i16, int16_t, i8, int8_t, int16_t)
-______DOTPOWER_____SM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____SM__(i32, int32_t, b, int32_t, int32_t)
-______DOTPOWER_____SM__(i32, int32_t, d, double, int32_t)
-______DOTPOWER_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______DOTPOWER_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____SM__(i32, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______DOTPOWER_____SM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____SM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____SM__(i64, int64_t, b, int32_t, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, d, double, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, i16, int16_t, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, i32, int32_t, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, i8, int8_t, int64_t)
-______DOTPOWER_____SM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____SM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____SM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____SM__(i8, int8_t, b, int32_t, int8_t)
-______DOTPOWER_____SM__(i8, int8_t, d, double, int8_t)
-______DOTPOWER_____SM__(i8, int8_t, i16, int16_t, int16_t)
-______DOTPOWER_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______DOTPOWER_____SM__(i8, int8_t, i64, int64_t, int64_t)
-______DOTPOWER_____SM__(i8, int8_t, i8, int8_t, int8_t)
-______DOTPOWER_____SM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____SM__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTPOWER_____SM__(ui16, uint16_t, d, double, uint16_t)
-______DOTPOWER_____SM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTPOWER_____SM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTPOWER_____SM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTPOWER_____SM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTPOWER_____SM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____SM__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, d, double, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTPOWER_____SM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____SM__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, d, double, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____SM__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTPOWER_____SM__(ui8, uint8_t, d, double, uint8_t)
-______DOTPOWER_____SM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTPOWER_____SM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTPOWER_____SM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTPOWER_____SM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTPOWER_____SM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____SM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____SM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____SM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____UU__(b, int32_t, b, int32_t, double)
-______DOTPOWER_____UU__(b, int32_t, c, double, double)
-______DOTPOWER_____UU__(b, int32_t, d, double, double)
-______DOTPOWER_____UU__(b, int32_t, i16, int16_t, int16_t)
-______DOTPOWER_____UU__(b, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____UU__(b, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(b, int32_t, i8, int8_t, int8_t)
-______DOTPOWER_____UU__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____UU__(c, double, b, int32_t, double)
-______DOTPOWER_____UU__(c, double, c, double, double)
-______DOTPOWER_____UU__(c, double, d, double, double)
-______DOTPOWER_____UU__(d, double, b, int32_t, double)
-______DOTPOWER_____UU__(d, double, c, double, double)
-______DOTPOWER_____UU__(d, double, d, double, double)
-______DOTPOWER_____UU__(d, double, i16, int16_t, int16_t)
-______DOTPOWER_____UU__(d, double, i32, int32_t, int32_t)
-______DOTPOWER_____UU__(d, double, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(d, double, i8, int8_t, int8_t)
-______DOTPOWER_____UU__(d, double, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(d, double, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(d, double, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(d, double, ui8, uint8_t, uint8_t)
-______DOTPOWER_____UU__(i16, int16_t, b, int32_t, int16_t)
-______DOTPOWER_____UU__(i16, int16_t, d, double, int16_t)
-______DOTPOWER_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______DOTPOWER_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______DOTPOWER_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______DOTPOWER_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____UU__(i32, int32_t, b, int32_t, int32_t)
-______DOTPOWER_____UU__(i32, int32_t, d, double, int32_t)
-______DOTPOWER_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______DOTPOWER_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______DOTPOWER_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______DOTPOWER_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____UU__(i64, int64_t, b, int32_t, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, d, double, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______DOTPOWER_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____UU__(i8, int8_t, b, int32_t, int8_t)
-______DOTPOWER_____UU__(i8, int8_t, d, double, int8_t)
-______DOTPOWER_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______DOTPOWER_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______DOTPOWER_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______DOTPOWER_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______DOTPOWER_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTPOWER_____UU__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTPOWER_____UU__(ui16, uint16_t, d, double, uint16_t)
-______DOTPOWER_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTPOWER_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTPOWER_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTPOWER_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTPOWER_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTPOWER_____UU__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, d, double, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTPOWER_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTPOWER_____UU__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, d, double, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTPOWER_____UU__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTPOWER_____UU__(ui8, uint8_t, d, double, uint8_t)
-______DOTPOWER_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTPOWER_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTPOWER_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTPOWER_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTPOWER_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTPOWER_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTPOWER_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTPOWER_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-__RAND_M__(b, int32_t, double)
-__RAND_M__(c, double, double)
-__RAND_M__(d, double, double)
-__RAND_M__(i16, int16_t, double)
-__RAND_M__(i32, int32_t, double)
-__RAND_M__(i64, int64_t, double)
-__RAND_M__(i8, int8_t, double)
-__RAND_M__(ui16, uint16_t, double)
-__RAND_M__(ui32, uint32_t, double)
-__RAND_M__(ui64, uint64_t, double)
-__RAND_M__(ui8, uint8_t, double)
-__RAND_SS__(d, double, d, double, double)
-______GE_____MM__(b, int32_t, b, int32_t, int32_t)
-______GE_____MM__(b, int32_t, c, double, int32_t)
-______GE_____MM__(b, int32_t, d, double, int32_t)
-______GE_____MM__(b, int32_t, i16, int16_t, int32_t)
-______GE_____MM__(b, int32_t, i32, int32_t, int32_t)
-______GE_____MM__(b, int32_t, i64, int64_t, int32_t)
-______GE_____MM__(b, int32_t, i8, int8_t, int32_t)
-______GE_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______GE_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______GE_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______GE_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______GE_____MM__(c, double, b, int32_t, int32_t)
-______GE_____MM__(c, double, c, double, int32_t)
-______GE_____MM__(c, double, d, double, int32_t)
-______GE_____MM__(c, double, i16, int16_t, int32_t)
-______GE_____MM__(c, double, i32, int32_t, int32_t)
-______GE_____MM__(c, double, i64, int64_t, int32_t)
-______GE_____MM__(c, double, i8, int8_t, int32_t)
-______GE_____MM__(c, double, ui16, uint16_t, int32_t)
-______GE_____MM__(c, double, ui32, uint32_t, int32_t)
-______GE_____MM__(c, double, ui64, uint64_t, int32_t)
-______GE_____MM__(c, double, ui8, uint8_t, int32_t)
-______GE_____MM__(d, double, b, int32_t, int32_t)
-______GE_____MM__(d, double, c, double, int32_t)
-______GE_____MM__(d, double, d, double, int32_t)
-______GE_____MM__(d, double, i16, int16_t, int32_t)
-______GE_____MM__(d, double, i32, int32_t, int32_t)
-______GE_____MM__(d, double, i64, int64_t, int32_t)
-______GE_____MM__(d, double, i8, int8_t, int32_t)
-______GE_____MM__(d, double, ui16, uint16_t, int32_t)
-______GE_____MM__(d, double, ui32, uint32_t, int32_t)
-______GE_____MM__(d, double, ui64, uint64_t, int32_t)
-______GE_____MM__(d, double, ui8, uint8_t, int32_t)
-______GE_____MM__(i16, int16_t, b, int32_t, int32_t)
-______GE_____MM__(i16, int16_t, c, double, int32_t)
-______GE_____MM__(i16, int16_t, d, double, int32_t)
-______GE_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______GE_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______GE_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______GE_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______GE_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______GE_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______GE_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______GE_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______GE_____MM__(i32, int32_t, b, int32_t, int32_t)
-______GE_____MM__(i32, int32_t, c, double, int32_t)
-______GE_____MM__(i32, int32_t, d, double, int32_t)
-______GE_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______GE_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______GE_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______GE_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______GE_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______GE_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______GE_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______GE_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______GE_____MM__(i64, int64_t, b, int32_t, int32_t)
-______GE_____MM__(i64, int64_t, c, double, int32_t)
-______GE_____MM__(i64, int64_t, d, double, int32_t)
-______GE_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______GE_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______GE_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______GE_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______GE_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______GE_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______GE_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______GE_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______GE_____MM__(i8, int8_t, b, int32_t, int32_t)
-______GE_____MM__(i8, int8_t, c, double, int32_t)
-______GE_____MM__(i8, int8_t, d, double, int32_t)
-______GE_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______GE_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______GE_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______GE_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______GE_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______GE_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______GE_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______GE_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______GE_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______GE_____MM__(ui16, uint16_t, c, double, int32_t)
-______GE_____MM__(ui16, uint16_t, d, double, int32_t)
-______GE_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______GE_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______GE_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______GE_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______GE_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GE_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GE_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GE_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GE_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______GE_____MM__(ui32, uint32_t, c, double, int32_t)
-______GE_____MM__(ui32, uint32_t, d, double, int32_t)
-______GE_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______GE_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______GE_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______GE_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______GE_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GE_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GE_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GE_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GE_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______GE_____MM__(ui64, uint64_t, c, double, int32_t)
-______GE_____MM__(ui64, uint64_t, d, double, int32_t)
-______GE_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______GE_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______GE_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______GE_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______GE_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GE_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GE_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GE_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GE_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______GE_____MM__(ui8, uint8_t, c, double, int32_t)
-______GE_____MM__(ui8, uint8_t, d, double, int32_t)
-______GE_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______GE_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______GE_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______GE_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______GE_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GE_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GE_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GE_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GE_____MS__(b, int32_t, b, int32_t, int32_t)
-______GE_____MS__(b, int32_t, c, double, int32_t)
-______GE_____MS__(b, int32_t, d, double, int32_t)
-______GE_____MS__(b, int32_t, i16, int16_t, int32_t)
-______GE_____MS__(b, int32_t, i32, int32_t, int32_t)
-______GE_____MS__(b, int32_t, i64, int64_t, int32_t)
-______GE_____MS__(b, int32_t, i8, int8_t, int32_t)
-______GE_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______GE_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______GE_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______GE_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______GE_____MS__(c, double, b, int32_t, int32_t)
-______GE_____MS__(c, double, c, double, int32_t)
-______GE_____MS__(c, double, d, double, int32_t)
-______GE_____MS__(c, double, i16, int16_t, int32_t)
-______GE_____MS__(c, double, i32, int32_t, int32_t)
-______GE_____MS__(c, double, i64, int64_t, int32_t)
-______GE_____MS__(c, double, i8, int8_t, int32_t)
-______GE_____MS__(c, double, ui16, uint16_t, int32_t)
-______GE_____MS__(c, double, ui32, uint32_t, int32_t)
-______GE_____MS__(c, double, ui64, uint64_t, int32_t)
-______GE_____MS__(c, double, ui8, uint8_t, int32_t)
-______GE_____MS__(d, double, b, int32_t, int32_t)
-______GE_____MS__(d, double, c, double, int32_t)
-______GE_____MS__(d, double, d, double, int32_t)
-______GE_____MS__(d, double, i16, int16_t, int32_t)
-______GE_____MS__(d, double, i32, int32_t, int32_t)
-______GE_____MS__(d, double, i64, int64_t, int32_t)
-______GE_____MS__(d, double, i8, int8_t, int32_t)
-______GE_____MS__(d, double, ui16, uint16_t, int32_t)
-______GE_____MS__(d, double, ui32, uint32_t, int32_t)
-______GE_____MS__(d, double, ui64, uint64_t, int32_t)
-______GE_____MS__(d, double, ui8, uint8_t, int32_t)
-______GE_____MS__(i16, int16_t, b, int32_t, int32_t)
-______GE_____MS__(i16, int16_t, c, double, int32_t)
-______GE_____MS__(i16, int16_t, d, double, int32_t)
-______GE_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______GE_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______GE_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______GE_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______GE_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______GE_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______GE_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______GE_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______GE_____MS__(i32, int32_t, b, int32_t, int32_t)
-______GE_____MS__(i32, int32_t, c, double, int32_t)
-______GE_____MS__(i32, int32_t, d, double, int32_t)
-______GE_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______GE_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______GE_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______GE_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______GE_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______GE_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______GE_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______GE_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______GE_____MS__(i64, int64_t, b, int32_t, int32_t)
-______GE_____MS__(i64, int64_t, c, double, int32_t)
-______GE_____MS__(i64, int64_t, d, double, int32_t)
-______GE_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______GE_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______GE_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______GE_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______GE_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______GE_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______GE_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______GE_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______GE_____MS__(i8, int8_t, b, int32_t, int32_t)
-______GE_____MS__(i8, int8_t, c, double, int32_t)
-______GE_____MS__(i8, int8_t, d, double, int32_t)
-______GE_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______GE_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______GE_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______GE_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______GE_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______GE_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______GE_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______GE_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______GE_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______GE_____MS__(ui16, uint16_t, c, double, int32_t)
-______GE_____MS__(ui16, uint16_t, d, double, int32_t)
-______GE_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______GE_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______GE_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______GE_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______GE_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GE_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GE_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GE_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GE_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______GE_____MS__(ui32, uint32_t, c, double, int32_t)
-______GE_____MS__(ui32, uint32_t, d, double, int32_t)
-______GE_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______GE_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______GE_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______GE_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______GE_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GE_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GE_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GE_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GE_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______GE_____MS__(ui64, uint64_t, c, double, int32_t)
-______GE_____MS__(ui64, uint64_t, d, double, int32_t)
-______GE_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______GE_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______GE_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______GE_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______GE_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GE_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GE_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GE_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GE_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______GE_____MS__(ui8, uint8_t, c, double, int32_t)
-______GE_____MS__(ui8, uint8_t, d, double, int32_t)
-______GE_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______GE_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______GE_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______GE_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______GE_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GE_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GE_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GE_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GE_____SM__(b, int32_t, b, int32_t, int32_t)
-______GE_____SM__(b, int32_t, c, double, int32_t)
-______GE_____SM__(b, int32_t, d, double, int32_t)
-______GE_____SM__(b, int32_t, i16, int16_t, int32_t)
-______GE_____SM__(b, int32_t, i32, int32_t, int32_t)
-______GE_____SM__(b, int32_t, i64, int64_t, int32_t)
-______GE_____SM__(b, int32_t, i8, int8_t, int32_t)
-______GE_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______GE_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______GE_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______GE_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______GE_____SM__(c, double, b, int32_t, int32_t)
-______GE_____SM__(c, double, c, double, int32_t)
-______GE_____SM__(c, double, d, double, int32_t)
-______GE_____SM__(c, double, i16, int16_t, int32_t)
-______GE_____SM__(c, double, i32, int32_t, int32_t)
-______GE_____SM__(c, double, i64, int64_t, int32_t)
-______GE_____SM__(c, double, i8, int8_t, int32_t)
-______GE_____SM__(c, double, ui16, uint16_t, int32_t)
-______GE_____SM__(c, double, ui32, uint32_t, int32_t)
-______GE_____SM__(c, double, ui64, uint64_t, int32_t)
-______GE_____SM__(c, double, ui8, uint8_t, int32_t)
-______GE_____SM__(d, double, b, int32_t, int32_t)
-______GE_____SM__(d, double, c, double, int32_t)
-______GE_____SM__(d, double, d, double, int32_t)
-______GE_____SM__(d, double, i16, int16_t, int32_t)
-______GE_____SM__(d, double, i32, int32_t, int32_t)
-______GE_____SM__(d, double, i64, int64_t, int32_t)
-______GE_____SM__(d, double, i8, int8_t, int32_t)
-______GE_____SM__(d, double, ui16, uint16_t, int32_t)
-______GE_____SM__(d, double, ui32, uint32_t, int32_t)
-______GE_____SM__(d, double, ui64, uint64_t, int32_t)
-______GE_____SM__(d, double, ui8, uint8_t, int32_t)
-______GE_____SM__(i16, int16_t, b, int32_t, int32_t)
-______GE_____SM__(i16, int16_t, c, double, int32_t)
-______GE_____SM__(i16, int16_t, d, double, int32_t)
-______GE_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______GE_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______GE_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______GE_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______GE_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______GE_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______GE_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______GE_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______GE_____SM__(i32, int32_t, b, int32_t, int32_t)
-______GE_____SM__(i32, int32_t, c, double, int32_t)
-______GE_____SM__(i32, int32_t, d, double, int32_t)
-______GE_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______GE_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______GE_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______GE_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______GE_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______GE_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______GE_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______GE_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______GE_____SM__(i64, int64_t, b, int32_t, int32_t)
-______GE_____SM__(i64, int64_t, c, double, int32_t)
-______GE_____SM__(i64, int64_t, d, double, int32_t)
-______GE_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______GE_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______GE_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______GE_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______GE_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______GE_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______GE_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______GE_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______GE_____SM__(i8, int8_t, b, int32_t, int32_t)
-______GE_____SM__(i8, int8_t, c, double, int32_t)
-______GE_____SM__(i8, int8_t, d, double, int32_t)
-______GE_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______GE_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______GE_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______GE_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______GE_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______GE_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______GE_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______GE_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______GE_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______GE_____SM__(ui16, uint16_t, c, double, int32_t)
-______GE_____SM__(ui16, uint16_t, d, double, int32_t)
-______GE_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______GE_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______GE_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______GE_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______GE_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GE_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GE_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GE_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GE_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______GE_____SM__(ui32, uint32_t, c, double, int32_t)
-______GE_____SM__(ui32, uint32_t, d, double, int32_t)
-______GE_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______GE_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______GE_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______GE_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______GE_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GE_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GE_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GE_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GE_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______GE_____SM__(ui64, uint64_t, c, double, int32_t)
-______GE_____SM__(ui64, uint64_t, d, double, int32_t)
-______GE_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______GE_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______GE_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______GE_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______GE_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GE_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GE_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GE_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GE_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______GE_____SM__(ui8, uint8_t, c, double, int32_t)
-______GE_____SM__(ui8, uint8_t, d, double, int32_t)
-______GE_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______GE_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______GE_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______GE_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______GE_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GE_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GE_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GE_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GE_____UU__(b, int32_t, b, int32_t, int32_t)
-______GE_____UU__(b, int32_t, c, double, int32_t)
-______GE_____UU__(b, int32_t, d, double, int32_t)
-______GE_____UU__(b, int32_t, i16, int16_t, int32_t)
-______GE_____UU__(b, int32_t, i32, int32_t, int32_t)
-______GE_____UU__(b, int32_t, i64, int64_t, int32_t)
-______GE_____UU__(b, int32_t, i8, int8_t, int32_t)
-______GE_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______GE_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______GE_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______GE_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______GE_____UU__(c, double, b, int32_t, int32_t)
-______GE_____UU__(c, double, c, double, int32_t)
-______GE_____UU__(c, double, d, double, int32_t)
-______GE_____UU__(c, double, i16, int16_t, int32_t)
-______GE_____UU__(c, double, i32, int32_t, int32_t)
-______GE_____UU__(c, double, i64, int64_t, int32_t)
-______GE_____UU__(c, double, i8, int8_t, int32_t)
-______GE_____UU__(c, double, ui16, uint16_t, int32_t)
-______GE_____UU__(c, double, ui32, uint32_t, int32_t)
-______GE_____UU__(c, double, ui64, uint64_t, int32_t)
-______GE_____UU__(c, double, ui8, uint8_t, int32_t)
-______GE_____UU__(d, double, b, int32_t, int32_t)
-______GE_____UU__(d, double, c, double, int32_t)
-______GE_____UU__(d, double, d, double, int32_t)
-______GE_____UU__(d, double, i16, int16_t, int32_t)
-______GE_____UU__(d, double, i32, int32_t, int32_t)
-______GE_____UU__(d, double, i64, int64_t, int32_t)
-______GE_____UU__(d, double, i8, int8_t, int32_t)
-______GE_____UU__(d, double, ui16, uint16_t, int32_t)
-______GE_____UU__(d, double, ui32, uint32_t, int32_t)
-______GE_____UU__(d, double, ui64, uint64_t, int32_t)
-______GE_____UU__(d, double, ui8, uint8_t, int32_t)
-______GE_____UU__(i16, int16_t, b, int32_t, int32_t)
-______GE_____UU__(i16, int16_t, c, double, int32_t)
-______GE_____UU__(i16, int16_t, d, double, int32_t)
-______GE_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______GE_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______GE_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______GE_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______GE_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______GE_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______GE_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______GE_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______GE_____UU__(i32, int32_t, b, int32_t, int32_t)
-______GE_____UU__(i32, int32_t, c, double, int32_t)
-______GE_____UU__(i32, int32_t, d, double, int32_t)
-______GE_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______GE_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______GE_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______GE_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______GE_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______GE_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______GE_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______GE_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______GE_____UU__(i64, int64_t, b, int32_t, int32_t)
-______GE_____UU__(i64, int64_t, c, double, int32_t)
-______GE_____UU__(i64, int64_t, d, double, int32_t)
-______GE_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______GE_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______GE_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______GE_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______GE_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______GE_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______GE_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______GE_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______GE_____UU__(i8, int8_t, b, int32_t, int32_t)
-______GE_____UU__(i8, int8_t, c, double, int32_t)
-______GE_____UU__(i8, int8_t, d, double, int32_t)
-______GE_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______GE_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______GE_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______GE_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______GE_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______GE_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______GE_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______GE_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______GE_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______GE_____UU__(ui16, uint16_t, c, double, int32_t)
-______GE_____UU__(ui16, uint16_t, d, double, int32_t)
-______GE_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______GE_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______GE_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______GE_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______GE_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GE_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GE_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GE_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GE_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______GE_____UU__(ui32, uint32_t, c, double, int32_t)
-______GE_____UU__(ui32, uint32_t, d, double, int32_t)
-______GE_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______GE_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______GE_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______GE_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______GE_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GE_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GE_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GE_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GE_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______GE_____UU__(ui64, uint64_t, c, double, int32_t)
-______GE_____UU__(ui64, uint64_t, d, double, int32_t)
-______GE_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______GE_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______GE_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______GE_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______GE_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GE_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GE_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GE_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GE_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______GE_____UU__(ui8, uint8_t, c, double, int32_t)
-______GE_____UU__(ui8, uint8_t, d, double, int32_t)
-______GE_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______GE_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______GE_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______GE_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______GE_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GE_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GE_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GE_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______OR_____MM__(b, int32_t, c, double, int32_t)
-______OR_____MM__(b, int32_t, d, double, int32_t)
-______OR_____MM__(b, int32_t, i16, int16_t, int32_t)
-______OR_____MM__(b, int32_t, i32, int32_t, int32_t)
-______OR_____MM__(b, int32_t, i64, int64_t, int32_t)
-______OR_____MM__(b, int32_t, i8, int8_t, int32_t)
-______OR_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______OR_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______OR_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______OR_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______OR_____MM__(c, double, b, int32_t, int32_t)
-______OR_____MM__(c, double, c, double, int32_t)
-______OR_____MM__(c, double, d, double, int32_t)
-______OR_____MM__(c, double, i16, int16_t, int32_t)
-______OR_____MM__(c, double, i32, int32_t, int32_t)
-______OR_____MM__(c, double, i64, int64_t, int32_t)
-______OR_____MM__(c, double, i8, int8_t, int32_t)
-______OR_____MM__(c, double, ui16, uint16_t, int32_t)
-______OR_____MM__(c, double, ui32, uint32_t, int32_t)
-______OR_____MM__(c, double, ui64, uint64_t, int32_t)
-______OR_____MM__(c, double, ui8, uint8_t, int32_t)
-______OR_____MM__(d, double, b, int32_t, int32_t)
-______OR_____MM__(d, double, c, double, int32_t)
-______OR_____MM__(d, double, d, double, int32_t)
-______OR_____MM__(d, double, i16, int16_t, int32_t)
-______OR_____MM__(d, double, i32, int32_t, int32_t)
-______OR_____MM__(d, double, i64, int64_t, int32_t)
-______OR_____MM__(d, double, i8, int8_t, int32_t)
-______OR_____MM__(d, double, ui16, uint16_t, int32_t)
-______OR_____MM__(d, double, ui32, uint32_t, int32_t)
-______OR_____MM__(d, double, ui64, uint64_t, int32_t)
-______OR_____MM__(d, double, ui8, uint8_t, int32_t)
-______OR_____MM__(i16, int16_t, b, int32_t, int32_t)
-______OR_____MM__(i16, int16_t, c, double, int32_t)
-______OR_____MM__(i16, int16_t, d, double, int32_t)
-______OR_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______OR_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______OR_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______OR_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______OR_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______OR_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______OR_____MM__(i32, int32_t, b, int32_t, int32_t)
-______OR_____MM__(i32, int32_t, c, double, int32_t)
-______OR_____MM__(i32, int32_t, d, double, int32_t)
-______OR_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______OR_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______OR_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______OR_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______OR_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______OR_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______OR_____MM__(i64, int64_t, b, int32_t, int32_t)
-______OR_____MM__(i64, int64_t, c, double, int32_t)
-______OR_____MM__(i64, int64_t, d, double, int32_t)
-______OR_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______OR_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______OR_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______OR_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______OR_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______OR_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______OR_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______OR_____MM__(i8, int8_t, b, int32_t, int32_t)
-______OR_____MM__(i8, int8_t, c, double, int32_t)
-______OR_____MM__(i8, int8_t, d, double, int32_t)
-______OR_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______OR_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______OR_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______OR_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______OR_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______OR_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______OR_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______OR_____MM__(ui16, uint16_t, c, double, int32_t)
-______OR_____MM__(ui16, uint16_t, d, double, int32_t)
-______OR_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______OR_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______OR_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______OR_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______OR_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______OR_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______OR_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______OR_____MM__(ui32, uint32_t, c, double, int32_t)
-______OR_____MM__(ui32, uint32_t, d, double, int32_t)
-______OR_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______OR_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______OR_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______OR_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______OR_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______OR_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______OR_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______OR_____MM__(ui64, uint64_t, c, double, int32_t)
-______OR_____MM__(ui64, uint64_t, d, double, int32_t)
-______OR_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______OR_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______OR_____MM__(ui8, uint8_t, c, double, int32_t)
-______OR_____MM__(ui8, uint8_t, d, double, int32_t)
-______OR_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______OR_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______OR_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______OR_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______OR_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______OR_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______OR_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______OR_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______OR_____MS__(b, int32_t, c, double, int32_t)
-______OR_____MS__(b, int32_t, d, double, int32_t)
-______OR_____MS__(b, int32_t, i16, int16_t, int32_t)
-______OR_____MS__(b, int32_t, i32, int32_t, int32_t)
-______OR_____MS__(b, int32_t, i64, int64_t, int32_t)
-______OR_____MS__(b, int32_t, i8, int8_t, int32_t)
-______OR_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______OR_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______OR_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______OR_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______OR_____MS__(c, double, b, int32_t, int32_t)
-______OR_____MS__(c, double, c, double, int32_t)
-______OR_____MS__(c, double, d, double, int32_t)
-______OR_____MS__(c, double, i16, int16_t, int32_t)
-______OR_____MS__(c, double, i32, int32_t, int32_t)
-______OR_____MS__(c, double, i64, int64_t, int32_t)
-______OR_____MS__(c, double, i8, int8_t, int32_t)
-______OR_____MS__(c, double, ui16, uint16_t, int32_t)
-______OR_____MS__(c, double, ui32, uint32_t, int32_t)
-______OR_____MS__(c, double, ui64, uint64_t, int32_t)
-______OR_____MS__(c, double, ui8, uint8_t, int32_t)
-______OR_____MS__(d, double, b, int32_t, int32_t)
-______OR_____MS__(d, double, c, double, int32_t)
-______OR_____MS__(d, double, d, double, int32_t)
-______OR_____MS__(d, double, i16, int16_t, int32_t)
-______OR_____MS__(d, double, i32, int32_t, int32_t)
-______OR_____MS__(d, double, i64, int64_t, int32_t)
-______OR_____MS__(d, double, i8, int8_t, int32_t)
-______OR_____MS__(d, double, ui16, uint16_t, int32_t)
-______OR_____MS__(d, double, ui32, uint32_t, int32_t)
-______OR_____MS__(d, double, ui64, uint64_t, int32_t)
-______OR_____MS__(d, double, ui8, uint8_t, int32_t)
-______OR_____MS__(i16, int16_t, b, int32_t, int32_t)
-______OR_____MS__(i16, int16_t, c, double, int32_t)
-______OR_____MS__(i16, int16_t, d, double, int32_t)
-______OR_____MS__(i16, int16_t, i16, int16_t, int16_t)
-______OR_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______OR_____MS__(i16, int16_t, i64, int64_t, int64_t)
-______OR_____MS__(i16, int16_t, i8, int8_t, int16_t)
-______OR_____MS__(i16, int16_t, ui16, uint16_t, uint16_t)
-______OR_____MS__(i16, int16_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(i16, int16_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(i16, int16_t, ui8, uint8_t, uint16_t)
-______OR_____MS__(i32, int32_t, b, int32_t, int32_t)
-______OR_____MS__(i32, int32_t, c, double, int32_t)
-______OR_____MS__(i32, int32_t, d, double, int32_t)
-______OR_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______OR_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______OR_____MS__(i32, int32_t, i64, int64_t, int64_t)
-______OR_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______OR_____MS__(i32, int32_t, ui16, uint16_t, uint32_t)
-______OR_____MS__(i32, int32_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(i32, int32_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(i32, int32_t, ui8, uint8_t, uint32_t)
-______OR_____MS__(i64, int64_t, b, int32_t, int32_t)
-______OR_____MS__(i64, int64_t, c, double, int32_t)
-______OR_____MS__(i64, int64_t, d, double, int32_t)
-______OR_____MS__(i64, int64_t, i16, int16_t, int64_t)
-______OR_____MS__(i64, int64_t, i32, int32_t, int64_t)
-______OR_____MS__(i64, int64_t, i64, int64_t, int64_t)
-______OR_____MS__(i64, int64_t, i8, int8_t, int64_t)
-______OR_____MS__(i64, int64_t, ui16, uint16_t, uint64_t)
-______OR_____MS__(i64, int64_t, ui32, uint32_t, uint64_t)
-______OR_____MS__(i64, int64_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(i64, int64_t, ui8, uint8_t, uint64_t)
-______OR_____MS__(i8, int8_t, b, int32_t, int32_t)
-______OR_____MS__(i8, int8_t, c, double, int32_t)
-______OR_____MS__(i8, int8_t, d, double, int32_t)
-______OR_____MS__(i8, int8_t, i16, int16_t, int16_t)
-______OR_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______OR_____MS__(i8, int8_t, i64, int64_t, int64_t)
-______OR_____MS__(i8, int8_t, i8, int8_t, int8_t)
-______OR_____MS__(i8, int8_t, ui16, uint16_t, uint16_t)
-______OR_____MS__(i8, int8_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(i8, int8_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(i8, int8_t, ui8, uint8_t, uint8_t)
-______OR_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______OR_____MS__(ui16, uint16_t, c, double, int32_t)
-______OR_____MS__(ui16, uint16_t, d, double, int32_t)
-______OR_____MS__(ui16, uint16_t, i16, int16_t, uint16_t)
-______OR_____MS__(ui16, uint16_t, i32, int32_t, uint32_t)
-______OR_____MS__(ui16, uint16_t, i64, int64_t, uint64_t)
-______OR_____MS__(ui16, uint16_t, i8, int8_t, uint16_t)
-______OR_____MS__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______OR_____MS__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______OR_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______OR_____MS__(ui32, uint32_t, c, double, int32_t)
-______OR_____MS__(ui32, uint32_t, d, double, int32_t)
-______OR_____MS__(ui32, uint32_t, i16, int16_t, uint32_t)
-______OR_____MS__(ui32, uint32_t, i32, int32_t, uint32_t)
-______OR_____MS__(ui32, uint32_t, i64, int64_t, uint64_t)
-______OR_____MS__(ui32, uint32_t, i8, int8_t, uint32_t)
-______OR_____MS__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______OR_____MS__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______OR_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______OR_____MS__(ui64, uint64_t, c, double, int32_t)
-______OR_____MS__(ui64, uint64_t, d, double, int32_t)
-______OR_____MS__(ui64, uint64_t, i16, int16_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, i32, int32_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, i64, int64_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, i8, int8_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______OR_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______OR_____MS__(ui8, uint8_t, c, double, int32_t)
-______OR_____MS__(ui8, uint8_t, d, double, int32_t)
-______OR_____MS__(ui8, uint8_t, i16, int16_t, uint16_t)
-______OR_____MS__(ui8, uint8_t, i32, int32_t, uint32_t)
-______OR_____MS__(ui8, uint8_t, i64, int64_t, uint64_t)
-______OR_____MS__(ui8, uint8_t, i8, int8_t, uint8_t)
-______OR_____MS__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______OR_____MS__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______OR_____MS__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______OR_____MS__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______OR_____SM__(b, int32_t, c, double, int32_t)
-______OR_____SM__(b, int32_t, d, double, int32_t)
-______OR_____SM__(b, int32_t, i16, int16_t, int32_t)
-______OR_____SM__(b, int32_t, i32, int32_t, int32_t)
-______OR_____SM__(b, int32_t, i64, int64_t, int32_t)
-______OR_____SM__(b, int32_t, i8, int8_t, int32_t)
-______OR_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______OR_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______OR_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______OR_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______OR_____SM__(c, double, b, int32_t, int32_t)
-______OR_____SM__(c, double, c, double, int32_t)
-______OR_____SM__(c, double, d, double, int32_t)
-______OR_____SM__(c, double, i16, int16_t, int32_t)
-______OR_____SM__(c, double, i32, int32_t, int32_t)
-______OR_____SM__(c, double, i64, int64_t, int32_t)
-______OR_____SM__(c, double, i8, int8_t, int32_t)
-______OR_____SM__(c, double, ui16, uint16_t, int32_t)
-______OR_____SM__(c, double, ui32, uint32_t, int32_t)
-______OR_____SM__(c, double, ui64, uint64_t, int32_t)
-______OR_____SM__(c, double, ui8, uint8_t, int32_t)
-______OR_____SM__(d, double, b, int32_t, int32_t)
-______OR_____SM__(d, double, c, double, int32_t)
-______OR_____SM__(d, double, d, double, int32_t)
-______OR_____SM__(d, double, i16, int16_t, int32_t)
-______OR_____SM__(d, double, i32, int32_t, int32_t)
-______OR_____SM__(d, double, i64, int64_t, int32_t)
-______OR_____SM__(d, double, i8, int8_t, int32_t)
-______OR_____SM__(d, double, ui16, uint16_t, int32_t)
-______OR_____SM__(d, double, ui32, uint32_t, int32_t)
-______OR_____SM__(d, double, ui64, uint64_t, int32_t)
-______OR_____SM__(d, double, ui8, uint8_t, int32_t)
-______OR_____SM__(i16, int16_t, b, int32_t, int32_t)
-______OR_____SM__(i16, int16_t, c, double, int32_t)
-______OR_____SM__(i16, int16_t, d, double, int32_t)
-______OR_____SM__(i16, int16_t, i16, int16_t, int16_t)
-______OR_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______OR_____SM__(i16, int16_t, i64, int64_t, int64_t)
-______OR_____SM__(i16, int16_t, i8, int8_t, int16_t)
-______OR_____SM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______OR_____SM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______OR_____SM__(i32, int32_t, b, int32_t, int32_t)
-______OR_____SM__(i32, int32_t, c, double, int32_t)
-______OR_____SM__(i32, int32_t, d, double, int32_t)
-______OR_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______OR_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______OR_____SM__(i32, int32_t, i64, int64_t, int64_t)
-______OR_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______OR_____SM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______OR_____SM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______OR_____SM__(i64, int64_t, b, int32_t, int32_t)
-______OR_____SM__(i64, int64_t, c, double, int32_t)
-______OR_____SM__(i64, int64_t, d, double, int32_t)
-______OR_____SM__(i64, int64_t, i16, int16_t, int64_t)
-______OR_____SM__(i64, int64_t, i32, int32_t, int64_t)
-______OR_____SM__(i64, int64_t, i64, int64_t, int64_t)
-______OR_____SM__(i64, int64_t, i8, int8_t, int64_t)
-______OR_____SM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______OR_____SM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______OR_____SM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______OR_____SM__(i8, int8_t, b, int32_t, int32_t)
-______OR_____SM__(i8, int8_t, c, double, int32_t)
-______OR_____SM__(i8, int8_t, d, double, int32_t)
-______OR_____SM__(i8, int8_t, i16, int16_t, int16_t)
-______OR_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______OR_____SM__(i8, int8_t, i64, int64_t, int64_t)
-______OR_____SM__(i8, int8_t, i8, int8_t, int8_t)
-______OR_____SM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______OR_____SM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______OR_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______OR_____SM__(ui16, uint16_t, c, double, int32_t)
-______OR_____SM__(ui16, uint16_t, d, double, int32_t)
-______OR_____SM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______OR_____SM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______OR_____SM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______OR_____SM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______OR_____SM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______OR_____SM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______OR_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______OR_____SM__(ui32, uint32_t, c, double, int32_t)
-______OR_____SM__(ui32, uint32_t, d, double, int32_t)
-______OR_____SM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______OR_____SM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______OR_____SM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______OR_____SM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______OR_____SM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______OR_____SM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______OR_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______OR_____SM__(ui64, uint64_t, c, double, int32_t)
-______OR_____SM__(ui64, uint64_t, d, double, int32_t)
-______OR_____SM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______OR_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______OR_____SM__(ui8, uint8_t, c, double, int32_t)
-______OR_____SM__(ui8, uint8_t, d, double, int32_t)
-______OR_____SM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______OR_____SM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______OR_____SM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______OR_____SM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______OR_____SM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______OR_____SM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______OR_____SM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______OR_____SM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______OR_____UU__(b, int32_t, c, double, int32_t)
-______OR_____UU__(b, int32_t, d, double, int32_t)
-______OR_____UU__(b, int32_t, i16, int16_t, int32_t)
-______OR_____UU__(b, int32_t, i32, int32_t, int32_t)
-______OR_____UU__(b, int32_t, i64, int64_t, int32_t)
-______OR_____UU__(b, int32_t, i8, int8_t, int32_t)
-______OR_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______OR_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______OR_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______OR_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______OR_____UU__(c, double, b, int32_t, int32_t)
-______OR_____UU__(c, double, c, double, int32_t)
-______OR_____UU__(c, double, d, double, int32_t)
-______OR_____UU__(c, double, i16, int16_t, int32_t)
-______OR_____UU__(c, double, i32, int32_t, int32_t)
-______OR_____UU__(c, double, i64, int64_t, int32_t)
-______OR_____UU__(c, double, i8, int8_t, int32_t)
-______OR_____UU__(c, double, ui16, uint16_t, int32_t)
-______OR_____UU__(c, double, ui32, uint32_t, int32_t)
-______OR_____UU__(c, double, ui64, uint64_t, int32_t)
-______OR_____UU__(c, double, ui8, uint8_t, int32_t)
-______OR_____UU__(d, double, b, int32_t, int32_t)
-______OR_____UU__(d, double, c, double, int32_t)
-______OR_____UU__(d, double, d, double, int32_t)
-______OR_____UU__(d, double, i16, int16_t, int32_t)
-______OR_____UU__(d, double, i32, int32_t, int32_t)
-______OR_____UU__(d, double, i64, int64_t, int32_t)
-______OR_____UU__(d, double, i8, int8_t, int32_t)
-______OR_____UU__(d, double, ui16, uint16_t, int32_t)
-______OR_____UU__(d, double, ui32, uint32_t, int32_t)
-______OR_____UU__(d, double, ui64, uint64_t, int32_t)
-______OR_____UU__(d, double, ui8, uint8_t, int32_t)
-______OR_____UU__(i16, int16_t, b, int32_t, int32_t)
-______OR_____UU__(i16, int16_t, c, double, int32_t)
-______OR_____UU__(i16, int16_t, d, double, int32_t)
-______OR_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______OR_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______OR_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______OR_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______OR_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______OR_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______OR_____UU__(i32, int32_t, b, int32_t, int32_t)
-______OR_____UU__(i32, int32_t, c, double, int32_t)
-______OR_____UU__(i32, int32_t, d, double, int32_t)
-______OR_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______OR_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______OR_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______OR_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______OR_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______OR_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______OR_____UU__(i64, int64_t, b, int32_t, int32_t)
-______OR_____UU__(i64, int64_t, c, double, int32_t)
-______OR_____UU__(i64, int64_t, d, double, int32_t)
-______OR_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______OR_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______OR_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______OR_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______OR_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______OR_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______OR_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______OR_____UU__(i8, int8_t, b, int32_t, int32_t)
-______OR_____UU__(i8, int8_t, c, double, int32_t)
-______OR_____UU__(i8, int8_t, d, double, int32_t)
-______OR_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______OR_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______OR_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______OR_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______OR_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______OR_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______OR_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______OR_____UU__(ui16, uint16_t, c, double, int32_t)
-______OR_____UU__(ui16, uint16_t, d, double, int32_t)
-______OR_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______OR_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______OR_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______OR_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______OR_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______OR_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______OR_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______OR_____UU__(ui32, uint32_t, c, double, int32_t)
-______OR_____UU__(ui32, uint32_t, d, double, int32_t)
-______OR_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______OR_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______OR_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______OR_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______OR_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______OR_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______OR_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______OR_____UU__(ui64, uint64_t, c, double, int32_t)
-______OR_____UU__(ui64, uint64_t, d, double, int32_t)
-______OR_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______OR_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______OR_____UU__(ui8, uint8_t, c, double, int32_t)
-______OR_____UU__(ui8, uint8_t, d, double, int32_t)
-______OR_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______OR_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______OR_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______OR_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______OR_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______OR_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______OR_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______OR_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______POWER_____MM__(b, int32_t, b, int32_t, double)
-______POWER_____MM__(b, int32_t, c, double, double)
-______POWER_____MM__(b, int32_t, d, double, double)
-______POWER_____MM__(b, int32_t, i16, int16_t, int16_t)
-______POWER_____MM__(b, int32_t, i32, int32_t, int32_t)
-______POWER_____MM__(b, int32_t, i64, int64_t, int64_t)
-______POWER_____MM__(b, int32_t, i8, int8_t, int8_t)
-______POWER_____MM__(b, int32_t, ui16, uint16_t, uint16_t)
-______POWER_____MM__(b, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(b, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(b, int32_t, ui8, uint8_t, uint8_t)
-______POWER_____MM__(c, double, b, int32_t, double)
-______POWER_____MM__(c, double, c, double, double)
-______POWER_____MM__(c, double, d, double, double)
-______POWER_____MM__(d, double, b, int32_t, double)
-______POWER_____MM__(d, double, c, double, double)
-______POWER_____MM__(d, double, d, double, double)
-______POWER_____MM__(d, double, i16, int16_t, int16_t)
-______POWER_____MM__(d, double, i32, int32_t, int32_t)
-______POWER_____MM__(d, double, i64, int64_t, int64_t)
-______POWER_____MM__(d, double, i8, int8_t, int8_t)
-______POWER_____MM__(d, double, ui16, uint16_t, uint16_t)
-______POWER_____MM__(d, double, ui32, uint32_t, uint32_t)
-______POWER_____MM__(d, double, ui64, uint64_t, uint64_t)
-______POWER_____MM__(d, double, ui8, uint8_t, uint8_t)
-______POWER_____MM__(i16, int16_t, b, int32_t, int16_t)
-______POWER_____MM__(i16, int16_t, d, double, int16_t)
-______POWER_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______POWER_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______POWER_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______POWER_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______POWER_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______POWER_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______POWER_____MM__(i32, int32_t, b, int32_t, int32_t)
-______POWER_____MM__(i32, int32_t, d, double, int32_t)
-______POWER_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______POWER_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______POWER_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______POWER_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______POWER_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______POWER_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______POWER_____MM__(i64, int64_t, b, int32_t, int64_t)
-______POWER_____MM__(i64, int64_t, d, double, int64_t)
-______POWER_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______POWER_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______POWER_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______POWER_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______POWER_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______POWER_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______POWER_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______POWER_____MM__(i8, int8_t, b, int32_t, int8_t)
-______POWER_____MM__(i8, int8_t, d, double, int8_t)
-______POWER_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______POWER_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______POWER_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______POWER_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______POWER_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______POWER_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______POWER_____MM__(ui16, uint16_t, b, int32_t, uint16_t)
-______POWER_____MM__(ui16, uint16_t, d, double, uint16_t)
-______POWER_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______POWER_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______POWER_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______POWER_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______POWER_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______POWER_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______POWER_____MM__(ui32, uint32_t, b, int32_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, d, double, uint32_t)
-______POWER_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______POWER_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______POWER_____MM__(ui64, uint64_t, b, int32_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, d, double, uint64_t)
-______POWER_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______POWER_____MM__(ui8, uint8_t, b, int32_t, uint8_t)
-______POWER_____MM__(ui8, uint8_t, d, double, uint8_t)
-______POWER_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______POWER_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______POWER_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______POWER_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______POWER_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______POWER_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______POWER_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______POWER_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______POWER_____SM__(b, int32_t, b, int32_t, double)
-______POWER_____SM__(b, int32_t, c, double, double)
-______POWER_____SM__(b, int32_t, d, double, double)
-______POWER_____SM__(b, int32_t, i16, int16_t, int16_t)
-______POWER_____SM__(b, int32_t, i32, int32_t, int32_t)
-______POWER_____SM__(b, int32_t, i64, int64_t, int64_t)
-______POWER_____SM__(b, int32_t, i8, int8_t, int8_t)
-______POWER_____SM__(b, int32_t, ui16, uint16_t, uint16_t)
-______POWER_____SM__(b, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(b, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(b, int32_t, ui8, uint8_t, uint8_t)
-______POWER_____SM__(c, double, b, int32_t, double)
-______POWER_____SM__(c, double, c, double, double)
-______POWER_____SM__(c, double, d, double, double)
-______POWER_____SM__(d, double, b, int32_t, double)
-______POWER_____SM__(d, double, c, double, double)
-______POWER_____SM__(d, double, d, double, double)
-______POWER_____SM__(d, double, i16, int16_t, int16_t)
-______POWER_____SM__(d, double, i32, int32_t, int32_t)
-______POWER_____SM__(d, double, i64, int64_t, int64_t)
-______POWER_____SM__(d, double, i8, int8_t, int8_t)
-______POWER_____SM__(d, double, ui16, uint16_t, uint16_t)
-______POWER_____SM__(d, double, ui32, uint32_t, uint32_t)
-______POWER_____SM__(d, double, ui64, uint64_t, uint64_t)
-______POWER_____SM__(d, double, ui8, uint8_t, uint8_t)
-______POWER_____SM__(i16, int16_t, b, int32_t, int16_t)
-______POWER_____SM__(i16, int16_t, d, double, int16_t)
-______POWER_____SM__(i16, int16_t, i16, int16_t, int16_t)
-______POWER_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______POWER_____SM__(i16, int16_t, i64, int64_t, int64_t)
-______POWER_____SM__(i16, int16_t, i8, int8_t, int16_t)
-______POWER_____SM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______POWER_____SM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______POWER_____SM__(i32, int32_t, b, int32_t, int32_t)
-______POWER_____SM__(i32, int32_t, d, double, int32_t)
-______POWER_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______POWER_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______POWER_____SM__(i32, int32_t, i64, int64_t, int64_t)
-______POWER_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______POWER_____SM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______POWER_____SM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______POWER_____SM__(i64, int64_t, b, int32_t, int64_t)
-______POWER_____SM__(i64, int64_t, d, double, int64_t)
-______POWER_____SM__(i64, int64_t, i16, int16_t, int64_t)
-______POWER_____SM__(i64, int64_t, i32, int32_t, int64_t)
-______POWER_____SM__(i64, int64_t, i64, int64_t, int64_t)
-______POWER_____SM__(i64, int64_t, i8, int8_t, int64_t)
-______POWER_____SM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______POWER_____SM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______POWER_____SM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______POWER_____SM__(i8, int8_t, b, int32_t, int8_t)
-______POWER_____SM__(i8, int8_t, d, double, int8_t)
-______POWER_____SM__(i8, int8_t, i16, int16_t, int16_t)
-______POWER_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______POWER_____SM__(i8, int8_t, i64, int64_t, int64_t)
-______POWER_____SM__(i8, int8_t, i8, int8_t, int8_t)
-______POWER_____SM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______POWER_____SM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______POWER_____SM__(ui16, uint16_t, b, int32_t, uint16_t)
-______POWER_____SM__(ui16, uint16_t, d, double, uint16_t)
-______POWER_____SM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______POWER_____SM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______POWER_____SM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______POWER_____SM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______POWER_____SM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______POWER_____SM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______POWER_____SM__(ui32, uint32_t, b, int32_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, d, double, uint32_t)
-______POWER_____SM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______POWER_____SM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______POWER_____SM__(ui64, uint64_t, b, int32_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, d, double, uint64_t)
-______POWER_____SM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______POWER_____SM__(ui8, uint8_t, b, int32_t, uint8_t)
-______POWER_____SM__(ui8, uint8_t, d, double, uint8_t)
-______POWER_____SM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______POWER_____SM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______POWER_____SM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______POWER_____SM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______POWER_____SM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______POWER_____SM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______POWER_____SM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______POWER_____SM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______POWER_____UU__(b, int32_t, b, int32_t, double)
-______POWER_____UU__(b, int32_t, c, double, double)
-______POWER_____UU__(b, int32_t, d, double, double)
-______POWER_____UU__(b, int32_t, i16, int16_t, int16_t)
-______POWER_____UU__(b, int32_t, i32, int32_t, int32_t)
-______POWER_____UU__(b, int32_t, i64, int64_t, int64_t)
-______POWER_____UU__(b, int32_t, i8, int8_t, int8_t)
-______POWER_____UU__(b, int32_t, ui16, uint16_t, uint16_t)
-______POWER_____UU__(b, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(b, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(b, int32_t, ui8, uint8_t, uint8_t)
-______POWER_____UU__(c, double, b, int32_t, double)
-______POWER_____UU__(c, double, c, double, double)
-______POWER_____UU__(c, double, d, double, double)
-______POWER_____UU__(d, double, b, int32_t, double)
-______POWER_____UU__(d, double, c, double, double)
-______POWER_____UU__(d, double, d, double, double)
-______POWER_____UU__(d, double, i16, int16_t, int16_t)
-______POWER_____UU__(d, double, i32, int32_t, int32_t)
-______POWER_____UU__(d, double, i64, int64_t, int64_t)
-______POWER_____UU__(d, double, i8, int8_t, int8_t)
-______POWER_____UU__(d, double, ui16, uint16_t, uint16_t)
-______POWER_____UU__(d, double, ui32, uint32_t, uint32_t)
-______POWER_____UU__(d, double, ui64, uint64_t, uint64_t)
-______POWER_____UU__(d, double, ui8, uint8_t, uint8_t)
-______POWER_____UU__(i16, int16_t, b, int32_t, int16_t)
-______POWER_____UU__(i16, int16_t, d, double, int16_t)
-______POWER_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______POWER_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______POWER_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______POWER_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______POWER_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______POWER_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______POWER_____UU__(i32, int32_t, b, int32_t, int32_t)
-______POWER_____UU__(i32, int32_t, d, double, int32_t)
-______POWER_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______POWER_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______POWER_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______POWER_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______POWER_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______POWER_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______POWER_____UU__(i64, int64_t, b, int32_t, int64_t)
-______POWER_____UU__(i64, int64_t, d, double, int64_t)
-______POWER_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______POWER_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______POWER_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______POWER_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______POWER_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______POWER_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______POWER_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______POWER_____UU__(i8, int8_t, b, int32_t, int8_t)
-______POWER_____UU__(i8, int8_t, d, double, int8_t)
-______POWER_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______POWER_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______POWER_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______POWER_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______POWER_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______POWER_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______POWER_____UU__(ui16, uint16_t, b, int32_t, uint16_t)
-______POWER_____UU__(ui16, uint16_t, d, double, uint16_t)
-______POWER_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______POWER_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______POWER_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______POWER_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______POWER_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______POWER_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______POWER_____UU__(ui32, uint32_t, b, int32_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, d, double, uint32_t)
-______POWER_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______POWER_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______POWER_____UU__(ui64, uint64_t, b, int32_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, d, double, uint64_t)
-______POWER_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______POWER_____UU__(ui8, uint8_t, b, int32_t, uint8_t)
-______POWER_____UU__(ui8, uint8_t, d, double, uint8_t)
-______POWER_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______POWER_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______POWER_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______POWER_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______POWER_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______POWER_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______POWER_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______POWER_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______NOT_____M__(b, int32_t, int32_t)
-______NOT_____M__(c, double, int32_t)
-______NOT_____M__(d, double, int32_t)
-______NOT_____M__(i16, int16_t, int32_t)
-______NOT_____M__(i32, int32_t, int32_t)
-______NOT_____M__(i64, int64_t, int32_t)
-______NOT_____M__(i8, int8_t, int32_t)
-______NOT_____M__(ui16, uint16_t, int32_t)
-______NOT_____M__(ui32, uint32_t, int32_t)
-______NOT_____M__(ui64, uint64_t, int32_t)
-______NOT_____M__(ui8, uint8_t, int32_t)
-__ISREAL_MS__(c, double, d, double, int32_t)
-__ISREAL_MS__(d, double, d, double, int32_t)
-__ISREAL_M__(c, double, int32_t)
-__ISREAL_M__(d, double, int32_t)
-______TRANSP_____M__(b, int32_t, int32_t)
-______TRANSP_____M__(c, double, double)
-______TRANSP_____M__(d, double, double)
-______TRANSP_____M__(i16, int16_t, int16_t)
-______TRANSP_____M__(i32, int32_t, int32_t)
-______TRANSP_____M__(i64, int64_t, int64_t)
-______TRANSP_____M__(i8, int8_t, int8_t)
-______TRANSP_____M__(ui16, uint16_t, uint16_t)
-______TRANSP_____M__(ui32, uint32_t, uint32_t)
-______TRANSP_____M__(ui64, uint64_t, uint64_t)
-______TRANSP_____M__(ui8, uint8_t, uint8_t)
-__ABS_M__(c, double, double)
-__ABS_M__(d, double, double)
-__ABS_M__(i16, int16_t, int16_t)
-__ABS_M__(i32, int32_t, int32_t)
-__ABS_M__(i64, int64_t, int64_t)
-__ABS_M__(i8, int8_t, int8_t)
-__ABS_M__(ui16, uint16_t, uint16_t)
-__ABS_M__(ui32, uint32_t, uint32_t)
-__ABS_M__(ui64, uint64_t, uint64_t)
-__ABS_M__(ui8, uint8_t, uint8_t)
-__COSH_M__(c, double, double)
-__COSH_M__(d, double, double)
-
-__INT16_M__(d, double, int16_t)
-__INT16_M__(i16, int16_t, int16_t)
-__INT16_M__(i32, int32_t, int16_t)
-__INT16_M__(i64, int64_t, int16_t)
-__INT16_M__(i8, int8_t, int16_t)
-__INT16_M__(ui16, uint16_t, int16_t)
-__INT16_M__(ui32, uint32_t, int16_t)
-__INT16_M__(ui64, uint64_t, int16_t)
-__INT16_M__(ui8, uint8_t, int16_t)
-
-
-______NEQ_____MM__(b, int32_t, b, int32_t, int32_t)
-______NEQ_____MM__(b, int32_t, c, double, int32_t)
-______NEQ_____MM__(b, int32_t, d, double, int32_t)
-______NEQ_____MM__(b, int32_t, i16, int16_t, int32_t)
-______NEQ_____MM__(b, int32_t, i32, int32_t, int32_t)
-______NEQ_____MM__(b, int32_t, i64, int64_t, int32_t)
-______NEQ_____MM__(b, int32_t, i8, int8_t, int32_t)
-______NEQ_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(c, double, b, int32_t, int32_t)
-______NEQ_____MM__(c, double, c, double, int32_t)
-______NEQ_____MM__(c, double, d, double, int32_t)
-______NEQ_____MM__(c, double, i16, int16_t, int32_t)
-______NEQ_____MM__(c, double, i32, int32_t, int32_t)
-______NEQ_____MM__(c, double, i64, int64_t, int32_t)
-______NEQ_____MM__(c, double, i8, int8_t, int32_t)
-______NEQ_____MM__(c, double, ui16, uint16_t, int32_t)
-______NEQ_____MM__(c, double, ui32, uint32_t, int32_t)
-______NEQ_____MM__(c, double, ui64, uint64_t, int32_t)
-______NEQ_____MM__(c, double, ui8, uint8_t, int32_t)
-______NEQ_____MM__(d, double, b, int32_t, int32_t)
-______NEQ_____MM__(d, double, c, double, int32_t)
-______NEQ_____MM__(d, double, d, double, int32_t)
-______NEQ_____MM__(d, double, i16, int16_t, int32_t)
-______NEQ_____MM__(d, double, i32, int32_t, int32_t)
-______NEQ_____MM__(d, double, i64, int64_t, int32_t)
-______NEQ_____MM__(d, double, i8, int8_t, int32_t)
-______NEQ_____MM__(d, double, ui16, uint16_t, int32_t)
-______NEQ_____MM__(d, double, ui32, uint32_t, int32_t)
-______NEQ_____MM__(d, double, ui64, uint64_t, int32_t)
-______NEQ_____MM__(d, double, ui8, uint8_t, int32_t)
-______NEQ_____MM__(i16, int16_t, b, int32_t, int32_t)
-______NEQ_____MM__(i16, int16_t, c, double, int32_t)
-______NEQ_____MM__(i16, int16_t, d, double, int32_t)
-______NEQ_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______NEQ_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______NEQ_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______NEQ_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______NEQ_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(i32, int32_t, b, int32_t, int32_t)
-______NEQ_____MM__(i32, int32_t, c, double, int32_t)
-______NEQ_____MM__(i32, int32_t, d, double, int32_t)
-______NEQ_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______NEQ_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______NEQ_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______NEQ_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______NEQ_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(i64, int64_t, b, int32_t, int32_t)
-______NEQ_____MM__(i64, int64_t, c, double, int32_t)
-______NEQ_____MM__(i64, int64_t, d, double, int32_t)
-______NEQ_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______NEQ_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______NEQ_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______NEQ_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______NEQ_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(i8, int8_t, b, int32_t, int32_t)
-______NEQ_____MM__(i8, int8_t, c, double, int32_t)
-______NEQ_____MM__(i8, int8_t, d, double, int32_t)
-______NEQ_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______NEQ_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______NEQ_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______NEQ_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______NEQ_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, c, double, int32_t)
-______NEQ_____MM__(ui16, uint16_t, d, double, int32_t)
-______NEQ_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, c, double, int32_t)
-______NEQ_____MM__(ui32, uint32_t, d, double, int32_t)
-______NEQ_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, c, double, int32_t)
-______NEQ_____MM__(ui64, uint64_t, d, double, int32_t)
-______NEQ_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, c, double, int32_t)
-______NEQ_____MM__(ui8, uint8_t, d, double, int32_t)
-______NEQ_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______NEQ_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(b, int32_t, b, int32_t, int32_t)
-______NEQ_____MS__(b, int32_t, c, double, int32_t)
-______NEQ_____MS__(b, int32_t, d, double, int32_t)
-______NEQ_____MS__(b, int32_t, i16, int16_t, int32_t)
-______NEQ_____MS__(b, int32_t, i32, int32_t, int32_t)
-______NEQ_____MS__(b, int32_t, i64, int64_t, int32_t)
-______NEQ_____MS__(b, int32_t, i8, int8_t, int32_t)
-______NEQ_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(c, double, b, int32_t, int32_t)
-______NEQ_____MS__(c, double, c, double, int32_t)
-______NEQ_____MS__(c, double, d, double, int32_t)
-______NEQ_____MS__(c, double, i16, int16_t, int32_t)
-______NEQ_____MS__(c, double, i32, int32_t, int32_t)
-______NEQ_____MS__(c, double, i64, int64_t, int32_t)
-______NEQ_____MS__(c, double, i8, int8_t, int32_t)
-______NEQ_____MS__(c, double, ui16, uint16_t, int32_t)
-______NEQ_____MS__(c, double, ui32, uint32_t, int32_t)
-______NEQ_____MS__(c, double, ui64, uint64_t, int32_t)
-______NEQ_____MS__(c, double, ui8, uint8_t, int32_t)
-______NEQ_____MS__(d, double, b, int32_t, int32_t)
-______NEQ_____MS__(d, double, c, double, int32_t)
-______NEQ_____MS__(d, double, d, double, int32_t)
-______NEQ_____MS__(d, double, i16, int16_t, int32_t)
-______NEQ_____MS__(d, double, i32, int32_t, int32_t)
-______NEQ_____MS__(d, double, i64, int64_t, int32_t)
-______NEQ_____MS__(d, double, i8, int8_t, int32_t)
-______NEQ_____MS__(d, double, ui16, uint16_t, int32_t)
-______NEQ_____MS__(d, double, ui32, uint32_t, int32_t)
-______NEQ_____MS__(d, double, ui64, uint64_t, int32_t)
-______NEQ_____MS__(d, double, ui8, uint8_t, int32_t)
-______NEQ_____MS__(i16, int16_t, b, int32_t, int32_t)
-______NEQ_____MS__(i16, int16_t, c, double, int32_t)
-______NEQ_____MS__(i16, int16_t, d, double, int32_t)
-______NEQ_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______NEQ_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______NEQ_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______NEQ_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______NEQ_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(i32, int32_t, b, int32_t, int32_t)
-______NEQ_____MS__(i32, int32_t, c, double, int32_t)
-______NEQ_____MS__(i32, int32_t, d, double, int32_t)
-______NEQ_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______NEQ_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______NEQ_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______NEQ_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______NEQ_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(i64, int64_t, b, int32_t, int32_t)
-______NEQ_____MS__(i64, int64_t, c, double, int32_t)
-______NEQ_____MS__(i64, int64_t, d, double, int32_t)
-______NEQ_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______NEQ_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______NEQ_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______NEQ_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______NEQ_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(i8, int8_t, b, int32_t, int32_t)
-______NEQ_____MS__(i8, int8_t, c, double, int32_t)
-______NEQ_____MS__(i8, int8_t, d, double, int32_t)
-______NEQ_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______NEQ_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______NEQ_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______NEQ_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______NEQ_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, c, double, int32_t)
-______NEQ_____MS__(ui16, uint16_t, d, double, int32_t)
-______NEQ_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, c, double, int32_t)
-______NEQ_____MS__(ui32, uint32_t, d, double, int32_t)
-______NEQ_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, c, double, int32_t)
-______NEQ_____MS__(ui64, uint64_t, d, double, int32_t)
-______NEQ_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, c, double, int32_t)
-______NEQ_____MS__(ui8, uint8_t, d, double, int32_t)
-______NEQ_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______NEQ_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(b, int32_t, b, int32_t, int32_t)
-______NEQ_____SM__(b, int32_t, c, double, int32_t)
-______NEQ_____SM__(b, int32_t, d, double, int32_t)
-______NEQ_____SM__(b, int32_t, i16, int16_t, int32_t)
-______NEQ_____SM__(b, int32_t, i32, int32_t, int32_t)
-______NEQ_____SM__(b, int32_t, i64, int64_t, int32_t)
-______NEQ_____SM__(b, int32_t, i8, int8_t, int32_t)
-______NEQ_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(c, double, b, int32_t, int32_t)
-______NEQ_____SM__(c, double, c, double, int32_t)
-______NEQ_____SM__(c, double, d, double, int32_t)
-______NEQ_____SM__(c, double, i16, int16_t, int32_t)
-______NEQ_____SM__(c, double, i32, int32_t, int32_t)
-______NEQ_____SM__(c, double, i64, int64_t, int32_t)
-______NEQ_____SM__(c, double, i8, int8_t, int32_t)
-______NEQ_____SM__(c, double, ui16, uint16_t, int32_t)
-______NEQ_____SM__(c, double, ui32, uint32_t, int32_t)
-______NEQ_____SM__(c, double, ui64, uint64_t, int32_t)
-______NEQ_____SM__(c, double, ui8, uint8_t, int32_t)
-______NEQ_____SM__(d, double, b, int32_t, int32_t)
-______NEQ_____SM__(d, double, c, double, int32_t)
-______NEQ_____SM__(d, double, d, double, int32_t)
-______NEQ_____SM__(d, double, i16, int16_t, int32_t)
-______NEQ_____SM__(d, double, i32, int32_t, int32_t)
-______NEQ_____SM__(d, double, i64, int64_t, int32_t)
-______NEQ_____SM__(d, double, i8, int8_t, int32_t)
-______NEQ_____SM__(d, double, ui16, uint16_t, int32_t)
-______NEQ_____SM__(d, double, ui32, uint32_t, int32_t)
-______NEQ_____SM__(d, double, ui64, uint64_t, int32_t)
-______NEQ_____SM__(d, double, ui8, uint8_t, int32_t)
-______NEQ_____SM__(i16, int16_t, b, int32_t, int32_t)
-______NEQ_____SM__(i16, int16_t, c, double, int32_t)
-______NEQ_____SM__(i16, int16_t, d, double, int32_t)
-______NEQ_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______NEQ_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______NEQ_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______NEQ_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______NEQ_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(i32, int32_t, b, int32_t, int32_t)
-______NEQ_____SM__(i32, int32_t, c, double, int32_t)
-______NEQ_____SM__(i32, int32_t, d, double, int32_t)
-______NEQ_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______NEQ_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______NEQ_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______NEQ_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______NEQ_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(i64, int64_t, b, int32_t, int32_t)
-______NEQ_____SM__(i64, int64_t, c, double, int32_t)
-______NEQ_____SM__(i64, int64_t, d, double, int32_t)
-______NEQ_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______NEQ_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______NEQ_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______NEQ_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______NEQ_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(i8, int8_t, b, int32_t, int32_t)
-______NEQ_____SM__(i8, int8_t, c, double, int32_t)
-______NEQ_____SM__(i8, int8_t, d, double, int32_t)
-______NEQ_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______NEQ_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______NEQ_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______NEQ_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______NEQ_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, c, double, int32_t)
-______NEQ_____SM__(ui16, uint16_t, d, double, int32_t)
-______NEQ_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, c, double, int32_t)
-______NEQ_____SM__(ui32, uint32_t, d, double, int32_t)
-______NEQ_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, c, double, int32_t)
-______NEQ_____SM__(ui64, uint64_t, d, double, int32_t)
-______NEQ_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, c, double, int32_t)
-______NEQ_____SM__(ui8, uint8_t, d, double, int32_t)
-______NEQ_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______NEQ_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(b, int32_t, b, int32_t, int32_t)
-______NEQ_____UU__(b, int32_t, c, double, int32_t)
-______NEQ_____UU__(b, int32_t, d, double, int32_t)
-______NEQ_____UU__(b, int32_t, i16, int16_t, int32_t)
-______NEQ_____UU__(b, int32_t, i32, int32_t, int32_t)
-______NEQ_____UU__(b, int32_t, i64, int64_t, int32_t)
-______NEQ_____UU__(b, int32_t, i8, int8_t, int32_t)
-______NEQ_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(c, double, b, int32_t, int32_t)
-______NEQ_____UU__(c, double, c, double, int32_t)
-______NEQ_____UU__(c, double, d, double, int32_t)
-______NEQ_____UU__(c, double, i16, int16_t, int32_t)
-______NEQ_____UU__(c, double, i32, int32_t, int32_t)
-______NEQ_____UU__(c, double, i64, int64_t, int32_t)
-______NEQ_____UU__(c, double, i8, int8_t, int32_t)
-______NEQ_____UU__(c, double, ui16, uint16_t, int32_t)
-______NEQ_____UU__(c, double, ui32, uint32_t, int32_t)
-______NEQ_____UU__(c, double, ui64, uint64_t, int32_t)
-______NEQ_____UU__(c, double, ui8, uint8_t, int32_t)
-______NEQ_____UU__(d, double, b, int32_t, int32_t)
-______NEQ_____UU__(d, double, c, double, int32_t)
-______NEQ_____UU__(d, double, d, double, int32_t)
-______NEQ_____UU__(d, double, i16, int16_t, int32_t)
-______NEQ_____UU__(d, double, i32, int32_t, int32_t)
-______NEQ_____UU__(d, double, i64, int64_t, int32_t)
-______NEQ_____UU__(d, double, i8, int8_t, int32_t)
-______NEQ_____UU__(d, double, ui16, uint16_t, int32_t)
-______NEQ_____UU__(d, double, ui32, uint32_t, int32_t)
-______NEQ_____UU__(d, double, ui64, uint64_t, int32_t)
-______NEQ_____UU__(d, double, ui8, uint8_t, int32_t)
-______NEQ_____UU__(i16, int16_t, b, int32_t, int32_t)
-______NEQ_____UU__(i16, int16_t, c, double, int32_t)
-______NEQ_____UU__(i16, int16_t, d, double, int32_t)
-______NEQ_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______NEQ_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______NEQ_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______NEQ_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______NEQ_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(i32, int32_t, b, int32_t, int32_t)
-______NEQ_____UU__(i32, int32_t, c, double, int32_t)
-______NEQ_____UU__(i32, int32_t, d, double, int32_t)
-______NEQ_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______NEQ_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______NEQ_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______NEQ_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______NEQ_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(i64, int64_t, b, int32_t, int32_t)
-______NEQ_____UU__(i64, int64_t, c, double, int32_t)
-______NEQ_____UU__(i64, int64_t, d, double, int32_t)
-______NEQ_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______NEQ_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______NEQ_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______NEQ_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______NEQ_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(i8, int8_t, b, int32_t, int32_t)
-______NEQ_____UU__(i8, int8_t, c, double, int32_t)
-______NEQ_____UU__(i8, int8_t, d, double, int32_t)
-______NEQ_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______NEQ_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______NEQ_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______NEQ_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______NEQ_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, c, double, int32_t)
-______NEQ_____UU__(ui16, uint16_t, d, double, int32_t)
-______NEQ_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, c, double, int32_t)
-______NEQ_____UU__(ui32, uint32_t, d, double, int32_t)
-______NEQ_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, c, double, int32_t)
-______NEQ_____UU__(ui64, uint64_t, d, double, int32_t)
-______NEQ_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, c, double, int32_t)
-______NEQ_____UU__(ui8, uint8_t, d, double, int32_t)
-______NEQ_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______NEQ_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______AND_____MM__(b, int32_t, c, double, int32_t)
-______AND_____MM__(b, int32_t, d, double, int32_t)
-______AND_____MM__(b, int32_t, i16, int16_t, int32_t)
-______AND_____MM__(b, int32_t, i32, int32_t, int32_t)
-______AND_____MM__(b, int32_t, i64, int64_t, int32_t)
-______AND_____MM__(b, int32_t, i8, int8_t, int32_t)
-______AND_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______AND_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______AND_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______AND_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______AND_____MM__(c, double, b, int32_t, int32_t)
-______AND_____MM__(c, double, c, double, int32_t)
-______AND_____MM__(c, double, d, double, int32_t)
-______AND_____MM__(c, double, i16, int16_t, int32_t)
-______AND_____MM__(c, double, i32, int32_t, int32_t)
-______AND_____MM__(c, double, i64, int64_t, int32_t)
-______AND_____MM__(c, double, i8, int8_t, int32_t)
-______AND_____MM__(c, double, ui16, uint16_t, int32_t)
-______AND_____MM__(c, double, ui32, uint32_t, int32_t)
-______AND_____MM__(c, double, ui64, uint64_t, int32_t)
-______AND_____MM__(c, double, ui8, uint8_t, int32_t)
-______AND_____MM__(d, double, b, int32_t, int32_t)
-______AND_____MM__(d, double, c, double, int32_t)
-______AND_____MM__(d, double, d, double, int32_t)
-______AND_____MM__(d, double, i16, int16_t, int32_t)
-______AND_____MM__(d, double, i32, int32_t, int32_t)
-______AND_____MM__(d, double, i64, int64_t, int32_t)
-______AND_____MM__(d, double, i8, int8_t, int32_t)
-______AND_____MM__(d, double, ui16, uint16_t, int32_t)
-______AND_____MM__(d, double, ui32, uint32_t, int32_t)
-______AND_____MM__(d, double, ui64, uint64_t, int32_t)
-______AND_____MM__(d, double, ui8, uint8_t, int32_t)
-______AND_____MM__(i16, int16_t, b, int32_t, int32_t)
-______AND_____MM__(i16, int16_t, c, double, int32_t)
-______AND_____MM__(i16, int16_t, d, double, int32_t)
-______AND_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______AND_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______AND_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______AND_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______AND_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______AND_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______AND_____MM__(i32, int32_t, b, int32_t, int32_t)
-______AND_____MM__(i32, int32_t, c, double, int32_t)
-______AND_____MM__(i32, int32_t, d, double, int32_t)
-______AND_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______AND_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______AND_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______AND_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______AND_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______AND_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______AND_____MM__(i64, int64_t, b, int32_t, int32_t)
-______AND_____MM__(i64, int64_t, c, double, int32_t)
-______AND_____MM__(i64, int64_t, d, double, int32_t)
-______AND_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______AND_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______AND_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______AND_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______AND_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______AND_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______AND_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______AND_____MM__(i8, int8_t, b, int32_t, int32_t)
-______AND_____MM__(i8, int8_t, c, double, int32_t)
-______AND_____MM__(i8, int8_t, d, double, int32_t)
-______AND_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______AND_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______AND_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______AND_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______AND_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______AND_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______AND_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______AND_____MM__(ui16, uint16_t, c, double, int32_t)
-______AND_____MM__(ui16, uint16_t, d, double, int32_t)
-______AND_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______AND_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______AND_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______AND_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______AND_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______AND_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______AND_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______AND_____MM__(ui32, uint32_t, c, double, int32_t)
-______AND_____MM__(ui32, uint32_t, d, double, int32_t)
-______AND_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______AND_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______AND_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______AND_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______AND_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______AND_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______AND_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______AND_____MM__(ui64, uint64_t, c, double, int32_t)
-______AND_____MM__(ui64, uint64_t, d, double, int32_t)
-______AND_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______AND_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______AND_____MM__(ui8, uint8_t, c, double, int32_t)
-______AND_____MM__(ui8, uint8_t, d, double, int32_t)
-______AND_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______AND_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______AND_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______AND_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______AND_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______AND_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______AND_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______AND_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______AND_____MS__(b, int32_t, c, double, int32_t)
-______AND_____MS__(b, int32_t, d, double, int32_t)
-______AND_____MS__(b, int32_t, i16, int16_t, int32_t)
-______AND_____MS__(b, int32_t, i32, int32_t, int32_t)
-______AND_____MS__(b, int32_t, i64, int64_t, int32_t)
-______AND_____MS__(b, int32_t, i8, int8_t, int32_t)
-______AND_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______AND_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______AND_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______AND_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______AND_____MS__(c, double, b, int32_t, int32_t)
-______AND_____MS__(c, double, c, double, int32_t)
-______AND_____MS__(c, double, d, double, int32_t)
-______AND_____MS__(c, double, i16, int16_t, int32_t)
-______AND_____MS__(c, double, i32, int32_t, int32_t)
-______AND_____MS__(c, double, i64, int64_t, int32_t)
-______AND_____MS__(c, double, i8, int8_t, int32_t)
-______AND_____MS__(c, double, ui16, uint16_t, int32_t)
-______AND_____MS__(c, double, ui32, uint32_t, int32_t)
-______AND_____MS__(c, double, ui64, uint64_t, int32_t)
-______AND_____MS__(c, double, ui8, uint8_t, int32_t)
-______AND_____MS__(d, double, b, int32_t, int32_t)
-______AND_____MS__(d, double, c, double, int32_t)
-______AND_____MS__(d, double, d, double, int32_t)
-______AND_____MS__(d, double, i16, int16_t, int32_t)
-______AND_____MS__(d, double, i32, int32_t, int32_t)
-______AND_____MS__(d, double, i64, int64_t, int32_t)
-______AND_____MS__(d, double, i8, int8_t, int32_t)
-______AND_____MS__(d, double, ui16, uint16_t, int32_t)
-______AND_____MS__(d, double, ui32, uint32_t, int32_t)
-______AND_____MS__(d, double, ui64, uint64_t, int32_t)
-______AND_____MS__(d, double, ui8, uint8_t, int32_t)
-______AND_____MS__(i16, int16_t, b, int32_t, int32_t)
-______AND_____MS__(i16, int16_t, c, double, int32_t)
-______AND_____MS__(i16, int16_t, d, double, int32_t)
-______AND_____MS__(i16, int16_t, i16, int16_t, int16_t)
-______AND_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______AND_____MS__(i16, int16_t, i64, int64_t, int64_t)
-______AND_____MS__(i16, int16_t, i8, int8_t, int16_t)
-______AND_____MS__(i16, int16_t, ui16, uint16_t, uint16_t)
-______AND_____MS__(i16, int16_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(i16, int16_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(i16, int16_t, ui8, uint8_t, uint16_t)
-______AND_____MS__(i32, int32_t, b, int32_t, int32_t)
-______AND_____MS__(i32, int32_t, c, double, int32_t)
-______AND_____MS__(i32, int32_t, d, double, int32_t)
-______AND_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______AND_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______AND_____MS__(i32, int32_t, i64, int64_t, int64_t)
-______AND_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______AND_____MS__(i32, int32_t, ui16, uint16_t, uint32_t)
-______AND_____MS__(i32, int32_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(i32, int32_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(i32, int32_t, ui8, uint8_t, uint32_t)
-______AND_____MS__(i64, int64_t, b, int32_t, int32_t)
-______AND_____MS__(i64, int64_t, c, double, int32_t)
-______AND_____MS__(i64, int64_t, d, double, int32_t)
-______AND_____MS__(i64, int64_t, i16, int16_t, int64_t)
-______AND_____MS__(i64, int64_t, i32, int32_t, int64_t)
-______AND_____MS__(i64, int64_t, i64, int64_t, int64_t)
-______AND_____MS__(i64, int64_t, i8, int8_t, int64_t)
-______AND_____MS__(i64, int64_t, ui16, uint16_t, uint64_t)
-______AND_____MS__(i64, int64_t, ui32, uint32_t, uint64_t)
-______AND_____MS__(i64, int64_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(i64, int64_t, ui8, uint8_t, uint64_t)
-______AND_____MS__(i8, int8_t, b, int32_t, int32_t)
-______AND_____MS__(i8, int8_t, c, double, int32_t)
-______AND_____MS__(i8, int8_t, d, double, int32_t)
-______AND_____MS__(i8, int8_t, i16, int16_t, int16_t)
-______AND_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______AND_____MS__(i8, int8_t, i64, int64_t, int64_t)
-______AND_____MS__(i8, int8_t, i8, int8_t, int8_t)
-______AND_____MS__(i8, int8_t, ui16, uint16_t, uint16_t)
-______AND_____MS__(i8, int8_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(i8, int8_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(i8, int8_t, ui8, uint8_t, uint8_t)
-______AND_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______AND_____MS__(ui16, uint16_t, c, double, int32_t)
-______AND_____MS__(ui16, uint16_t, d, double, int32_t)
-______AND_____MS__(ui16, uint16_t, i16, int16_t, uint16_t)
-______AND_____MS__(ui16, uint16_t, i32, int32_t, uint32_t)
-______AND_____MS__(ui16, uint16_t, i64, int64_t, uint64_t)
-______AND_____MS__(ui16, uint16_t, i8, int8_t, uint16_t)
-______AND_____MS__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______AND_____MS__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______AND_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______AND_____MS__(ui32, uint32_t, c, double, int32_t)
-______AND_____MS__(ui32, uint32_t, d, double, int32_t)
-______AND_____MS__(ui32, uint32_t, i16, int16_t, uint32_t)
-______AND_____MS__(ui32, uint32_t, i32, int32_t, uint32_t)
-______AND_____MS__(ui32, uint32_t, i64, int64_t, uint64_t)
-______AND_____MS__(ui32, uint32_t, i8, int8_t, uint32_t)
-______AND_____MS__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______AND_____MS__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______AND_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______AND_____MS__(ui64, uint64_t, c, double, int32_t)
-______AND_____MS__(ui64, uint64_t, d, double, int32_t)
-______AND_____MS__(ui64, uint64_t, i16, int16_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, i32, int32_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, i64, int64_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, i8, int8_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______AND_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______AND_____MS__(ui8, uint8_t, c, double, int32_t)
-______AND_____MS__(ui8, uint8_t, d, double, int32_t)
-______AND_____MS__(ui8, uint8_t, i16, int16_t, uint16_t)
-______AND_____MS__(ui8, uint8_t, i32, int32_t, uint32_t)
-______AND_____MS__(ui8, uint8_t, i64, int64_t, uint64_t)
-______AND_____MS__(ui8, uint8_t, i8, int8_t, uint8_t)
-______AND_____MS__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______AND_____MS__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______AND_____MS__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______AND_____MS__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______AND_____SM__(b, int32_t, c, double, int32_t)
-______AND_____SM__(b, int32_t, d, double, int32_t)
-______AND_____SM__(b, int32_t, i16, int16_t, int32_t)
-______AND_____SM__(b, int32_t, i32, int32_t, int32_t)
-______AND_____SM__(b, int32_t, i64, int64_t, int32_t)
-______AND_____SM__(b, int32_t, i8, int8_t, int32_t)
-______AND_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______AND_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______AND_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______AND_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______AND_____SM__(c, double, b, int32_t, int32_t)
-______AND_____SM__(c, double, c, double, int32_t)
-______AND_____SM__(c, double, d, double, int32_t)
-______AND_____SM__(c, double, i16, int16_t, int32_t)
-______AND_____SM__(c, double, i32, int32_t, int32_t)
-______AND_____SM__(c, double, i64, int64_t, int32_t)
-______AND_____SM__(c, double, i8, int8_t, int32_t)
-______AND_____SM__(c, double, ui16, uint16_t, int32_t)
-______AND_____SM__(c, double, ui32, uint32_t, int32_t)
-______AND_____SM__(c, double, ui64, uint64_t, int32_t)
-______AND_____SM__(c, double, ui8, uint8_t, int32_t)
-______AND_____SM__(d, double, b, int32_t, int32_t)
-______AND_____SM__(d, double, c, double, int32_t)
-______AND_____SM__(d, double, d, double, int32_t)
-______AND_____SM__(d, double, i16, int16_t, int32_t)
-______AND_____SM__(d, double, i32, int32_t, int32_t)
-______AND_____SM__(d, double, i64, int64_t, int32_t)
-______AND_____SM__(d, double, i8, int8_t, int32_t)
-______AND_____SM__(d, double, ui16, uint16_t, int32_t)
-______AND_____SM__(d, double, ui32, uint32_t, int32_t)
-______AND_____SM__(d, double, ui64, uint64_t, int32_t)
-______AND_____SM__(d, double, ui8, uint8_t, int32_t)
-______AND_____SM__(i16, int16_t, b, int32_t, int32_t)
-______AND_____SM__(i16, int16_t, c, double, int32_t)
-______AND_____SM__(i16, int16_t, d, double, int32_t)
-______AND_____SM__(i16, int16_t, i16, int16_t, int16_t)
-______AND_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______AND_____SM__(i16, int16_t, i64, int64_t, int64_t)
-______AND_____SM__(i16, int16_t, i8, int8_t, int16_t)
-______AND_____SM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______AND_____SM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______AND_____SM__(i32, int32_t, b, int32_t, int32_t)
-______AND_____SM__(i32, int32_t, c, double, int32_t)
-______AND_____SM__(i32, int32_t, d, double, int32_t)
-______AND_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______AND_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______AND_____SM__(i32, int32_t, i64, int64_t, int64_t)
-______AND_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______AND_____SM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______AND_____SM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______AND_____SM__(i64, int64_t, b, int32_t, int32_t)
-______AND_____SM__(i64, int64_t, c, double, int32_t)
-______AND_____SM__(i64, int64_t, d, double, int32_t)
-______AND_____SM__(i64, int64_t, i16, int16_t, int64_t)
-______AND_____SM__(i64, int64_t, i32, int32_t, int64_t)
-______AND_____SM__(i64, int64_t, i64, int64_t, int64_t)
-______AND_____SM__(i64, int64_t, i8, int8_t, int64_t)
-______AND_____SM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______AND_____SM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______AND_____SM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______AND_____SM__(i8, int8_t, b, int32_t, int32_t)
-______AND_____SM__(i8, int8_t, c, double, int32_t)
-______AND_____SM__(i8, int8_t, d, double, int32_t)
-______AND_____SM__(i8, int8_t, i16, int16_t, int16_t)
-______AND_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______AND_____SM__(i8, int8_t, i64, int64_t, int64_t)
-______AND_____SM__(i8, int8_t, i8, int8_t, int8_t)
-______AND_____SM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______AND_____SM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______AND_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______AND_____SM__(ui16, uint16_t, c, double, int32_t)
-______AND_____SM__(ui16, uint16_t, d, double, int32_t)
-______AND_____SM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______AND_____SM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______AND_____SM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______AND_____SM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______AND_____SM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______AND_____SM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______AND_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______AND_____SM__(ui32, uint32_t, c, double, int32_t)
-______AND_____SM__(ui32, uint32_t, d, double, int32_t)
-______AND_____SM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______AND_____SM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______AND_____SM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______AND_____SM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______AND_____SM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______AND_____SM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______AND_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______AND_____SM__(ui64, uint64_t, c, double, int32_t)
-______AND_____SM__(ui64, uint64_t, d, double, int32_t)
-______AND_____SM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______AND_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______AND_____SM__(ui8, uint8_t, c, double, int32_t)
-______AND_____SM__(ui8, uint8_t, d, double, int32_t)
-______AND_____SM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______AND_____SM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______AND_____SM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______AND_____SM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______AND_____SM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______AND_____SM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______AND_____SM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______AND_____SM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______AND_____UU__(b, int32_t, c, double, int32_t)
-______AND_____UU__(b, int32_t, d, double, int32_t)
-______AND_____UU__(b, int32_t, i16, int16_t, int32_t)
-______AND_____UU__(b, int32_t, i32, int32_t, int32_t)
-______AND_____UU__(b, int32_t, i64, int64_t, int32_t)
-______AND_____UU__(b, int32_t, i8, int8_t, int32_t)
-______AND_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______AND_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______AND_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______AND_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______AND_____UU__(c, double, b, int32_t, int32_t)
-______AND_____UU__(c, double, c, double, int32_t)
-______AND_____UU__(c, double, d, double, int32_t)
-______AND_____UU__(c, double, i16, int16_t, int32_t)
-______AND_____UU__(c, double, i32, int32_t, int32_t)
-______AND_____UU__(c, double, i64, int64_t, int32_t)
-______AND_____UU__(c, double, i8, int8_t, int32_t)
-______AND_____UU__(c, double, ui16, uint16_t, int32_t)
-______AND_____UU__(c, double, ui32, uint32_t, int32_t)
-______AND_____UU__(c, double, ui64, uint64_t, int32_t)
-______AND_____UU__(c, double, ui8, uint8_t, int32_t)
-______AND_____UU__(d, double, b, int32_t, int32_t)
-______AND_____UU__(d, double, c, double, int32_t)
-______AND_____UU__(d, double, d, double, int32_t)
-______AND_____UU__(d, double, i16, int16_t, int32_t)
-______AND_____UU__(d, double, i32, int32_t, int32_t)
-______AND_____UU__(d, double, i64, int64_t, int32_t)
-______AND_____UU__(d, double, i8, int8_t, int32_t)
-______AND_____UU__(d, double, ui16, uint16_t, int32_t)
-______AND_____UU__(d, double, ui32, uint32_t, int32_t)
-______AND_____UU__(d, double, ui64, uint64_t, int32_t)
-______AND_____UU__(d, double, ui8, uint8_t, int32_t)
-______AND_____UU__(i16, int16_t, b, int32_t, int32_t)
-______AND_____UU__(i16, int16_t, c, double, int32_t)
-______AND_____UU__(i16, int16_t, d, double, int32_t)
-______AND_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______AND_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______AND_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______AND_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______AND_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______AND_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______AND_____UU__(i32, int32_t, b, int32_t, int32_t)
-______AND_____UU__(i32, int32_t, c, double, int32_t)
-______AND_____UU__(i32, int32_t, d, double, int32_t)
-______AND_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______AND_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______AND_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______AND_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______AND_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______AND_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______AND_____UU__(i64, int64_t, b, int32_t, int32_t)
-______AND_____UU__(i64, int64_t, c, double, int32_t)
-______AND_____UU__(i64, int64_t, d, double, int32_t)
-______AND_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______AND_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______AND_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______AND_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______AND_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______AND_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______AND_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______AND_____UU__(i8, int8_t, b, int32_t, int32_t)
-______AND_____UU__(i8, int8_t, c, double, int32_t)
-______AND_____UU__(i8, int8_t, d, double, int32_t)
-______AND_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______AND_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______AND_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______AND_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______AND_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______AND_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______AND_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______AND_____UU__(ui16, uint16_t, c, double, int32_t)
-______AND_____UU__(ui16, uint16_t, d, double, int32_t)
-______AND_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______AND_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______AND_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______AND_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______AND_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______AND_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______AND_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______AND_____UU__(ui32, uint32_t, c, double, int32_t)
-______AND_____UU__(ui32, uint32_t, d, double, int32_t)
-______AND_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______AND_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______AND_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______AND_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______AND_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______AND_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______AND_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______AND_____UU__(ui64, uint64_t, c, double, int32_t)
-______AND_____UU__(ui64, uint64_t, d, double, int32_t)
-______AND_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______AND_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______AND_____UU__(ui8, uint8_t, c, double, int32_t)
-______AND_____UU__(ui8, uint8_t, d, double, int32_t)
-______AND_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______AND_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______AND_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______AND_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______AND_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______AND_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______AND_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______AND_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-__TAN_M__(c, double, double)
-__TAN_M__(d, double, double)
-__CUMSUM_M__(c, double, double)
-__CUMSUM_M__(d, double, double)
-__CUMSUM_M__(i16, int16_t, int16_t)
-__CUMSUM_M__(i32, int32_t, int32_t)
-__CUMSUM_M__(i64, int64_t, int64_t)
-__CUMSUM_M__(i8, int8_t, int8_t)
-__CUMSUM_M__(ui16, uint16_t, uint16_t)
-__CUMSUM_M__(ui32, uint32_t, uint32_t)
-__CUMSUM_M__(ui64, uint64_t, uint64_t)
-__CUMSUM_M__(ui8, uint8_t, uint8_t)
-__SIZE_M__(b, int32_t, double)
-__SIZE_M__(c, double, double)
-__SIZE_M__(d, double, double)
-__SIZE_M__(i16, int16_t, double)
-__SIZE_M__(i32, int32_t, double)
-__SIZE_M__(i64, int64_t, double)
-__SIZE_M__(i8, int8_t, double)
-__SIZE_M__(ui16, uint16_t, double)
-__SIZE_M__(ui32, uint32_t, double)
-__SIZE_M__(ui64, uint64_t, double)
-__SIZE_M__(ui8, uint8_t, double)
-______ANDAND_____MM__(b, int32_t, b, int32_t, int32_t)
-______ANDAND_____MM__(b, int32_t, c, double, int32_t)
-______ANDAND_____MM__(b, int32_t, d, double, int32_t)
-______ANDAND_____MM__(b, int32_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(b, int32_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(b, int32_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(b, int32_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(c, double, b, int32_t, int32_t)
-______ANDAND_____MM__(c, double, c, double, int32_t)
-______ANDAND_____MM__(c, double, d, double, int32_t)
-______ANDAND_____MM__(c, double, i16, int16_t, int32_t)
-______ANDAND_____MM__(c, double, i32, int32_t, int32_t)
-______ANDAND_____MM__(c, double, i64, int64_t, int32_t)
-______ANDAND_____MM__(c, double, i8, int8_t, int32_t)
-______ANDAND_____MM__(c, double, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(c, double, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(c, double, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(c, double, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(d, double, b, int32_t, int32_t)
-______ANDAND_____MM__(d, double, c, double, int32_t)
-______ANDAND_____MM__(d, double, d, double, int32_t)
-______ANDAND_____MM__(d, double, i16, int16_t, int32_t)
-______ANDAND_____MM__(d, double, i32, int32_t, int32_t)
-______ANDAND_____MM__(d, double, i64, int64_t, int32_t)
-______ANDAND_____MM__(d, double, i8, int8_t, int32_t)
-______ANDAND_____MM__(d, double, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(d, double, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(d, double, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(d, double, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, b, int32_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, c, double, int32_t)
-______ANDAND_____MM__(i16, int16_t, d, double, int32_t)
-______ANDAND_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, b, int32_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, c, double, int32_t)
-______ANDAND_____MM__(i32, int32_t, d, double, int32_t)
-______ANDAND_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, b, int32_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, c, double, int32_t)
-______ANDAND_____MM__(i64, int64_t, d, double, int32_t)
-______ANDAND_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, b, int32_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, c, double, int32_t)
-______ANDAND_____MM__(i8, int8_t, d, double, int32_t)
-______ANDAND_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, c, double, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, d, double, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, c, double, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, d, double, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, c, double, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, d, double, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, c, double, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, d, double, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______ANDAND_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(b, int32_t, b, int32_t, int32_t)
-______ANDAND_____MS__(b, int32_t, c, double, int32_t)
-______ANDAND_____MS__(b, int32_t, d, double, int32_t)
-______ANDAND_____MS__(b, int32_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(b, int32_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(b, int32_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(b, int32_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(c, double, b, int32_t, int32_t)
-______ANDAND_____MS__(c, double, c, double, int32_t)
-______ANDAND_____MS__(c, double, d, double, int32_t)
-______ANDAND_____MS__(c, double, i16, int16_t, int32_t)
-______ANDAND_____MS__(c, double, i32, int32_t, int32_t)
-______ANDAND_____MS__(c, double, i64, int64_t, int32_t)
-______ANDAND_____MS__(c, double, i8, int8_t, int32_t)
-______ANDAND_____MS__(c, double, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(c, double, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(c, double, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(c, double, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(d, double, b, int32_t, int32_t)
-______ANDAND_____MS__(d, double, c, double, int32_t)
-______ANDAND_____MS__(d, double, d, double, int32_t)
-______ANDAND_____MS__(d, double, i16, int16_t, int32_t)
-______ANDAND_____MS__(d, double, i32, int32_t, int32_t)
-______ANDAND_____MS__(d, double, i64, int64_t, int32_t)
-______ANDAND_____MS__(d, double, i8, int8_t, int32_t)
-______ANDAND_____MS__(d, double, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(d, double, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(d, double, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(d, double, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, b, int32_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, c, double, int32_t)
-______ANDAND_____MS__(i16, int16_t, d, double, int32_t)
-______ANDAND_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, b, int32_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, c, double, int32_t)
-______ANDAND_____MS__(i32, int32_t, d, double, int32_t)
-______ANDAND_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, b, int32_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, c, double, int32_t)
-______ANDAND_____MS__(i64, int64_t, d, double, int32_t)
-______ANDAND_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, b, int32_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, c, double, int32_t)
-______ANDAND_____MS__(i8, int8_t, d, double, int32_t)
-______ANDAND_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, c, double, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, d, double, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, c, double, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, d, double, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, c, double, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, d, double, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, c, double, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, d, double, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______ANDAND_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(b, int32_t, b, int32_t, int32_t)
-______ANDAND_____SM__(b, int32_t, c, double, int32_t)
-______ANDAND_____SM__(b, int32_t, d, double, int32_t)
-______ANDAND_____SM__(b, int32_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(b, int32_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(b, int32_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(b, int32_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(c, double, b, int32_t, int32_t)
-______ANDAND_____SM__(c, double, c, double, int32_t)
-______ANDAND_____SM__(c, double, d, double, int32_t)
-______ANDAND_____SM__(c, double, i16, int16_t, int32_t)
-______ANDAND_____SM__(c, double, i32, int32_t, int32_t)
-______ANDAND_____SM__(c, double, i64, int64_t, int32_t)
-______ANDAND_____SM__(c, double, i8, int8_t, int32_t)
-______ANDAND_____SM__(c, double, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(c, double, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(c, double, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(c, double, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(d, double, b, int32_t, int32_t)
-______ANDAND_____SM__(d, double, c, double, int32_t)
-______ANDAND_____SM__(d, double, d, double, int32_t)
-______ANDAND_____SM__(d, double, i16, int16_t, int32_t)
-______ANDAND_____SM__(d, double, i32, int32_t, int32_t)
-______ANDAND_____SM__(d, double, i64, int64_t, int32_t)
-______ANDAND_____SM__(d, double, i8, int8_t, int32_t)
-______ANDAND_____SM__(d, double, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(d, double, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(d, double, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(d, double, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, b, int32_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, c, double, int32_t)
-______ANDAND_____SM__(i16, int16_t, d, double, int32_t)
-______ANDAND_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, b, int32_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, c, double, int32_t)
-______ANDAND_____SM__(i32, int32_t, d, double, int32_t)
-______ANDAND_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, b, int32_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, c, double, int32_t)
-______ANDAND_____SM__(i64, int64_t, d, double, int32_t)
-______ANDAND_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, b, int32_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, c, double, int32_t)
-______ANDAND_____SM__(i8, int8_t, d, double, int32_t)
-______ANDAND_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, c, double, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, d, double, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, c, double, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, d, double, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, c, double, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, d, double, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, c, double, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, d, double, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______ANDAND_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(b, int32_t, b, int32_t, int32_t)
-______ANDAND_____UU__(b, int32_t, c, double, int32_t)
-______ANDAND_____UU__(b, int32_t, d, double, int32_t)
-______ANDAND_____UU__(b, int32_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(b, int32_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(b, int32_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(b, int32_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(c, double, b, int32_t, int32_t)
-______ANDAND_____UU__(c, double, c, double, int32_t)
-______ANDAND_____UU__(c, double, d, double, int32_t)
-______ANDAND_____UU__(c, double, i16, int16_t, int32_t)
-______ANDAND_____UU__(c, double, i32, int32_t, int32_t)
-______ANDAND_____UU__(c, double, i64, int64_t, int32_t)
-______ANDAND_____UU__(c, double, i8, int8_t, int32_t)
-______ANDAND_____UU__(c, double, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(c, double, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(c, double, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(c, double, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(d, double, b, int32_t, int32_t)
-______ANDAND_____UU__(d, double, c, double, int32_t)
-______ANDAND_____UU__(d, double, d, double, int32_t)
-______ANDAND_____UU__(d, double, i16, int16_t, int32_t)
-______ANDAND_____UU__(d, double, i32, int32_t, int32_t)
-______ANDAND_____UU__(d, double, i64, int64_t, int32_t)
-______ANDAND_____UU__(d, double, i8, int8_t, int32_t)
-______ANDAND_____UU__(d, double, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(d, double, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(d, double, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(d, double, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, b, int32_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, c, double, int32_t)
-______ANDAND_____UU__(i16, int16_t, d, double, int32_t)
-______ANDAND_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, b, int32_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, c, double, int32_t)
-______ANDAND_____UU__(i32, int32_t, d, double, int32_t)
-______ANDAND_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, b, int32_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, c, double, int32_t)
-______ANDAND_____UU__(i64, int64_t, d, double, int32_t)
-______ANDAND_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, b, int32_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, c, double, int32_t)
-______ANDAND_____UU__(i8, int8_t, d, double, int32_t)
-______ANDAND_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, c, double, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, d, double, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, c, double, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, d, double, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, c, double, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, d, double, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, c, double, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, d, double, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______ANDAND_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-__ASIN_M__(c, double, double)
-__ASIN_M__(d, double, double)
-______DOTTRANSP_____M__(b, int32_t, int32_t)
-______DOTTRANSP_____M__(c, double, double)
-______DOTTRANSP_____M__(d, double, double)
-______DOTTRANSP_____M__(i16, int16_t, int16_t)
-______DOTTRANSP_____M__(i32, int32_t, int32_t)
-______DOTTRANSP_____M__(i64, int64_t, int64_t)
-______DOTTRANSP_____M__(i8, int8_t, int8_t)
-______DOTTRANSP_____M__(ui16, uint16_t, uint16_t)
-______DOTTRANSP_____M__(ui32, uint32_t, uint32_t)
-______DOTTRANSP_____M__(ui64, uint64_t, uint64_t)
-______DOTTRANSP_____M__(ui8, uint8_t, uint8_t)
-__OR_MS__(b, int32_t, d, double, int32_t)
-__OR_MS__(c, double, d, double, int32_t)
-__OR_MS__(d, double, d, double, int32_t)
-__OR_MS__(i16, int16_t, d, double, int32_t)
-__OR_MS__(i32, int32_t, d, double, int32_t)
-__OR_MS__(i64, int64_t, d, double, int32_t)
-__OR_MS__(i8, int8_t, d, double, int32_t)
-__OR_MS__(ui16, uint16_t, d, double, int32_t)
-__OR_MS__(ui32, uint32_t, d, double, int32_t)
-__OR_MS__(ui64, uint64_t, d, double, int32_t)
-__OR_MS__(ui8, uint8_t, d, double, int32_t)
-__OR_M__(b, int32_t, int32_t)
-__OR_M__(c, double, int32_t)
-__OR_M__(d, double, int32_t)
-__OR_M__(i16, int16_t, int32_t)
-__OR_M__(i32, int32_t, int32_t)
-__OR_M__(i64, int64_t, int32_t)
-__OR_M__(i8, int8_t, int32_t)
-__OR_M__(ui16, uint16_t, int32_t)
-__OR_M__(ui32, uint32_t, int32_t)
-__OR_M__(ui64, uint64_t, int32_t)
-__OR_M__(ui8, uint8_t, int32_t)
-______EQ_____MM__(b, int32_t, b, int32_t, int32_t)
-______EQ_____MM__(b, int32_t, c, double, int32_t)
-______EQ_____MM__(b, int32_t, d, double, int32_t)
-______EQ_____MM__(b, int32_t, i16, int16_t, int32_t)
-______EQ_____MM__(b, int32_t, i32, int32_t, int32_t)
-______EQ_____MM__(b, int32_t, i64, int64_t, int32_t)
-______EQ_____MM__(b, int32_t, i8, int8_t, int32_t)
-______EQ_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(c, double, b, int32_t, int32_t)
-______EQ_____MM__(c, double, c, double, int32_t)
-______EQ_____MM__(c, double, d, double, int32_t)
-______EQ_____MM__(c, double, i16, int16_t, int32_t)
-______EQ_____MM__(c, double, i32, int32_t, int32_t)
-______EQ_____MM__(c, double, i64, int64_t, int32_t)
-______EQ_____MM__(c, double, i8, int8_t, int32_t)
-______EQ_____MM__(c, double, ui16, uint16_t, int32_t)
-______EQ_____MM__(c, double, ui32, uint32_t, int32_t)
-______EQ_____MM__(c, double, ui64, uint64_t, int32_t)
-______EQ_____MM__(c, double, ui8, uint8_t, int32_t)
-______EQ_____MM__(d, double, b, int32_t, int32_t)
-______EQ_____MM__(d, double, c, double, int32_t)
-______EQ_____MM__(d, double, d, double, int32_t)
-______EQ_____MM__(d, double, i16, int16_t, int32_t)
-______EQ_____MM__(d, double, i32, int32_t, int32_t)
-______EQ_____MM__(d, double, i64, int64_t, int32_t)
-______EQ_____MM__(d, double, i8, int8_t, int32_t)
-______EQ_____MM__(d, double, ui16, uint16_t, int32_t)
-______EQ_____MM__(d, double, ui32, uint32_t, int32_t)
-______EQ_____MM__(d, double, ui64, uint64_t, int32_t)
-______EQ_____MM__(d, double, ui8, uint8_t, int32_t)
-______EQ_____MM__(i16, int16_t, b, int32_t, int32_t)
-______EQ_____MM__(i16, int16_t, c, double, int32_t)
-______EQ_____MM__(i16, int16_t, d, double, int32_t)
-______EQ_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______EQ_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______EQ_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______EQ_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______EQ_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(i32, int32_t, b, int32_t, int32_t)
-______EQ_____MM__(i32, int32_t, c, double, int32_t)
-______EQ_____MM__(i32, int32_t, d, double, int32_t)
-______EQ_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______EQ_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______EQ_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______EQ_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______EQ_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(i64, int64_t, b, int32_t, int32_t)
-______EQ_____MM__(i64, int64_t, c, double, int32_t)
-______EQ_____MM__(i64, int64_t, d, double, int32_t)
-______EQ_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______EQ_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______EQ_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______EQ_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______EQ_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(i8, int8_t, b, int32_t, int32_t)
-______EQ_____MM__(i8, int8_t, c, double, int32_t)
-______EQ_____MM__(i8, int8_t, d, double, int32_t)
-______EQ_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______EQ_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______EQ_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______EQ_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______EQ_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, c, double, int32_t)
-______EQ_____MM__(ui16, uint16_t, d, double, int32_t)
-______EQ_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, c, double, int32_t)
-______EQ_____MM__(ui32, uint32_t, d, double, int32_t)
-______EQ_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, c, double, int32_t)
-______EQ_____MM__(ui64, uint64_t, d, double, int32_t)
-______EQ_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, c, double, int32_t)
-______EQ_____MM__(ui8, uint8_t, d, double, int32_t)
-______EQ_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______EQ_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(b, int32_t, b, int32_t, int32_t)
-______EQ_____MS__(b, int32_t, c, double, int32_t)
-______EQ_____MS__(b, int32_t, d, double, int32_t)
-______EQ_____MS__(b, int32_t, i16, int16_t, int32_t)
-______EQ_____MS__(b, int32_t, i32, int32_t, int32_t)
-______EQ_____MS__(b, int32_t, i64, int64_t, int32_t)
-______EQ_____MS__(b, int32_t, i8, int8_t, int32_t)
-______EQ_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(c, double, b, int32_t, int32_t)
-______EQ_____MS__(c, double, c, double, int32_t)
-______EQ_____MS__(c, double, d, double, int32_t)
-______EQ_____MS__(c, double, i16, int16_t, int32_t)
-______EQ_____MS__(c, double, i32, int32_t, int32_t)
-______EQ_____MS__(c, double, i64, int64_t, int32_t)
-______EQ_____MS__(c, double, i8, int8_t, int32_t)
-______EQ_____MS__(c, double, ui16, uint16_t, int32_t)
-______EQ_____MS__(c, double, ui32, uint32_t, int32_t)
-______EQ_____MS__(c, double, ui64, uint64_t, int32_t)
-______EQ_____MS__(c, double, ui8, uint8_t, int32_t)
-______EQ_____MS__(d, double, b, int32_t, int32_t)
-______EQ_____MS__(d, double, c, double, int32_t)
-______EQ_____MS__(d, double, d, double, int32_t)
-______EQ_____MS__(d, double, i16, int16_t, int32_t)
-______EQ_____MS__(d, double, i32, int32_t, int32_t)
-______EQ_____MS__(d, double, i64, int64_t, int32_t)
-______EQ_____MS__(d, double, i8, int8_t, int32_t)
-______EQ_____MS__(d, double, ui16, uint16_t, int32_t)
-______EQ_____MS__(d, double, ui32, uint32_t, int32_t)
-______EQ_____MS__(d, double, ui64, uint64_t, int32_t)
-______EQ_____MS__(d, double, ui8, uint8_t, int32_t)
-______EQ_____MS__(i16, int16_t, b, int32_t, int32_t)
-______EQ_____MS__(i16, int16_t, c, double, int32_t)
-______EQ_____MS__(i16, int16_t, d, double, int32_t)
-______EQ_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______EQ_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______EQ_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______EQ_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______EQ_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(i32, int32_t, b, int32_t, int32_t)
-______EQ_____MS__(i32, int32_t, c, double, int32_t)
-______EQ_____MS__(i32, int32_t, d, double, int32_t)
-______EQ_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______EQ_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______EQ_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______EQ_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______EQ_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(i64, int64_t, b, int32_t, int32_t)
-______EQ_____MS__(i64, int64_t, c, double, int32_t)
-______EQ_____MS__(i64, int64_t, d, double, int32_t)
-______EQ_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______EQ_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______EQ_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______EQ_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______EQ_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(i8, int8_t, b, int32_t, int32_t)
-______EQ_____MS__(i8, int8_t, c, double, int32_t)
-______EQ_____MS__(i8, int8_t, d, double, int32_t)
-______EQ_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______EQ_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______EQ_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______EQ_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______EQ_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, c, double, int32_t)
-______EQ_____MS__(ui16, uint16_t, d, double, int32_t)
-______EQ_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, c, double, int32_t)
-______EQ_____MS__(ui32, uint32_t, d, double, int32_t)
-______EQ_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, c, double, int32_t)
-______EQ_____MS__(ui64, uint64_t, d, double, int32_t)
-______EQ_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, c, double, int32_t)
-______EQ_____MS__(ui8, uint8_t, d, double, int32_t)
-______EQ_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______EQ_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(b, int32_t, b, int32_t, int32_t)
-______EQ_____SM__(b, int32_t, c, double, int32_t)
-______EQ_____SM__(b, int32_t, d, double, int32_t)
-______EQ_____SM__(b, int32_t, i16, int16_t, int32_t)
-______EQ_____SM__(b, int32_t, i32, int32_t, int32_t)
-______EQ_____SM__(b, int32_t, i64, int64_t, int32_t)
-______EQ_____SM__(b, int32_t, i8, int8_t, int32_t)
-______EQ_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(c, double, b, int32_t, int32_t)
-______EQ_____SM__(c, double, c, double, int32_t)
-______EQ_____SM__(c, double, d, double, int32_t)
-______EQ_____SM__(c, double, i16, int16_t, int32_t)
-______EQ_____SM__(c, double, i32, int32_t, int32_t)
-______EQ_____SM__(c, double, i64, int64_t, int32_t)
-______EQ_____SM__(c, double, i8, int8_t, int32_t)
-______EQ_____SM__(c, double, ui16, uint16_t, int32_t)
-______EQ_____SM__(c, double, ui32, uint32_t, int32_t)
-______EQ_____SM__(c, double, ui64, uint64_t, int32_t)
-______EQ_____SM__(c, double, ui8, uint8_t, int32_t)
-______EQ_____SM__(d, double, b, int32_t, int32_t)
-______EQ_____SM__(d, double, c, double, int32_t)
-______EQ_____SM__(d, double, d, double, int32_t)
-______EQ_____SM__(d, double, i16, int16_t, int32_t)
-______EQ_____SM__(d, double, i32, int32_t, int32_t)
-______EQ_____SM__(d, double, i64, int64_t, int32_t)
-______EQ_____SM__(d, double, i8, int8_t, int32_t)
-______EQ_____SM__(d, double, ui16, uint16_t, int32_t)
-______EQ_____SM__(d, double, ui32, uint32_t, int32_t)
-______EQ_____SM__(d, double, ui64, uint64_t, int32_t)
-______EQ_____SM__(d, double, ui8, uint8_t, int32_t)
-______EQ_____SM__(i16, int16_t, b, int32_t, int32_t)
-______EQ_____SM__(i16, int16_t, c, double, int32_t)
-______EQ_____SM__(i16, int16_t, d, double, int32_t)
-______EQ_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______EQ_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______EQ_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______EQ_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______EQ_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(i32, int32_t, b, int32_t, int32_t)
-______EQ_____SM__(i32, int32_t, c, double, int32_t)
-______EQ_____SM__(i32, int32_t, d, double, int32_t)
-______EQ_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______EQ_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______EQ_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______EQ_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______EQ_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(i64, int64_t, b, int32_t, int32_t)
-______EQ_____SM__(i64, int64_t, c, double, int32_t)
-______EQ_____SM__(i64, int64_t, d, double, int32_t)
-______EQ_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______EQ_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______EQ_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______EQ_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______EQ_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(i8, int8_t, b, int32_t, int32_t)
-______EQ_____SM__(i8, int8_t, c, double, int32_t)
-______EQ_____SM__(i8, int8_t, d, double, int32_t)
-______EQ_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______EQ_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______EQ_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______EQ_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______EQ_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, c, double, int32_t)
-______EQ_____SM__(ui16, uint16_t, d, double, int32_t)
-______EQ_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, c, double, int32_t)
-______EQ_____SM__(ui32, uint32_t, d, double, int32_t)
-______EQ_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, c, double, int32_t)
-______EQ_____SM__(ui64, uint64_t, d, double, int32_t)
-______EQ_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, c, double, int32_t)
-______EQ_____SM__(ui8, uint8_t, d, double, int32_t)
-______EQ_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______EQ_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(b, int32_t, b, int32_t, int32_t)
-______EQ_____UU__(b, int32_t, c, double, int32_t)
-______EQ_____UU__(b, int32_t, d, double, int32_t)
-______EQ_____UU__(b, int32_t, i16, int16_t, int32_t)
-______EQ_____UU__(b, int32_t, i32, int32_t, int32_t)
-______EQ_____UU__(b, int32_t, i64, int64_t, int32_t)
-______EQ_____UU__(b, int32_t, i8, int8_t, int32_t)
-______EQ_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(c, double, b, int32_t, int32_t)
-______EQ_____UU__(c, double, c, double, int32_t)
-______EQ_____UU__(c, double, d, double, int32_t)
-______EQ_____UU__(c, double, i16, int16_t, int32_t)
-______EQ_____UU__(c, double, i32, int32_t, int32_t)
-______EQ_____UU__(c, double, i64, int64_t, int32_t)
-______EQ_____UU__(c, double, i8, int8_t, int32_t)
-______EQ_____UU__(c, double, ui16, uint16_t, int32_t)
-______EQ_____UU__(c, double, ui32, uint32_t, int32_t)
-______EQ_____UU__(c, double, ui64, uint64_t, int32_t)
-______EQ_____UU__(c, double, ui8, uint8_t, int32_t)
-______EQ_____UU__(d, double, b, int32_t, int32_t)
-______EQ_____UU__(d, double, c, double, int32_t)
-______EQ_____UU__(d, double, d, double, int32_t)
-______EQ_____UU__(d, double, i16, int16_t, int32_t)
-______EQ_____UU__(d, double, i32, int32_t, int32_t)
-______EQ_____UU__(d, double, i64, int64_t, int32_t)
-______EQ_____UU__(d, double, i8, int8_t, int32_t)
-______EQ_____UU__(d, double, ui16, uint16_t, int32_t)
-______EQ_____UU__(d, double, ui32, uint32_t, int32_t)
-______EQ_____UU__(d, double, ui64, uint64_t, int32_t)
-______EQ_____UU__(d, double, ui8, uint8_t, int32_t)
-______EQ_____UU__(i16, int16_t, b, int32_t, int32_t)
-______EQ_____UU__(i16, int16_t, c, double, int32_t)
-______EQ_____UU__(i16, int16_t, d, double, int32_t)
-______EQ_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______EQ_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______EQ_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______EQ_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______EQ_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(i32, int32_t, b, int32_t, int32_t)
-______EQ_____UU__(i32, int32_t, c, double, int32_t)
-______EQ_____UU__(i32, int32_t, d, double, int32_t)
-______EQ_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______EQ_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______EQ_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______EQ_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______EQ_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(i64, int64_t, b, int32_t, int32_t)
-______EQ_____UU__(i64, int64_t, c, double, int32_t)
-______EQ_____UU__(i64, int64_t, d, double, int32_t)
-______EQ_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______EQ_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______EQ_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______EQ_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______EQ_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(i8, int8_t, b, int32_t, int32_t)
-______EQ_____UU__(i8, int8_t, c, double, int32_t)
-______EQ_____UU__(i8, int8_t, d, double, int32_t)
-______EQ_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______EQ_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______EQ_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______EQ_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______EQ_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, c, double, int32_t)
-______EQ_____UU__(ui16, uint16_t, d, double, int32_t)
-______EQ_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, c, double, int32_t)
-______EQ_____UU__(ui32, uint32_t, d, double, int32_t)
-______EQ_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, c, double, int32_t)
-______EQ_____UU__(ui64, uint64_t, d, double, int32_t)
-______EQ_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, c, double, int32_t)
-______EQ_____UU__(ui8, uint8_t, d, double, int32_t)
-______EQ_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______EQ_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-__LOG_M__(c, double, double)
-__LOG_M__(d, double, double)
-__FLOOR_M__(c, double, double)
-__FLOOR_M__(d, double, double)
-__FLOOR_M__(i16, int16_t, int16_t)
-__FLOOR_M__(i32, int32_t, int32_t)
-__FLOOR_M__(i64, int64_t, int64_t)
-__FLOOR_M__(i8, int8_t, int8_t)
-__FLOOR_M__(ui16, uint16_t, uint16_t)
-__FLOOR_M__(ui32, uint32_t, uint32_t)
-__FLOOR_M__(ui64, uint64_t, uint64_t)
-__FLOOR_M__(ui8, uint8_t, uint8_t)
-__INT_M__(c, double, double)
-__INT_M__(d, double, double)
-__INT_M__(i16, int16_t, int16_t)
-__INT_M__(i32, int32_t, int32_t)
-__INT_M__(i64, int64_t, int64_t)
-__INT_M__(i8, int8_t, int8_t)
-__INT_M__(ui16, uint16_t, uint16_t)
-__INT_M__(ui32, uint32_t, uint32_t)
-__INT_M__(ui64, uint64_t, uint64_t)
-__INT_M__(ui8, uint8_t, uint8_t)
-__FIX_M__(c, double, double)
-__FIX_M__(d, double, double)
-__FIX_M__(i16, int16_t, int16_t)
-__FIX_M__(i32, int32_t, int32_t)
-__FIX_M__(i64, int64_t, int64_t)
-__FIX_M__(i8, int8_t, int8_t)
-__FIX_M__(ui16, uint16_t, uint16_t)
-__FIX_M__(ui32, uint32_t, uint32_t)
-__FIX_M__(ui64, uint64_t, uint64_t)
-__FIX_M__(ui8, uint8_t, uint8_t)
-__SQRT_M__(c, double, double)
-__SQRT_M__(d, double, double)
-__UINT16_M__(d, double, uint16_t)
-__UINT16_M__(i16, int16_t, uint16_t)
-__UINT16_M__(i32, int32_t, uint16_t)
-__UINT16_M__(i64, int64_t, uint16_t)
-__UINT16_M__(i8, int8_t, uint16_t)
-__UINT16_M__(ui16, uint16_t, uint16_t)
-__UINT16_M__(ui32, uint32_t, uint16_t)
-__UINT16_M__(ui64, uint64_t, uint16_t)
-__UINT16_M__(ui8, uint8_t, uint16_t)
-______LE_____MM__(b, int32_t, b, int32_t, int32_t)
-______LE_____MM__(b, int32_t, c, double, int32_t)
-______LE_____MM__(b, int32_t, d, double, int32_t)
-______LE_____MM__(b, int32_t, i16, int16_t, int32_t)
-______LE_____MM__(b, int32_t, i32, int32_t, int32_t)
-______LE_____MM__(b, int32_t, i64, int64_t, int32_t)
-______LE_____MM__(b, int32_t, i8, int8_t, int32_t)
-______LE_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______LE_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______LE_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______LE_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______LE_____MM__(c, double, b, int32_t, int32_t)
-______LE_____MM__(c, double, c, double, int32_t)
-______LE_____MM__(c, double, d, double, int32_t)
-______LE_____MM__(c, double, i16, int16_t, int32_t)
-______LE_____MM__(c, double, i32, int32_t, int32_t)
-______LE_____MM__(c, double, i64, int64_t, int32_t)
-______LE_____MM__(c, double, i8, int8_t, int32_t)
-______LE_____MM__(c, double, ui16, uint16_t, int32_t)
-______LE_____MM__(c, double, ui32, uint32_t, int32_t)
-______LE_____MM__(c, double, ui64, uint64_t, int32_t)
-______LE_____MM__(c, double, ui8, uint8_t, int32_t)
-______LE_____MM__(d, double, b, int32_t, int32_t)
-______LE_____MM__(d, double, c, double, int32_t)
-______LE_____MM__(d, double, d, double, int32_t)
-______LE_____MM__(d, double, i16, int16_t, int32_t)
-______LE_____MM__(d, double, i32, int32_t, int32_t)
-______LE_____MM__(d, double, i64, int64_t, int32_t)
-______LE_____MM__(d, double, i8, int8_t, int32_t)
-______LE_____MM__(d, double, ui16, uint16_t, int32_t)
-______LE_____MM__(d, double, ui32, uint32_t, int32_t)
-______LE_____MM__(d, double, ui64, uint64_t, int32_t)
-______LE_____MM__(d, double, ui8, uint8_t, int32_t)
-______LE_____MM__(i16, int16_t, b, int32_t, int32_t)
-______LE_____MM__(i16, int16_t, c, double, int32_t)
-______LE_____MM__(i16, int16_t, d, double, int32_t)
-______LE_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______LE_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______LE_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______LE_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______LE_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______LE_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______LE_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______LE_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______LE_____MM__(i32, int32_t, b, int32_t, int32_t)
-______LE_____MM__(i32, int32_t, c, double, int32_t)
-______LE_____MM__(i32, int32_t, d, double, int32_t)
-______LE_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______LE_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______LE_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______LE_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______LE_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______LE_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______LE_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______LE_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______LE_____MM__(i64, int64_t, b, int32_t, int32_t)
-______LE_____MM__(i64, int64_t, c, double, int32_t)
-______LE_____MM__(i64, int64_t, d, double, int32_t)
-______LE_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______LE_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______LE_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______LE_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______LE_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______LE_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______LE_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______LE_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______LE_____MM__(i8, int8_t, b, int32_t, int32_t)
-______LE_____MM__(i8, int8_t, c, double, int32_t)
-______LE_____MM__(i8, int8_t, d, double, int32_t)
-______LE_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______LE_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______LE_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______LE_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______LE_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______LE_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______LE_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______LE_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______LE_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______LE_____MM__(ui16, uint16_t, c, double, int32_t)
-______LE_____MM__(ui16, uint16_t, d, double, int32_t)
-______LE_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______LE_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______LE_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______LE_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______LE_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LE_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LE_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LE_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LE_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______LE_____MM__(ui32, uint32_t, c, double, int32_t)
-______LE_____MM__(ui32, uint32_t, d, double, int32_t)
-______LE_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______LE_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______LE_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______LE_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______LE_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LE_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LE_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LE_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LE_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______LE_____MM__(ui64, uint64_t, c, double, int32_t)
-______LE_____MM__(ui64, uint64_t, d, double, int32_t)
-______LE_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______LE_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______LE_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______LE_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______LE_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LE_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LE_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LE_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LE_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______LE_____MM__(ui8, uint8_t, c, double, int32_t)
-______LE_____MM__(ui8, uint8_t, d, double, int32_t)
-______LE_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______LE_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______LE_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______LE_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______LE_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LE_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LE_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LE_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LE_____MS__(b, int32_t, b, int32_t, int32_t)
-______LE_____MS__(b, int32_t, c, double, int32_t)
-______LE_____MS__(b, int32_t, d, double, int32_t)
-______LE_____MS__(b, int32_t, i16, int16_t, int32_t)
-______LE_____MS__(b, int32_t, i32, int32_t, int32_t)
-______LE_____MS__(b, int32_t, i64, int64_t, int32_t)
-______LE_____MS__(b, int32_t, i8, int8_t, int32_t)
-______LE_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______LE_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______LE_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______LE_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______LE_____MS__(c, double, b, int32_t, int32_t)
-______LE_____MS__(c, double, c, double, int32_t)
-______LE_____MS__(c, double, d, double, int32_t)
-______LE_____MS__(c, double, i16, int16_t, int32_t)
-______LE_____MS__(c, double, i32, int32_t, int32_t)
-______LE_____MS__(c, double, i64, int64_t, int32_t)
-______LE_____MS__(c, double, i8, int8_t, int32_t)
-______LE_____MS__(c, double, ui16, uint16_t, int32_t)
-______LE_____MS__(c, double, ui32, uint32_t, int32_t)
-______LE_____MS__(c, double, ui64, uint64_t, int32_t)
-______LE_____MS__(c, double, ui8, uint8_t, int32_t)
-______LE_____MS__(d, double, b, int32_t, int32_t)
-______LE_____MS__(d, double, c, double, int32_t)
-______LE_____MS__(d, double, d, double, int32_t)
-______LE_____MS__(d, double, i16, int16_t, int32_t)
-______LE_____MS__(d, double, i32, int32_t, int32_t)
-______LE_____MS__(d, double, i64, int64_t, int32_t)
-______LE_____MS__(d, double, i8, int8_t, int32_t)
-______LE_____MS__(d, double, ui16, uint16_t, int32_t)
-______LE_____MS__(d, double, ui32, uint32_t, int32_t)
-______LE_____MS__(d, double, ui64, uint64_t, int32_t)
-______LE_____MS__(d, double, ui8, uint8_t, int32_t)
-______LE_____MS__(i16, int16_t, b, int32_t, int32_t)
-______LE_____MS__(i16, int16_t, c, double, int32_t)
-______LE_____MS__(i16, int16_t, d, double, int32_t)
-______LE_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______LE_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______LE_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______LE_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______LE_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______LE_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______LE_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______LE_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______LE_____MS__(i32, int32_t, b, int32_t, int32_t)
-______LE_____MS__(i32, int32_t, c, double, int32_t)
-______LE_____MS__(i32, int32_t, d, double, int32_t)
-______LE_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______LE_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______LE_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______LE_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______LE_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______LE_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______LE_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______LE_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______LE_____MS__(i64, int64_t, b, int32_t, int32_t)
-______LE_____MS__(i64, int64_t, c, double, int32_t)
-______LE_____MS__(i64, int64_t, d, double, int32_t)
-______LE_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______LE_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______LE_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______LE_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______LE_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______LE_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______LE_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______LE_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______LE_____MS__(i8, int8_t, b, int32_t, int32_t)
-______LE_____MS__(i8, int8_t, c, double, int32_t)
-______LE_____MS__(i8, int8_t, d, double, int32_t)
-______LE_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______LE_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______LE_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______LE_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______LE_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______LE_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______LE_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______LE_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______LE_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______LE_____MS__(ui16, uint16_t, c, double, int32_t)
-______LE_____MS__(ui16, uint16_t, d, double, int32_t)
-______LE_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______LE_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______LE_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______LE_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______LE_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LE_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LE_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LE_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LE_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______LE_____MS__(ui32, uint32_t, c, double, int32_t)
-______LE_____MS__(ui32, uint32_t, d, double, int32_t)
-______LE_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______LE_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______LE_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______LE_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______LE_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LE_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LE_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LE_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LE_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______LE_____MS__(ui64, uint64_t, c, double, int32_t)
-______LE_____MS__(ui64, uint64_t, d, double, int32_t)
-______LE_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______LE_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______LE_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______LE_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______LE_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LE_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LE_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LE_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LE_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______LE_____MS__(ui8, uint8_t, c, double, int32_t)
-______LE_____MS__(ui8, uint8_t, d, double, int32_t)
-______LE_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______LE_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______LE_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______LE_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______LE_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LE_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LE_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LE_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LE_____SM__(b, int32_t, b, int32_t, int32_t)
-______LE_____SM__(b, int32_t, c, double, int32_t)
-______LE_____SM__(b, int32_t, d, double, int32_t)
-______LE_____SM__(b, int32_t, i16, int16_t, int32_t)
-______LE_____SM__(b, int32_t, i32, int32_t, int32_t)
-______LE_____SM__(b, int32_t, i64, int64_t, int32_t)
-______LE_____SM__(b, int32_t, i8, int8_t, int32_t)
-______LE_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______LE_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______LE_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______LE_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______LE_____SM__(c, double, b, int32_t, int32_t)
-______LE_____SM__(c, double, c, double, int32_t)
-______LE_____SM__(c, double, d, double, int32_t)
-______LE_____SM__(c, double, i16, int16_t, int32_t)
-______LE_____SM__(c, double, i32, int32_t, int32_t)
-______LE_____SM__(c, double, i64, int64_t, int32_t)
-______LE_____SM__(c, double, i8, int8_t, int32_t)
-______LE_____SM__(c, double, ui16, uint16_t, int32_t)
-______LE_____SM__(c, double, ui32, uint32_t, int32_t)
-______LE_____SM__(c, double, ui64, uint64_t, int32_t)
-______LE_____SM__(c, double, ui8, uint8_t, int32_t)
-______LE_____SM__(d, double, b, int32_t, int32_t)
-______LE_____SM__(d, double, c, double, int32_t)
-______LE_____SM__(d, double, d, double, int32_t)
-______LE_____SM__(d, double, i16, int16_t, int32_t)
-______LE_____SM__(d, double, i32, int32_t, int32_t)
-______LE_____SM__(d, double, i64, int64_t, int32_t)
-______LE_____SM__(d, double, i8, int8_t, int32_t)
-______LE_____SM__(d, double, ui16, uint16_t, int32_t)
-______LE_____SM__(d, double, ui32, uint32_t, int32_t)
-______LE_____SM__(d, double, ui64, uint64_t, int32_t)
-______LE_____SM__(d, double, ui8, uint8_t, int32_t)
-______LE_____SM__(i16, int16_t, b, int32_t, int32_t)
-______LE_____SM__(i16, int16_t, c, double, int32_t)
-______LE_____SM__(i16, int16_t, d, double, int32_t)
-______LE_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______LE_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______LE_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______LE_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______LE_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______LE_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______LE_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______LE_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______LE_____SM__(i32, int32_t, b, int32_t, int32_t)
-______LE_____SM__(i32, int32_t, c, double, int32_t)
-______LE_____SM__(i32, int32_t, d, double, int32_t)
-______LE_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______LE_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______LE_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______LE_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______LE_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______LE_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______LE_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______LE_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______LE_____SM__(i64, int64_t, b, int32_t, int32_t)
-______LE_____SM__(i64, int64_t, c, double, int32_t)
-______LE_____SM__(i64, int64_t, d, double, int32_t)
-______LE_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______LE_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______LE_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______LE_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______LE_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______LE_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______LE_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______LE_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______LE_____SM__(i8, int8_t, b, int32_t, int32_t)
-______LE_____SM__(i8, int8_t, c, double, int32_t)
-______LE_____SM__(i8, int8_t, d, double, int32_t)
-______LE_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______LE_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______LE_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______LE_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______LE_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______LE_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______LE_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______LE_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______LE_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______LE_____SM__(ui16, uint16_t, c, double, int32_t)
-______LE_____SM__(ui16, uint16_t, d, double, int32_t)
-______LE_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______LE_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______LE_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______LE_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______LE_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LE_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LE_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LE_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LE_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______LE_____SM__(ui32, uint32_t, c, double, int32_t)
-______LE_____SM__(ui32, uint32_t, d, double, int32_t)
-______LE_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______LE_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______LE_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______LE_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______LE_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LE_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LE_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LE_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LE_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______LE_____SM__(ui64, uint64_t, c, double, int32_t)
-______LE_____SM__(ui64, uint64_t, d, double, int32_t)
-______LE_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______LE_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______LE_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______LE_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______LE_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LE_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LE_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LE_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LE_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______LE_____SM__(ui8, uint8_t, c, double, int32_t)
-______LE_____SM__(ui8, uint8_t, d, double, int32_t)
-______LE_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______LE_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______LE_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______LE_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______LE_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LE_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LE_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LE_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LE_____UU__(b, int32_t, b, int32_t, int32_t)
-______LE_____UU__(b, int32_t, c, double, int32_t)
-______LE_____UU__(b, int32_t, d, double, int32_t)
-______LE_____UU__(b, int32_t, i16, int16_t, int32_t)
-______LE_____UU__(b, int32_t, i32, int32_t, int32_t)
-______LE_____UU__(b, int32_t, i64, int64_t, int32_t)
-______LE_____UU__(b, int32_t, i8, int8_t, int32_t)
-______LE_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______LE_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______LE_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______LE_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______LE_____UU__(c, double, b, int32_t, int32_t)
-______LE_____UU__(c, double, c, double, int32_t)
-______LE_____UU__(c, double, d, double, int32_t)
-______LE_____UU__(c, double, i16, int16_t, int32_t)
-______LE_____UU__(c, double, i32, int32_t, int32_t)
-______LE_____UU__(c, double, i64, int64_t, int32_t)
-______LE_____UU__(c, double, i8, int8_t, int32_t)
-______LE_____UU__(c, double, ui16, uint16_t, int32_t)
-______LE_____UU__(c, double, ui32, uint32_t, int32_t)
-______LE_____UU__(c, double, ui64, uint64_t, int32_t)
-______LE_____UU__(c, double, ui8, uint8_t, int32_t)
-______LE_____UU__(d, double, b, int32_t, int32_t)
-______LE_____UU__(d, double, c, double, int32_t)
-______LE_____UU__(d, double, d, double, int32_t)
-______LE_____UU__(d, double, i16, int16_t, int32_t)
-______LE_____UU__(d, double, i32, int32_t, int32_t)
-______LE_____UU__(d, double, i64, int64_t, int32_t)
-______LE_____UU__(d, double, i8, int8_t, int32_t)
-______LE_____UU__(d, double, ui16, uint16_t, int32_t)
-______LE_____UU__(d, double, ui32, uint32_t, int32_t)
-______LE_____UU__(d, double, ui64, uint64_t, int32_t)
-______LE_____UU__(d, double, ui8, uint8_t, int32_t)
-______LE_____UU__(i16, int16_t, b, int32_t, int32_t)
-______LE_____UU__(i16, int16_t, c, double, int32_t)
-______LE_____UU__(i16, int16_t, d, double, int32_t)
-______LE_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______LE_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______LE_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______LE_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______LE_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______LE_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______LE_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______LE_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______LE_____UU__(i32, int32_t, b, int32_t, int32_t)
-______LE_____UU__(i32, int32_t, c, double, int32_t)
-______LE_____UU__(i32, int32_t, d, double, int32_t)
-______LE_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______LE_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______LE_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______LE_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______LE_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______LE_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______LE_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______LE_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______LE_____UU__(i64, int64_t, b, int32_t, int32_t)
-______LE_____UU__(i64, int64_t, c, double, int32_t)
-______LE_____UU__(i64, int64_t, d, double, int32_t)
-______LE_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______LE_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______LE_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______LE_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______LE_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______LE_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______LE_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______LE_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______LE_____UU__(i8, int8_t, b, int32_t, int32_t)
-______LE_____UU__(i8, int8_t, c, double, int32_t)
-______LE_____UU__(i8, int8_t, d, double, int32_t)
-______LE_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______LE_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______LE_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______LE_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______LE_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______LE_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______LE_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______LE_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______LE_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______LE_____UU__(ui16, uint16_t, c, double, int32_t)
-______LE_____UU__(ui16, uint16_t, d, double, int32_t)
-______LE_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______LE_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______LE_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______LE_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______LE_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LE_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LE_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LE_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LE_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______LE_____UU__(ui32, uint32_t, c, double, int32_t)
-______LE_____UU__(ui32, uint32_t, d, double, int32_t)
-______LE_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______LE_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______LE_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______LE_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______LE_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LE_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LE_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LE_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LE_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______LE_____UU__(ui64, uint64_t, c, double, int32_t)
-______LE_____UU__(ui64, uint64_t, d, double, int32_t)
-______LE_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______LE_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______LE_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______LE_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______LE_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LE_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LE_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LE_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LE_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______LE_____UU__(ui8, uint8_t, c, double, int32_t)
-______LE_____UU__(ui8, uint8_t, d, double, int32_t)
-______LE_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______LE_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______LE_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______LE_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______LE_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LE_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LE_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LE_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-__ZEROS_M__(b, int32_t, double)
-__ZEROS_M__(c, double, double)
-__ZEROS_M__(d, double, double)
-__ZEROS_M__(i16, int16_t, double)
-__ZEROS_M__(i32, int32_t, double)
-__ZEROS_M__(i64, int64_t, double)
-__ZEROS_M__(i8, int8_t, double)
-__ZEROS_M__(ui16, uint16_t, double)
-__ZEROS_M__(ui32, uint32_t, double)
-__ZEROS_M__(ui64, uint64_t, double)
-__ZEROS_M__(ui8, uint8_t, double)
-__ZEROS_SS__(d, double, d, double, double)
-
-__MAX_M__(b, int32_t, int32_t)
-__MAX_M__(d, double, double)
-__MAX_M__(i16, int16_t, int16_t)
-__MAX_M__(i32, int32_t, int32_t)
-__MAX_M__(i64, int64_t, int64_t)
-__MAX_M__(i8, int8_t, int8_t)
-__MAX_M__(ui16, uint16_t, uint16_t)
-__MAX_M__(ui32, uint32_t, uint32_t)
-__MAX_M__(ui64, uint64_t, uint64_t)
-__MAX_M__(ui8, uint8_t, uint8_t)
-__UINT32_M__(d, double, uint32_t)
-__UINT32_M__(i16, int16_t, uint32_t)
-__UINT32_M__(i32, int32_t, uint32_t)
-__UINT32_M__(i64, int64_t, uint32_t)
-__UINT32_M__(i8, int8_t, uint32_t)
-__UINT32_M__(ui16, uint16_t, uint32_t)
-__UINT32_M__(ui32, uint32_t, uint32_t)
-__UINT32_M__(ui64, uint64_t, uint32_t)
-__UINT32_M__(ui8, uint8_t, uint32_t)
-__INT64_M__(d, double, int64_t)
-__INT64_M__(i16, int16_t, int64_t)
-__INT64_M__(i32, int32_t, int64_t)
-__INT64_M__(i64, int64_t, int64_t)
-__INT64_M__(i8, int8_t, int64_t)
-__INT64_M__(ui16, uint16_t, int64_t)
-__INT64_M__(ui32, uint32_t, int64_t)
-__INT64_M__(ui64, uint64_t, int64_t)
-__INT64_M__(ui8, uint8_t, int64_t)
-__PROD_M__(c, double, double)
-__PROD_M__(d, double, double)
-__PROD_M__(i16, int16_t, int16_t)
-__PROD_M__(i32, int32_t, int32_t)
-__PROD_M__(i64, int64_t, int64_t)
-__PROD_M__(i8, int8_t, int8_t)
-__PROD_M__(ui16, uint16_t, uint16_t)
-__PROD_M__(ui32, uint32_t, uint32_t)
-__PROD_M__(ui64, uint64_t, uint64_t)
-__PROD_M__(ui8, uint8_t, uint8_t)
-__TYPE_M__(b, int32_t, double)
-__TYPE_M__(c, double, double)
-__TYPE_M__(d, double, double)
-__TYPE_M__(i16, int16_t, double)
-__TYPE_M__(i32, int32_t, double)
-__TYPE_M__(i64, int64_t, double)
-__TYPE_M__(i8, int8_t, double)
-__TYPE_M__(ui16, uint16_t, double)
-__TYPE_M__(ui32, uint32_t, double)
-__TYPE_M__(ui64, uint64_t, double)
-__TYPE_M__(ui8, uint8_t, double)
-__SIN_M__(c, double, double)
-__SIN_M__(d, double, double)
-__ROUND_M__(c, double, double)
-__ROUND_M__(d, double, double)
-__ROUND_M__(i16, int16_t, int16_t)
-__ROUND_M__(i32, int32_t, int32_t)
-__ROUND_M__(i64, int64_t, int64_t)
-__ROUND_M__(i8, int8_t, int8_t)
-__ROUND_M__(ui16, uint16_t, uint16_t)
-__ROUND_M__(ui32, uint32_t, uint32_t)
-__ROUND_M__(ui64, uint64_t, uint64_t)
-__ROUND_M__(ui8, uint8_t, uint8_t)
-______KRONTIMES_____MM__(c, double, c, double, double)
-______KRONTIMES_____MM__(c, double, d, double, double)
-______KRONTIMES_____MM__(d, double, c, double, double)
-______KRONTIMES_____MM__(d, double, d, double, double)
-______KRONTIMES_____MM__(d, double, i16, int16_t, double)
-______KRONTIMES_____MM__(d, double, i32, int32_t, double)
-______KRONTIMES_____MM__(d, double, i64, int64_t, double)
-______KRONTIMES_____MM__(d, double, i8, int8_t, double)
-______KRONTIMES_____MM__(d, double, ui16, uint16_t, double)
-______KRONTIMES_____MM__(d, double, ui32, uint32_t, double)
-______KRONTIMES_____MM__(d, double, ui64, uint64_t, double)
-______KRONTIMES_____MM__(d, double, ui8, uint8_t, double)
-______KRONTIMES_____MM__(i16, int16_t, d, double, double)
-______KRONTIMES_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______KRONTIMES_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______KRONTIMES_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______KRONTIMES_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______KRONTIMES_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____MM__(i32, int32_t, d, double, double)
-______KRONTIMES_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______KRONTIMES_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______KRONTIMES_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______KRONTIMES_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______KRONTIMES_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____MM__(i64, int64_t, d, double, double)
-______KRONTIMES_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______KRONTIMES_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______KRONTIMES_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______KRONTIMES_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______KRONTIMES_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____MM__(i8, int8_t, d, double, double)
-______KRONTIMES_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______KRONTIMES_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______KRONTIMES_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______KRONTIMES_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______KRONTIMES_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______KRONTIMES_____MM__(ui16, uint16_t, d, double, double)
-______KRONTIMES_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______KRONTIMES_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______KRONTIMES_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____MM__(ui32, uint32_t, d, double, double)
-______KRONTIMES_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______KRONTIMES_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______KRONTIMES_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____MM__(ui64, uint64_t, d, double, double)
-______KRONTIMES_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____MM__(ui8, uint8_t, d, double, double)
-______KRONTIMES_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______KRONTIMES_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______KRONTIMES_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______KRONTIMES_____MS__(c, double, c, double, double)
-______KRONTIMES_____MS__(c, double, d, double, double)
-______KRONTIMES_____MS__(d, double, c, double, double)
-______KRONTIMES_____MS__(d, double, d, double, double)
-______KRONTIMES_____MS__(d, double, i16, int16_t, double)
-______KRONTIMES_____MS__(d, double, i32, int32_t, double)
-______KRONTIMES_____MS__(d, double, i64, int64_t, double)
-______KRONTIMES_____MS__(d, double, i8, int8_t, double)
-______KRONTIMES_____MS__(d, double, ui16, uint16_t, double)
-______KRONTIMES_____MS__(d, double, ui32, uint32_t, double)
-______KRONTIMES_____MS__(d, double, ui64, uint64_t, double)
-______KRONTIMES_____MS__(d, double, ui8, uint8_t, double)
-______KRONTIMES_____MS__(i16, int16_t, d, double, double)
-______KRONTIMES_____MS__(i16, int16_t, i16, int16_t, int16_t)
-______KRONTIMES_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______KRONTIMES_____MS__(i16, int16_t, i64, int64_t, int64_t)
-______KRONTIMES_____MS__(i16, int16_t, i8, int8_t, int16_t)
-______KRONTIMES_____MS__(i16, int16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MS__(i16, int16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(i16, int16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(i16, int16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____MS__(i32, int32_t, d, double, double)
-______KRONTIMES_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______KRONTIMES_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______KRONTIMES_____MS__(i32, int32_t, i64, int64_t, int64_t)
-______KRONTIMES_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______KRONTIMES_____MS__(i32, int32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____MS__(i32, int32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(i32, int32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(i32, int32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____MS__(i64, int64_t, d, double, double)
-______KRONTIMES_____MS__(i64, int64_t, i16, int16_t, int64_t)
-______KRONTIMES_____MS__(i64, int64_t, i32, int32_t, int64_t)
-______KRONTIMES_____MS__(i64, int64_t, i64, int64_t, int64_t)
-______KRONTIMES_____MS__(i64, int64_t, i8, int8_t, int64_t)
-______KRONTIMES_____MS__(i64, int64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____MS__(i64, int64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____MS__(i64, int64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(i64, int64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____MS__(i8, int8_t, d, double, double)
-______KRONTIMES_____MS__(i8, int8_t, i16, int16_t, int16_t)
-______KRONTIMES_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______KRONTIMES_____MS__(i8, int8_t, i64, int64_t, int64_t)
-______KRONTIMES_____MS__(i8, int8_t, i8, int8_t, int8_t)
-______KRONTIMES_____MS__(i8, int8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MS__(i8, int8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(i8, int8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(i8, int8_t, ui8, uint8_t, uint8_t)
-______KRONTIMES_____MS__(ui16, uint16_t, d, double, double)
-______KRONTIMES_____MS__(ui16, uint16_t, i16, int16_t, uint16_t)
-______KRONTIMES_____MS__(ui16, uint16_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MS__(ui16, uint16_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MS__(ui16, uint16_t, i8, int8_t, uint16_t)
-______KRONTIMES_____MS__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MS__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____MS__(ui32, uint32_t, d, double, double)
-______KRONTIMES_____MS__(ui32, uint32_t, i16, int16_t, uint32_t)
-______KRONTIMES_____MS__(ui32, uint32_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MS__(ui32, uint32_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MS__(ui32, uint32_t, i8, int8_t, uint32_t)
-______KRONTIMES_____MS__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____MS__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____MS__(ui64, uint64_t, d, double, double)
-______KRONTIMES_____MS__(ui64, uint64_t, i16, int16_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, i32, int32_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, i8, int8_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____MS__(ui8, uint8_t, d, double, double)
-______KRONTIMES_____MS__(ui8, uint8_t, i16, int16_t, uint16_t)
-______KRONTIMES_____MS__(ui8, uint8_t, i32, int32_t, uint32_t)
-______KRONTIMES_____MS__(ui8, uint8_t, i64, int64_t, uint64_t)
-______KRONTIMES_____MS__(ui8, uint8_t, i8, int8_t, uint8_t)
-______KRONTIMES_____MS__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____MS__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____MS__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____MS__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______KRONTIMES_____UU__(c, double, c, double, double)
-______KRONTIMES_____UU__(c, double, d, double, double)
-______KRONTIMES_____UU__(d, double, c, double, double)
-______KRONTIMES_____UU__(d, double, d, double, double)
-______KRONTIMES_____UU__(d, double, i16, int16_t, double)
-______KRONTIMES_____UU__(d, double, i32, int32_t, double)
-______KRONTIMES_____UU__(d, double, i64, int64_t, double)
-______KRONTIMES_____UU__(d, double, i8, int8_t, double)
-______KRONTIMES_____UU__(d, double, ui16, uint16_t, double)
-______KRONTIMES_____UU__(d, double, ui32, uint32_t, double)
-______KRONTIMES_____UU__(d, double, ui64, uint64_t, double)
-______KRONTIMES_____UU__(d, double, ui8, uint8_t, double)
-______KRONTIMES_____UU__(i16, int16_t, d, double, double)
-______KRONTIMES_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______KRONTIMES_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______KRONTIMES_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______KRONTIMES_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______KRONTIMES_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____UU__(i32, int32_t, d, double, double)
-______KRONTIMES_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______KRONTIMES_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______KRONTIMES_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______KRONTIMES_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______KRONTIMES_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____UU__(i64, int64_t, d, double, double)
-______KRONTIMES_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______KRONTIMES_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______KRONTIMES_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______KRONTIMES_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______KRONTIMES_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____UU__(i8, int8_t, d, double, double)
-______KRONTIMES_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______KRONTIMES_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______KRONTIMES_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______KRONTIMES_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______KRONTIMES_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______KRONTIMES_____UU__(ui16, uint16_t, d, double, double)
-______KRONTIMES_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______KRONTIMES_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______KRONTIMES_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______KRONTIMES_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______KRONTIMES_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______KRONTIMES_____UU__(ui32, uint32_t, d, double, double)
-______KRONTIMES_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______KRONTIMES_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______KRONTIMES_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______KRONTIMES_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______KRONTIMES_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______KRONTIMES_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______KRONTIMES_____UU__(ui64, uint64_t, d, double, double)
-______KRONTIMES_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______KRONTIMES_____UU__(ui8, uint8_t, d, double, double)
-______KRONTIMES_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______KRONTIMES_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______KRONTIMES_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______KRONTIMES_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______KRONTIMES_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______KRONTIMES_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______KRONTIMES_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______KRONTIMES_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-__INT32_M__(d, double, int32_t)
-__INT32_M__(i16, int16_t, int32_t)
-__INT32_M__(i32, int32_t, int32_t)
-__INT32_M__(i64, int64_t, int32_t)
-__INT32_M__(i8, int8_t, int32_t)
-__INT32_M__(ui16, uint16_t, int32_t)
-__INT32_M__(ui32, uint32_t, int32_t)
-__INT32_M__(ui64, uint64_t, int32_t)
-__INT32_M__(ui8, uint8_t, int32_t)
-______GT_____MM__(b, int32_t, b, int32_t, int32_t)
-______GT_____MM__(b, int32_t, c, double, int32_t)
-______GT_____MM__(b, int32_t, d, double, int32_t)
-______GT_____MM__(b, int32_t, i16, int16_t, int32_t)
-______GT_____MM__(b, int32_t, i32, int32_t, int32_t)
-______GT_____MM__(b, int32_t, i64, int64_t, int32_t)
-______GT_____MM__(b, int32_t, i8, int8_t, int32_t)
-______GT_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______GT_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______GT_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______GT_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______GT_____MM__(c, double, b, int32_t, int32_t)
-______GT_____MM__(c, double, c, double, int32_t)
-______GT_____MM__(c, double, d, double, int32_t)
-______GT_____MM__(c, double, i16, int16_t, int32_t)
-______GT_____MM__(c, double, i32, int32_t, int32_t)
-______GT_____MM__(c, double, i64, int64_t, int32_t)
-______GT_____MM__(c, double, i8, int8_t, int32_t)
-______GT_____MM__(c, double, ui16, uint16_t, int32_t)
-______GT_____MM__(c, double, ui32, uint32_t, int32_t)
-______GT_____MM__(c, double, ui64, uint64_t, int32_t)
-______GT_____MM__(c, double, ui8, uint8_t, int32_t)
-______GT_____MM__(d, double, b, int32_t, int32_t)
-______GT_____MM__(d, double, c, double, int32_t)
-______GT_____MM__(d, double, d, double, int32_t)
-______GT_____MM__(d, double, i16, int16_t, int32_t)
-______GT_____MM__(d, double, i32, int32_t, int32_t)
-______GT_____MM__(d, double, i64, int64_t, int32_t)
-______GT_____MM__(d, double, i8, int8_t, int32_t)
-______GT_____MM__(d, double, ui16, uint16_t, int32_t)
-______GT_____MM__(d, double, ui32, uint32_t, int32_t)
-______GT_____MM__(d, double, ui64, uint64_t, int32_t)
-______GT_____MM__(d, double, ui8, uint8_t, int32_t)
-______GT_____MM__(i16, int16_t, b, int32_t, int32_t)
-______GT_____MM__(i16, int16_t, c, double, int32_t)
-______GT_____MM__(i16, int16_t, d, double, int32_t)
-______GT_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______GT_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______GT_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______GT_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______GT_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______GT_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______GT_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______GT_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______GT_____MM__(i32, int32_t, b, int32_t, int32_t)
-______GT_____MM__(i32, int32_t, c, double, int32_t)
-______GT_____MM__(i32, int32_t, d, double, int32_t)
-______GT_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______GT_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______GT_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______GT_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______GT_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______GT_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______GT_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______GT_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______GT_____MM__(i64, int64_t, b, int32_t, int32_t)
-______GT_____MM__(i64, int64_t, c, double, int32_t)
-______GT_____MM__(i64, int64_t, d, double, int32_t)
-______GT_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______GT_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______GT_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______GT_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______GT_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______GT_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______GT_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______GT_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______GT_____MM__(i8, int8_t, b, int32_t, int32_t)
-______GT_____MM__(i8, int8_t, c, double, int32_t)
-______GT_____MM__(i8, int8_t, d, double, int32_t)
-______GT_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______GT_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______GT_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______GT_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______GT_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______GT_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______GT_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______GT_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______GT_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______GT_____MM__(ui16, uint16_t, c, double, int32_t)
-______GT_____MM__(ui16, uint16_t, d, double, int32_t)
-______GT_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______GT_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______GT_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______GT_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______GT_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GT_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GT_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GT_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GT_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______GT_____MM__(ui32, uint32_t, c, double, int32_t)
-______GT_____MM__(ui32, uint32_t, d, double, int32_t)
-______GT_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______GT_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______GT_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______GT_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______GT_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GT_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GT_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GT_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GT_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______GT_____MM__(ui64, uint64_t, c, double, int32_t)
-______GT_____MM__(ui64, uint64_t, d, double, int32_t)
-______GT_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______GT_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______GT_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______GT_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______GT_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GT_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GT_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GT_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GT_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______GT_____MM__(ui8, uint8_t, c, double, int32_t)
-______GT_____MM__(ui8, uint8_t, d, double, int32_t)
-______GT_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______GT_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______GT_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______GT_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______GT_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GT_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GT_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GT_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GT_____MS__(b, int32_t, b, int32_t, int32_t)
-______GT_____MS__(b, int32_t, c, double, int32_t)
-______GT_____MS__(b, int32_t, d, double, int32_t)
-______GT_____MS__(b, int32_t, i16, int16_t, int32_t)
-______GT_____MS__(b, int32_t, i32, int32_t, int32_t)
-______GT_____MS__(b, int32_t, i64, int64_t, int32_t)
-______GT_____MS__(b, int32_t, i8, int8_t, int32_t)
-______GT_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______GT_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______GT_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______GT_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______GT_____MS__(c, double, b, int32_t, int32_t)
-______GT_____MS__(c, double, c, double, int32_t)
-______GT_____MS__(c, double, d, double, int32_t)
-______GT_____MS__(c, double, i16, int16_t, int32_t)
-______GT_____MS__(c, double, i32, int32_t, int32_t)
-______GT_____MS__(c, double, i64, int64_t, int32_t)
-______GT_____MS__(c, double, i8, int8_t, int32_t)
-______GT_____MS__(c, double, ui16, uint16_t, int32_t)
-______GT_____MS__(c, double, ui32, uint32_t, int32_t)
-______GT_____MS__(c, double, ui64, uint64_t, int32_t)
-______GT_____MS__(c, double, ui8, uint8_t, int32_t)
-______GT_____MS__(d, double, b, int32_t, int32_t)
-______GT_____MS__(d, double, c, double, int32_t)
-______GT_____MS__(d, double, d, double, int32_t)
-______GT_____MS__(d, double, i16, int16_t, int32_t)
-______GT_____MS__(d, double, i32, int32_t, int32_t)
-______GT_____MS__(d, double, i64, int64_t, int32_t)
-______GT_____MS__(d, double, i8, int8_t, int32_t)
-______GT_____MS__(d, double, ui16, uint16_t, int32_t)
-______GT_____MS__(d, double, ui32, uint32_t, int32_t)
-______GT_____MS__(d, double, ui64, uint64_t, int32_t)
-______GT_____MS__(d, double, ui8, uint8_t, int32_t)
-______GT_____MS__(i16, int16_t, b, int32_t, int32_t)
-______GT_____MS__(i16, int16_t, c, double, int32_t)
-______GT_____MS__(i16, int16_t, d, double, int32_t)
-______GT_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______GT_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______GT_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______GT_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______GT_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______GT_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______GT_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______GT_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______GT_____MS__(i32, int32_t, b, int32_t, int32_t)
-______GT_____MS__(i32, int32_t, c, double, int32_t)
-______GT_____MS__(i32, int32_t, d, double, int32_t)
-______GT_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______GT_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______GT_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______GT_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______GT_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______GT_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______GT_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______GT_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______GT_____MS__(i64, int64_t, b, int32_t, int32_t)
-______GT_____MS__(i64, int64_t, c, double, int32_t)
-______GT_____MS__(i64, int64_t, d, double, int32_t)
-______GT_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______GT_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______GT_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______GT_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______GT_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______GT_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______GT_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______GT_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______GT_____MS__(i8, int8_t, b, int32_t, int32_t)
-______GT_____MS__(i8, int8_t, c, double, int32_t)
-______GT_____MS__(i8, int8_t, d, double, int32_t)
-______GT_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______GT_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______GT_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______GT_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______GT_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______GT_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______GT_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______GT_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______GT_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______GT_____MS__(ui16, uint16_t, c, double, int32_t)
-______GT_____MS__(ui16, uint16_t, d, double, int32_t)
-______GT_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______GT_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______GT_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______GT_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______GT_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GT_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GT_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GT_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GT_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______GT_____MS__(ui32, uint32_t, c, double, int32_t)
-______GT_____MS__(ui32, uint32_t, d, double, int32_t)
-______GT_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______GT_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______GT_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______GT_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______GT_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GT_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GT_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GT_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GT_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______GT_____MS__(ui64, uint64_t, c, double, int32_t)
-______GT_____MS__(ui64, uint64_t, d, double, int32_t)
-______GT_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______GT_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______GT_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______GT_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______GT_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GT_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GT_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GT_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GT_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______GT_____MS__(ui8, uint8_t, c, double, int32_t)
-______GT_____MS__(ui8, uint8_t, d, double, int32_t)
-______GT_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______GT_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______GT_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______GT_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______GT_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GT_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GT_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GT_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GT_____SM__(b, int32_t, b, int32_t, int32_t)
-______GT_____SM__(b, int32_t, c, double, int32_t)
-______GT_____SM__(b, int32_t, d, double, int32_t)
-______GT_____SM__(b, int32_t, i16, int16_t, int32_t)
-______GT_____SM__(b, int32_t, i32, int32_t, int32_t)
-______GT_____SM__(b, int32_t, i64, int64_t, int32_t)
-______GT_____SM__(b, int32_t, i8, int8_t, int32_t)
-______GT_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______GT_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______GT_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______GT_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______GT_____SM__(c, double, b, int32_t, int32_t)
-______GT_____SM__(c, double, c, double, int32_t)
-______GT_____SM__(c, double, d, double, int32_t)
-______GT_____SM__(c, double, i16, int16_t, int32_t)
-______GT_____SM__(c, double, i32, int32_t, int32_t)
-______GT_____SM__(c, double, i64, int64_t, int32_t)
-______GT_____SM__(c, double, i8, int8_t, int32_t)
-______GT_____SM__(c, double, ui16, uint16_t, int32_t)
-______GT_____SM__(c, double, ui32, uint32_t, int32_t)
-______GT_____SM__(c, double, ui64, uint64_t, int32_t)
-______GT_____SM__(c, double, ui8, uint8_t, int32_t)
-______GT_____SM__(d, double, b, int32_t, int32_t)
-______GT_____SM__(d, double, c, double, int32_t)
-______GT_____SM__(d, double, d, double, int32_t)
-______GT_____SM__(d, double, i16, int16_t, int32_t)
-______GT_____SM__(d, double, i32, int32_t, int32_t)
-______GT_____SM__(d, double, i64, int64_t, int32_t)
-______GT_____SM__(d, double, i8, int8_t, int32_t)
-______GT_____SM__(d, double, ui16, uint16_t, int32_t)
-______GT_____SM__(d, double, ui32, uint32_t, int32_t)
-______GT_____SM__(d, double, ui64, uint64_t, int32_t)
-______GT_____SM__(d, double, ui8, uint8_t, int32_t)
-______GT_____SM__(i16, int16_t, b, int32_t, int32_t)
-______GT_____SM__(i16, int16_t, c, double, int32_t)
-______GT_____SM__(i16, int16_t, d, double, int32_t)
-______GT_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______GT_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______GT_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______GT_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______GT_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______GT_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______GT_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______GT_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______GT_____SM__(i32, int32_t, b, int32_t, int32_t)
-______GT_____SM__(i32, int32_t, c, double, int32_t)
-______GT_____SM__(i32, int32_t, d, double, int32_t)
-______GT_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______GT_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______GT_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______GT_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______GT_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______GT_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______GT_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______GT_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______GT_____SM__(i64, int64_t, b, int32_t, int32_t)
-______GT_____SM__(i64, int64_t, c, double, int32_t)
-______GT_____SM__(i64, int64_t, d, double, int32_t)
-______GT_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______GT_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______GT_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______GT_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______GT_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______GT_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______GT_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______GT_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______GT_____SM__(i8, int8_t, b, int32_t, int32_t)
-______GT_____SM__(i8, int8_t, c, double, int32_t)
-______GT_____SM__(i8, int8_t, d, double, int32_t)
-______GT_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______GT_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______GT_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______GT_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______GT_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______GT_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______GT_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______GT_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______GT_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______GT_____SM__(ui16, uint16_t, c, double, int32_t)
-______GT_____SM__(ui16, uint16_t, d, double, int32_t)
-______GT_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______GT_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______GT_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______GT_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______GT_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GT_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GT_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GT_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GT_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______GT_____SM__(ui32, uint32_t, c, double, int32_t)
-______GT_____SM__(ui32, uint32_t, d, double, int32_t)
-______GT_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______GT_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______GT_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______GT_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______GT_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GT_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GT_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GT_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GT_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______GT_____SM__(ui64, uint64_t, c, double, int32_t)
-______GT_____SM__(ui64, uint64_t, d, double, int32_t)
-______GT_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______GT_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______GT_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______GT_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______GT_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GT_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GT_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GT_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GT_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______GT_____SM__(ui8, uint8_t, c, double, int32_t)
-______GT_____SM__(ui8, uint8_t, d, double, int32_t)
-______GT_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______GT_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______GT_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______GT_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______GT_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GT_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GT_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GT_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______GT_____UU__(b, int32_t, b, int32_t, int32_t)
-______GT_____UU__(b, int32_t, c, double, int32_t)
-______GT_____UU__(b, int32_t, d, double, int32_t)
-______GT_____UU__(b, int32_t, i16, int16_t, int32_t)
-______GT_____UU__(b, int32_t, i32, int32_t, int32_t)
-______GT_____UU__(b, int32_t, i64, int64_t, int32_t)
-______GT_____UU__(b, int32_t, i8, int8_t, int32_t)
-______GT_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______GT_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______GT_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______GT_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______GT_____UU__(c, double, b, int32_t, int32_t)
-______GT_____UU__(c, double, c, double, int32_t)
-______GT_____UU__(c, double, d, double, int32_t)
-______GT_____UU__(c, double, i16, int16_t, int32_t)
-______GT_____UU__(c, double, i32, int32_t, int32_t)
-______GT_____UU__(c, double, i64, int64_t, int32_t)
-______GT_____UU__(c, double, i8, int8_t, int32_t)
-______GT_____UU__(c, double, ui16, uint16_t, int32_t)
-______GT_____UU__(c, double, ui32, uint32_t, int32_t)
-______GT_____UU__(c, double, ui64, uint64_t, int32_t)
-______GT_____UU__(c, double, ui8, uint8_t, int32_t)
-______GT_____UU__(d, double, b, int32_t, int32_t)
-______GT_____UU__(d, double, c, double, int32_t)
-______GT_____UU__(d, double, d, double, int32_t)
-______GT_____UU__(d, double, i16, int16_t, int32_t)
-______GT_____UU__(d, double, i32, int32_t, int32_t)
-______GT_____UU__(d, double, i64, int64_t, int32_t)
-______GT_____UU__(d, double, i8, int8_t, int32_t)
-______GT_____UU__(d, double, ui16, uint16_t, int32_t)
-______GT_____UU__(d, double, ui32, uint32_t, int32_t)
-______GT_____UU__(d, double, ui64, uint64_t, int32_t)
-______GT_____UU__(d, double, ui8, uint8_t, int32_t)
-______GT_____UU__(i16, int16_t, b, int32_t, int32_t)
-______GT_____UU__(i16, int16_t, c, double, int32_t)
-______GT_____UU__(i16, int16_t, d, double, int32_t)
-______GT_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______GT_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______GT_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______GT_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______GT_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______GT_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______GT_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______GT_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______GT_____UU__(i32, int32_t, b, int32_t, int32_t)
-______GT_____UU__(i32, int32_t, c, double, int32_t)
-______GT_____UU__(i32, int32_t, d, double, int32_t)
-______GT_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______GT_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______GT_____UU__(i32, int32_t, i64, int64_t, int32_t)
-______GT_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______GT_____UU__(i32, int32_t, ui16, uint16_t, int32_t)
-______GT_____UU__(i32, int32_t, ui32, uint32_t, int32_t)
-______GT_____UU__(i32, int32_t, ui64, uint64_t, int32_t)
-______GT_____UU__(i32, int32_t, ui8, uint8_t, int32_t)
-______GT_____UU__(i64, int64_t, b, int32_t, int32_t)
-______GT_____UU__(i64, int64_t, c, double, int32_t)
-______GT_____UU__(i64, int64_t, d, double, int32_t)
-______GT_____UU__(i64, int64_t, i16, int16_t, int32_t)
-______GT_____UU__(i64, int64_t, i32, int32_t, int32_t)
-______GT_____UU__(i64, int64_t, i64, int64_t, int32_t)
-______GT_____UU__(i64, int64_t, i8, int8_t, int32_t)
-______GT_____UU__(i64, int64_t, ui16, uint16_t, int32_t)
-______GT_____UU__(i64, int64_t, ui32, uint32_t, int32_t)
-______GT_____UU__(i64, int64_t, ui64, uint64_t, int32_t)
-______GT_____UU__(i64, int64_t, ui8, uint8_t, int32_t)
-______GT_____UU__(i8, int8_t, b, int32_t, int32_t)
-______GT_____UU__(i8, int8_t, c, double, int32_t)
-______GT_____UU__(i8, int8_t, d, double, int32_t)
-______GT_____UU__(i8, int8_t, i16, int16_t, int32_t)
-______GT_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______GT_____UU__(i8, int8_t, i64, int64_t, int32_t)
-______GT_____UU__(i8, int8_t, i8, int8_t, int32_t)
-______GT_____UU__(i8, int8_t, ui16, uint16_t, int32_t)
-______GT_____UU__(i8, int8_t, ui32, uint32_t, int32_t)
-______GT_____UU__(i8, int8_t, ui64, uint64_t, int32_t)
-______GT_____UU__(i8, int8_t, ui8, uint8_t, int32_t)
-______GT_____UU__(ui16, uint16_t, b, int32_t, int32_t)
-______GT_____UU__(ui16, uint16_t, c, double, int32_t)
-______GT_____UU__(ui16, uint16_t, d, double, int32_t)
-______GT_____UU__(ui16, uint16_t, i16, int16_t, int32_t)
-______GT_____UU__(ui16, uint16_t, i32, int32_t, int32_t)
-______GT_____UU__(ui16, uint16_t, i64, int64_t, int32_t)
-______GT_____UU__(ui16, uint16_t, i8, int8_t, int32_t)
-______GT_____UU__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______GT_____UU__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______GT_____UU__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______GT_____UU__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______GT_____UU__(ui32, uint32_t, b, int32_t, int32_t)
-______GT_____UU__(ui32, uint32_t, c, double, int32_t)
-______GT_____UU__(ui32, uint32_t, d, double, int32_t)
-______GT_____UU__(ui32, uint32_t, i16, int16_t, int32_t)
-______GT_____UU__(ui32, uint32_t, i32, int32_t, int32_t)
-______GT_____UU__(ui32, uint32_t, i64, int64_t, int32_t)
-______GT_____UU__(ui32, uint32_t, i8, int8_t, int32_t)
-______GT_____UU__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______GT_____UU__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______GT_____UU__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______GT_____UU__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______GT_____UU__(ui64, uint64_t, b, int32_t, int32_t)
-______GT_____UU__(ui64, uint64_t, c, double, int32_t)
-______GT_____UU__(ui64, uint64_t, d, double, int32_t)
-______GT_____UU__(ui64, uint64_t, i16, int16_t, int32_t)
-______GT_____UU__(ui64, uint64_t, i32, int32_t, int32_t)
-______GT_____UU__(ui64, uint64_t, i64, int64_t, int32_t)
-______GT_____UU__(ui64, uint64_t, i8, int8_t, int32_t)
-______GT_____UU__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______GT_____UU__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______GT_____UU__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______GT_____UU__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______GT_____UU__(ui8, uint8_t, b, int32_t, int32_t)
-______GT_____UU__(ui8, uint8_t, c, double, int32_t)
-______GT_____UU__(ui8, uint8_t, d, double, int32_t)
-______GT_____UU__(ui8, uint8_t, i16, int16_t, int32_t)
-______GT_____UU__(ui8, uint8_t, i32, int32_t, int32_t)
-______GT_____UU__(ui8, uint8_t, i64, int64_t, int32_t)
-______GT_____UU__(ui8, uint8_t, i8, int8_t, int32_t)
-______GT_____UU__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______GT_____UU__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______GT_____UU__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______GT_____UU__(ui8, uint8_t, ui8, uint8_t, int32_t)
-__INTTYPE_M__(c, double, double)
-__INTTYPE_M__(d, double, double)
-__INTTYPE_M__(i16, int16_t, double)
-__INTTYPE_M__(i32, int32_t, double)
-__INTTYPE_M__(i64, int64_t, double)
-__INTTYPE_M__(i8, int8_t, double)
-__INTTYPE_M__(ui16, uint16_t, double)
-__INTTYPE_M__(ui32, uint32_t, double)
-__INTTYPE_M__(ui64, uint64_t, double)
-__INTTYPE_M__(ui8, uint8_t, double)
-__EXP_M__(c, double, double)
-__EXP_M__(d, double, double)
-__ATAN_M__(c, double, double)
-__ATAN_M__(d, double, double)
-______DOTRDIV_____MM__(b, int32_t, b, int32_t, double)
-______DOTRDIV_____MM__(b, int32_t, c, double, double)
-______DOTRDIV_____MM__(b, int32_t, d, double, double)
-______DOTRDIV_____MM__(b, int32_t, i16, int16_t, int16_t)
-______DOTRDIV_____MM__(b, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____MM__(b, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(b, int32_t, i8, int8_t, int8_t)
-______DOTRDIV_____MM__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MM__(c, double, b, int32_t, double)
-______DOTRDIV_____MM__(c, double, c, double, double)
-______DOTRDIV_____MM__(c, double, d, double, double)
-______DOTRDIV_____MM__(d, double, b, int32_t, double)
-______DOTRDIV_____MM__(d, double, c, double, double)
-______DOTRDIV_____MM__(d, double, d, double, double)
-______DOTRDIV_____MM__(d, double, i16, int16_t, int16_t)
-______DOTRDIV_____MM__(d, double, i32, int32_t, int32_t)
-______DOTRDIV_____MM__(d, double, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(d, double, i8, int8_t, int8_t)
-______DOTRDIV_____MM__(d, double, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(d, double, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(d, double, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(d, double, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MM__(i16, int16_t, b, int32_t, int16_t)
-______DOTRDIV_____MM__(i16, int16_t, d, double, int16_t)
-______DOTRDIV_____MM__(i16, int16_t, i16, int16_t, int16_t)
-______DOTRDIV_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______DOTRDIV_____MM__(i16, int16_t, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(i16, int16_t, i8, int8_t, int16_t)
-______DOTRDIV_____MM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____MM__(i32, int32_t, b, int32_t, int32_t)
-______DOTRDIV_____MM__(i32, int32_t, d, double, int32_t)
-______DOTRDIV_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______DOTRDIV_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____MM__(i32, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______DOTRDIV_____MM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____MM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____MM__(i64, int64_t, b, int32_t, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, d, double, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, i16, int16_t, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, i32, int32_t, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, i8, int8_t, int64_t)
-______DOTRDIV_____MM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____MM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____MM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____MM__(i8, int8_t, b, int32_t, int8_t)
-______DOTRDIV_____MM__(i8, int8_t, d, double, int8_t)
-______DOTRDIV_____MM__(i8, int8_t, i16, int16_t, int16_t)
-______DOTRDIV_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______DOTRDIV_____MM__(i8, int8_t, i64, int64_t, int64_t)
-______DOTRDIV_____MM__(i8, int8_t, i8, int8_t, int8_t)
-______DOTRDIV_____MM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MM__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTRDIV_____MM__(ui16, uint16_t, d, double, uint16_t)
-______DOTRDIV_____MM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTRDIV_____MM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTRDIV_____MM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____MM__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, d, double, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____MM__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, d, double, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____MM__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTRDIV_____MM__(ui8, uint8_t, d, double, uint8_t)
-______DOTRDIV_____MM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTRDIV_____MM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTRDIV_____MM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MS__(b, int32_t, b, int32_t, double)
-______DOTRDIV_____MS__(b, int32_t, c, double, double)
-______DOTRDIV_____MS__(b, int32_t, d, double, double)
-______DOTRDIV_____MS__(b, int32_t, i16, int16_t, int16_t)
-______DOTRDIV_____MS__(b, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____MS__(b, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(b, int32_t, i8, int8_t, int8_t)
-______DOTRDIV_____MS__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MS__(c, double, b, int32_t, double)
-______DOTRDIV_____MS__(c, double, c, double, double)
-______DOTRDIV_____MS__(c, double, d, double, double)
-______DOTRDIV_____MS__(d, double, b, int32_t, double)
-______DOTRDIV_____MS__(d, double, c, double, double)
-______DOTRDIV_____MS__(d, double, d, double, double)
-______DOTRDIV_____MS__(d, double, i16, int16_t, int16_t)
-______DOTRDIV_____MS__(d, double, i32, int32_t, int32_t)
-______DOTRDIV_____MS__(d, double, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(d, double, i8, int8_t, int8_t)
-______DOTRDIV_____MS__(d, double, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(d, double, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(d, double, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(d, double, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MS__(i16, int16_t, b, int32_t, int16_t)
-______DOTRDIV_____MS__(i16, int16_t, d, double, int16_t)
-______DOTRDIV_____MS__(i16, int16_t, i16, int16_t, int16_t)
-______DOTRDIV_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______DOTRDIV_____MS__(i16, int16_t, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(i16, int16_t, i8, int8_t, int16_t)
-______DOTRDIV_____MS__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____MS__(i32, int32_t, b, int32_t, int32_t)
-______DOTRDIV_____MS__(i32, int32_t, d, double, int32_t)
-______DOTRDIV_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______DOTRDIV_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____MS__(i32, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______DOTRDIV_____MS__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____MS__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____MS__(i64, int64_t, b, int32_t, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, d, double, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, i16, int16_t, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, i32, int32_t, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, i8, int8_t, int64_t)
-______DOTRDIV_____MS__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____MS__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____MS__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____MS__(i8, int8_t, b, int32_t, int8_t)
-______DOTRDIV_____MS__(i8, int8_t, d, double, int8_t)
-______DOTRDIV_____MS__(i8, int8_t, i16, int16_t, int16_t)
-______DOTRDIV_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______DOTRDIV_____MS__(i8, int8_t, i64, int64_t, int64_t)
-______DOTRDIV_____MS__(i8, int8_t, i8, int8_t, int8_t)
-______DOTRDIV_____MS__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____MS__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTRDIV_____MS__(ui16, uint16_t, d, double, uint16_t)
-______DOTRDIV_____MS__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTRDIV_____MS__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MS__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MS__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTRDIV_____MS__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____MS__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, d, double, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MS__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____MS__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, d, double, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____MS__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTRDIV_____MS__(ui8, uint8_t, d, double, uint8_t)
-______DOTRDIV_____MS__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTRDIV_____MS__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTRDIV_____MS__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTRDIV_____MS__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTRDIV_____MS__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____MS__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____MS__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____MS__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____SM__(b, int32_t, b, int32_t, double)
-______DOTRDIV_____SM__(b, int32_t, c, double, double)
-______DOTRDIV_____SM__(b, int32_t, d, double, double)
-______DOTRDIV_____SM__(b, int32_t, i16, int16_t, int16_t)
-______DOTRDIV_____SM__(b, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____SM__(b, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(b, int32_t, i8, int8_t, int8_t)
-______DOTRDIV_____SM__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____SM__(c, double, b, int32_t, double)
-______DOTRDIV_____SM__(c, double, c, double, double)
-______DOTRDIV_____SM__(c, double, d, double, double)
-______DOTRDIV_____SM__(d, double, b, int32_t, double)
-______DOTRDIV_____SM__(d, double, c, double, double)
-______DOTRDIV_____SM__(d, double, d, double, double)
-______DOTRDIV_____SM__(d, double, i16, int16_t, int16_t)
-______DOTRDIV_____SM__(d, double, i32, int32_t, int32_t)
-______DOTRDIV_____SM__(d, double, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(d, double, i8, int8_t, int8_t)
-______DOTRDIV_____SM__(d, double, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(d, double, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(d, double, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(d, double, ui8, uint8_t, uint8_t)
-______DOTRDIV_____SM__(i16, int16_t, b, int32_t, int16_t)
-______DOTRDIV_____SM__(i16, int16_t, d, double, int16_t)
-______DOTRDIV_____SM__(i16, int16_t, i16, int16_t, int16_t)
-______DOTRDIV_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______DOTRDIV_____SM__(i16, int16_t, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(i16, int16_t, i8, int8_t, int16_t)
-______DOTRDIV_____SM__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____SM__(i32, int32_t, b, int32_t, int32_t)
-______DOTRDIV_____SM__(i32, int32_t, d, double, int32_t)
-______DOTRDIV_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______DOTRDIV_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____SM__(i32, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______DOTRDIV_____SM__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____SM__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____SM__(i64, int64_t, b, int32_t, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, d, double, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, i16, int16_t, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, i32, int32_t, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, i8, int8_t, int64_t)
-______DOTRDIV_____SM__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____SM__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____SM__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____SM__(i8, int8_t, b, int32_t, int8_t)
-______DOTRDIV_____SM__(i8, int8_t, d, double, int8_t)
-______DOTRDIV_____SM__(i8, int8_t, i16, int16_t, int16_t)
-______DOTRDIV_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______DOTRDIV_____SM__(i8, int8_t, i64, int64_t, int64_t)
-______DOTRDIV_____SM__(i8, int8_t, i8, int8_t, int8_t)
-______DOTRDIV_____SM__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____SM__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTRDIV_____SM__(ui16, uint16_t, d, double, uint16_t)
-______DOTRDIV_____SM__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTRDIV_____SM__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTRDIV_____SM__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTRDIV_____SM__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTRDIV_____SM__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____SM__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, d, double, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTRDIV_____SM__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____SM__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, d, double, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____SM__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTRDIV_____SM__(ui8, uint8_t, d, double, uint8_t)
-______DOTRDIV_____SM__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTRDIV_____SM__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTRDIV_____SM__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTRDIV_____SM__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTRDIV_____SM__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____SM__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____SM__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____SM__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____UU__(b, int32_t, b, int32_t, double)
-______DOTRDIV_____UU__(b, int32_t, c, double, double)
-______DOTRDIV_____UU__(b, int32_t, d, double, double)
-______DOTRDIV_____UU__(b, int32_t, i16, int16_t, int16_t)
-______DOTRDIV_____UU__(b, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____UU__(b, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(b, int32_t, i8, int8_t, int8_t)
-______DOTRDIV_____UU__(b, int32_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(b, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(b, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(b, int32_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____UU__(c, double, b, int32_t, double)
-______DOTRDIV_____UU__(c, double, c, double, double)
-______DOTRDIV_____UU__(c, double, d, double, double)
-______DOTRDIV_____UU__(d, double, b, int32_t, double)
-______DOTRDIV_____UU__(d, double, c, double, double)
-______DOTRDIV_____UU__(d, double, d, double, double)
-______DOTRDIV_____UU__(d, double, i16, int16_t, int16_t)
-______DOTRDIV_____UU__(d, double, i32, int32_t, int32_t)
-______DOTRDIV_____UU__(d, double, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(d, double, i8, int8_t, int8_t)
-______DOTRDIV_____UU__(d, double, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(d, double, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(d, double, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(d, double, ui8, uint8_t, uint8_t)
-______DOTRDIV_____UU__(i16, int16_t, b, int32_t, int16_t)
-______DOTRDIV_____UU__(i16, int16_t, d, double, int16_t)
-______DOTRDIV_____UU__(i16, int16_t, i16, int16_t, int16_t)
-______DOTRDIV_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______DOTRDIV_____UU__(i16, int16_t, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(i16, int16_t, i8, int8_t, int16_t)
-______DOTRDIV_____UU__(i16, int16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(i16, int16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(i16, int16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(i16, int16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____UU__(i32, int32_t, b, int32_t, int32_t)
-______DOTRDIV_____UU__(i32, int32_t, d, double, int32_t)
-______DOTRDIV_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______DOTRDIV_____UU__(i32, int32_t, i32, int32_t, int32_t)
-______DOTRDIV_____UU__(i32, int32_t, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(i32, int32_t, i8, int8_t, int32_t)
-______DOTRDIV_____UU__(i32, int32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____UU__(i32, int32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(i32, int32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(i32, int32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____UU__(i64, int64_t, b, int32_t, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, d, double, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, i16, int16_t, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, i32, int32_t, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, i8, int8_t, int64_t)
-______DOTRDIV_____UU__(i64, int64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____UU__(i64, int64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____UU__(i64, int64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(i64, int64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____UU__(i8, int8_t, b, int32_t, int8_t)
-______DOTRDIV_____UU__(i8, int8_t, d, double, int8_t)
-______DOTRDIV_____UU__(i8, int8_t, i16, int16_t, int16_t)
-______DOTRDIV_____UU__(i8, int8_t, i32, int32_t, int32_t)
-______DOTRDIV_____UU__(i8, int8_t, i64, int64_t, int64_t)
-______DOTRDIV_____UU__(i8, int8_t, i8, int8_t, int8_t)
-______DOTRDIV_____UU__(i8, int8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(i8, int8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(i8, int8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(i8, int8_t, ui8, uint8_t, uint8_t)
-______DOTRDIV_____UU__(ui16, uint16_t, b, int32_t, uint16_t)
-______DOTRDIV_____UU__(ui16, uint16_t, d, double, uint16_t)
-______DOTRDIV_____UU__(ui16, uint16_t, i16, int16_t, uint16_t)
-______DOTRDIV_____UU__(ui16, uint16_t, i32, int32_t, uint32_t)
-______DOTRDIV_____UU__(ui16, uint16_t, i64, int64_t, uint64_t)
-______DOTRDIV_____UU__(ui16, uint16_t, i8, int8_t, uint16_t)
-______DOTRDIV_____UU__(ui16, uint16_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(ui16, uint16_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(ui16, uint16_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(ui16, uint16_t, ui8, uint8_t, uint16_t)
-______DOTRDIV_____UU__(ui32, uint32_t, b, int32_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, d, double, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, i16, int16_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, i32, int32_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, i64, int64_t, uint64_t)
-______DOTRDIV_____UU__(ui32, uint32_t, i8, int8_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, ui16, uint16_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(ui32, uint32_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(ui32, uint32_t, ui8, uint8_t, uint32_t)
-______DOTRDIV_____UU__(ui64, uint64_t, b, int32_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, d, double, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, i16, int16_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, i32, int32_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, i64, int64_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, i8, int8_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, ui16, uint16_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, ui32, uint32_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(ui64, uint64_t, ui8, uint8_t, uint64_t)
-______DOTRDIV_____UU__(ui8, uint8_t, b, int32_t, uint8_t)
-______DOTRDIV_____UU__(ui8, uint8_t, d, double, uint8_t)
-______DOTRDIV_____UU__(ui8, uint8_t, i16, int16_t, uint16_t)
-______DOTRDIV_____UU__(ui8, uint8_t, i32, int32_t, uint32_t)
-______DOTRDIV_____UU__(ui8, uint8_t, i64, int64_t, uint64_t)
-______DOTRDIV_____UU__(ui8, uint8_t, i8, int8_t, uint8_t)
-______DOTRDIV_____UU__(ui8, uint8_t, ui16, uint16_t, uint16_t)
-______DOTRDIV_____UU__(ui8, uint8_t, ui32, uint32_t, uint32_t)
-______DOTRDIV_____UU__(ui8, uint8_t, ui64, uint64_t, uint64_t)
-______DOTRDIV_____UU__(ui8, uint8_t, ui8, uint8_t, uint8_t)
-__IMAG_M__(c, double, double)
-__IMAG_M__(d, double, double)
-__UINT8_M__(d, double, uint8_t)
-__UINT8_M__(i16, int16_t, uint8_t)
-__UINT8_M__(i32, int32_t, uint8_t)
-__UINT8_M__(i64, int64_t, uint8_t)
-__UINT8_M__(i8, int8_t, uint8_t)
-__UINT8_M__(ui16, uint16_t, uint8_t)
-__UINT8_M__(ui32, uint32_t, uint8_t)
-__UINT8_M__(ui64, uint64_t, uint8_t)
-__UINT8_M__(ui8, uint8_t, uint8_t)
-__CEIL_M__(c, double, double)
-__CEIL_M__(d, double, double)
-__CEIL_M__(i16, int16_t, int16_t)
-__CEIL_M__(i32, int32_t, int32_t)
-__CEIL_M__(i64, int64_t, int64_t)
-__CEIL_M__(i8, int8_t, int8_t)
-__CEIL_M__(ui16, uint16_t, uint16_t)
-__CEIL_M__(ui32, uint32_t, uint32_t)
-__CEIL_M__(ui64, uint64_t, uint64_t)
-__CEIL_M__(ui8, uint8_t, uint8_t)
-__UINT64_M__(d, double, uint64_t)
-__UINT64_M__(i16, int16_t, uint64_t)
-__UINT64_M__(i32, int32_t, uint64_t)
-__UINT64_M__(i64, int64_t, uint64_t)
-__UINT64_M__(i8, int8_t, uint64_t)
-__UINT64_M__(ui16, uint16_t, uint64_t)
-__UINT64_M__(ui32, uint32_t, uint64_t)
-__UINT64_M__(ui64, uint64_t, uint64_t)
-__UINT64_M__(ui8, uint8_t, uint64_t)
-______LT_____MM__(b, int32_t, b, int32_t, int32_t)
-______LT_____MM__(b, int32_t, c, double, int32_t)
-______LT_____MM__(b, int32_t, d, double, int32_t)
-______LT_____MM__(b, int32_t, i16, int16_t, int32_t)
-______LT_____MM__(b, int32_t, i32, int32_t, int32_t)
-______LT_____MM__(b, int32_t, i64, int64_t, int32_t)
-______LT_____MM__(b, int32_t, i8, int8_t, int32_t)
-______LT_____MM__(b, int32_t, ui16, uint16_t, int32_t)
-______LT_____MM__(b, int32_t, ui32, uint32_t, int32_t)
-______LT_____MM__(b, int32_t, ui64, uint64_t, int32_t)
-______LT_____MM__(b, int32_t, ui8, uint8_t, int32_t)
-______LT_____MM__(c, double, b, int32_t, int32_t)
-______LT_____MM__(c, double, c, double, int32_t)
-______LT_____MM__(c, double, d, double, int32_t)
-______LT_____MM__(c, double, i16, int16_t, int32_t)
-______LT_____MM__(c, double, i32, int32_t, int32_t)
-______LT_____MM__(c, double, i64, int64_t, int32_t)
-______LT_____MM__(c, double, i8, int8_t, int32_t)
-______LT_____MM__(c, double, ui16, uint16_t, int32_t)
-______LT_____MM__(c, double, ui32, uint32_t, int32_t)
-______LT_____MM__(c, double, ui64, uint64_t, int32_t)
-______LT_____MM__(c, double, ui8, uint8_t, int32_t)
-______LT_____MM__(d, double, b, int32_t, int32_t)
-______LT_____MM__(d, double, c, double, int32_t)
-______LT_____MM__(d, double, d, double, int32_t)
-______LT_____MM__(d, double, i16, int16_t, int32_t)
-______LT_____MM__(d, double, i32, int32_t, int32_t)
-______LT_____MM__(d, double, i64, int64_t, int32_t)
-______LT_____MM__(d, double, i8, int8_t, int32_t)
-______LT_____MM__(d, double, ui16, uint16_t, int32_t)
-______LT_____MM__(d, double, ui32, uint32_t, int32_t)
-______LT_____MM__(d, double, ui64, uint64_t, int32_t)
-______LT_____MM__(d, double, ui8, uint8_t, int32_t)
-______LT_____MM__(i16, int16_t, b, int32_t, int32_t)
-______LT_____MM__(i16, int16_t, c, double, int32_t)
-______LT_____MM__(i16, int16_t, d, double, int32_t)
-______LT_____MM__(i16, int16_t, i16, int16_t, int32_t)
-______LT_____MM__(i16, int16_t, i32, int32_t, int32_t)
-______LT_____MM__(i16, int16_t, i64, int64_t, int32_t)
-______LT_____MM__(i16, int16_t, i8, int8_t, int32_t)
-______LT_____MM__(i16, int16_t, ui16, uint16_t, int32_t)
-______LT_____MM__(i16, int16_t, ui32, uint32_t, int32_t)
-______LT_____MM__(i16, int16_t, ui64, uint64_t, int32_t)
-______LT_____MM__(i16, int16_t, ui8, uint8_t, int32_t)
-______LT_____MM__(i32, int32_t, b, int32_t, int32_t)
-______LT_____MM__(i32, int32_t, c, double, int32_t)
-______LT_____MM__(i32, int32_t, d, double, int32_t)
-______LT_____MM__(i32, int32_t, i16, int16_t, int32_t)
-______LT_____MM__(i32, int32_t, i32, int32_t, int32_t)
-______LT_____MM__(i32, int32_t, i64, int64_t, int32_t)
-______LT_____MM__(i32, int32_t, i8, int8_t, int32_t)
-______LT_____MM__(i32, int32_t, ui16, uint16_t, int32_t)
-______LT_____MM__(i32, int32_t, ui32, uint32_t, int32_t)
-______LT_____MM__(i32, int32_t, ui64, uint64_t, int32_t)
-______LT_____MM__(i32, int32_t, ui8, uint8_t, int32_t)
-______LT_____MM__(i64, int64_t, b, int32_t, int32_t)
-______LT_____MM__(i64, int64_t, c, double, int32_t)
-______LT_____MM__(i64, int64_t, d, double, int32_t)
-______LT_____MM__(i64, int64_t, i16, int16_t, int32_t)
-______LT_____MM__(i64, int64_t, i32, int32_t, int32_t)
-______LT_____MM__(i64, int64_t, i64, int64_t, int32_t)
-______LT_____MM__(i64, int64_t, i8, int8_t, int32_t)
-______LT_____MM__(i64, int64_t, ui16, uint16_t, int32_t)
-______LT_____MM__(i64, int64_t, ui32, uint32_t, int32_t)
-______LT_____MM__(i64, int64_t, ui64, uint64_t, int32_t)
-______LT_____MM__(i64, int64_t, ui8, uint8_t, int32_t)
-______LT_____MM__(i8, int8_t, b, int32_t, int32_t)
-______LT_____MM__(i8, int8_t, c, double, int32_t)
-______LT_____MM__(i8, int8_t, d, double, int32_t)
-______LT_____MM__(i8, int8_t, i16, int16_t, int32_t)
-______LT_____MM__(i8, int8_t, i32, int32_t, int32_t)
-______LT_____MM__(i8, int8_t, i64, int64_t, int32_t)
-______LT_____MM__(i8, int8_t, i8, int8_t, int32_t)
-______LT_____MM__(i8, int8_t, ui16, uint16_t, int32_t)
-______LT_____MM__(i8, int8_t, ui32, uint32_t, int32_t)
-______LT_____MM__(i8, int8_t, ui64, uint64_t, int32_t)
-______LT_____MM__(i8, int8_t, ui8, uint8_t, int32_t)
-______LT_____MM__(ui16, uint16_t, b, int32_t, int32_t)
-______LT_____MM__(ui16, uint16_t, c, double, int32_t)
-______LT_____MM__(ui16, uint16_t, d, double, int32_t)
-______LT_____MM__(ui16, uint16_t, i16, int16_t, int32_t)
-______LT_____MM__(ui16, uint16_t, i32, int32_t, int32_t)
-______LT_____MM__(ui16, uint16_t, i64, int64_t, int32_t)
-______LT_____MM__(ui16, uint16_t, i8, int8_t, int32_t)
-______LT_____MM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LT_____MM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LT_____MM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LT_____MM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LT_____MM__(ui32, uint32_t, b, int32_t, int32_t)
-______LT_____MM__(ui32, uint32_t, c, double, int32_t)
-______LT_____MM__(ui32, uint32_t, d, double, int32_t)
-______LT_____MM__(ui32, uint32_t, i16, int16_t, int32_t)
-______LT_____MM__(ui32, uint32_t, i32, int32_t, int32_t)
-______LT_____MM__(ui32, uint32_t, i64, int64_t, int32_t)
-______LT_____MM__(ui32, uint32_t, i8, int8_t, int32_t)
-______LT_____MM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LT_____MM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LT_____MM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LT_____MM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LT_____MM__(ui64, uint64_t, b, int32_t, int32_t)
-______LT_____MM__(ui64, uint64_t, c, double, int32_t)
-______LT_____MM__(ui64, uint64_t, d, double, int32_t)
-______LT_____MM__(ui64, uint64_t, i16, int16_t, int32_t)
-______LT_____MM__(ui64, uint64_t, i32, int32_t, int32_t)
-______LT_____MM__(ui64, uint64_t, i64, int64_t, int32_t)
-______LT_____MM__(ui64, uint64_t, i8, int8_t, int32_t)
-______LT_____MM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LT_____MM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LT_____MM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LT_____MM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LT_____MM__(ui8, uint8_t, b, int32_t, int32_t)
-______LT_____MM__(ui8, uint8_t, c, double, int32_t)
-______LT_____MM__(ui8, uint8_t, d, double, int32_t)
-______LT_____MM__(ui8, uint8_t, i16, int16_t, int32_t)
-______LT_____MM__(ui8, uint8_t, i32, int32_t, int32_t)
-______LT_____MM__(ui8, uint8_t, i64, int64_t, int32_t)
-______LT_____MM__(ui8, uint8_t, i8, int8_t, int32_t)
-______LT_____MM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LT_____MM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LT_____MM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LT_____MM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LT_____MS__(b, int32_t, b, int32_t, int32_t)
-______LT_____MS__(b, int32_t, c, double, int32_t)
-______LT_____MS__(b, int32_t, d, double, int32_t)
-______LT_____MS__(b, int32_t, i16, int16_t, int32_t)
-______LT_____MS__(b, int32_t, i32, int32_t, int32_t)
-______LT_____MS__(b, int32_t, i64, int64_t, int32_t)
-______LT_____MS__(b, int32_t, i8, int8_t, int32_t)
-______LT_____MS__(b, int32_t, ui16, uint16_t, int32_t)
-______LT_____MS__(b, int32_t, ui32, uint32_t, int32_t)
-______LT_____MS__(b, int32_t, ui64, uint64_t, int32_t)
-______LT_____MS__(b, int32_t, ui8, uint8_t, int32_t)
-______LT_____MS__(c, double, b, int32_t, int32_t)
-______LT_____MS__(c, double, c, double, int32_t)
-______LT_____MS__(c, double, d, double, int32_t)
-______LT_____MS__(c, double, i16, int16_t, int32_t)
-______LT_____MS__(c, double, i32, int32_t, int32_t)
-______LT_____MS__(c, double, i64, int64_t, int32_t)
-______LT_____MS__(c, double, i8, int8_t, int32_t)
-______LT_____MS__(c, double, ui16, uint16_t, int32_t)
-______LT_____MS__(c, double, ui32, uint32_t, int32_t)
-______LT_____MS__(c, double, ui64, uint64_t, int32_t)
-______LT_____MS__(c, double, ui8, uint8_t, int32_t)
-______LT_____MS__(d, double, b, int32_t, int32_t)
-______LT_____MS__(d, double, c, double, int32_t)
-______LT_____MS__(d, double, d, double, int32_t)
-______LT_____MS__(d, double, i16, int16_t, int32_t)
-______LT_____MS__(d, double, i32, int32_t, int32_t)
-______LT_____MS__(d, double, i64, int64_t, int32_t)
-______LT_____MS__(d, double, i8, int8_t, int32_t)
-______LT_____MS__(d, double, ui16, uint16_t, int32_t)
-______LT_____MS__(d, double, ui32, uint32_t, int32_t)
-______LT_____MS__(d, double, ui64, uint64_t, int32_t)
-______LT_____MS__(d, double, ui8, uint8_t, int32_t)
-______LT_____MS__(i16, int16_t, b, int32_t, int32_t)
-______LT_____MS__(i16, int16_t, c, double, int32_t)
-______LT_____MS__(i16, int16_t, d, double, int32_t)
-______LT_____MS__(i16, int16_t, i16, int16_t, int32_t)
-______LT_____MS__(i16, int16_t, i32, int32_t, int32_t)
-______LT_____MS__(i16, int16_t, i64, int64_t, int32_t)
-______LT_____MS__(i16, int16_t, i8, int8_t, int32_t)
-______LT_____MS__(i16, int16_t, ui16, uint16_t, int32_t)
-______LT_____MS__(i16, int16_t, ui32, uint32_t, int32_t)
-______LT_____MS__(i16, int16_t, ui64, uint64_t, int32_t)
-______LT_____MS__(i16, int16_t, ui8, uint8_t, int32_t)
-______LT_____MS__(i32, int32_t, b, int32_t, int32_t)
-______LT_____MS__(i32, int32_t, c, double, int32_t)
-______LT_____MS__(i32, int32_t, d, double, int32_t)
-______LT_____MS__(i32, int32_t, i16, int16_t, int32_t)
-______LT_____MS__(i32, int32_t, i32, int32_t, int32_t)
-______LT_____MS__(i32, int32_t, i64, int64_t, int32_t)
-______LT_____MS__(i32, int32_t, i8, int8_t, int32_t)
-______LT_____MS__(i32, int32_t, ui16, uint16_t, int32_t)
-______LT_____MS__(i32, int32_t, ui32, uint32_t, int32_t)
-______LT_____MS__(i32, int32_t, ui64, uint64_t, int32_t)
-______LT_____MS__(i32, int32_t, ui8, uint8_t, int32_t)
-______LT_____MS__(i64, int64_t, b, int32_t, int32_t)
-______LT_____MS__(i64, int64_t, c, double, int32_t)
-______LT_____MS__(i64, int64_t, d, double, int32_t)
-______LT_____MS__(i64, int64_t, i16, int16_t, int32_t)
-______LT_____MS__(i64, int64_t, i32, int32_t, int32_t)
-______LT_____MS__(i64, int64_t, i64, int64_t, int32_t)
-______LT_____MS__(i64, int64_t, i8, int8_t, int32_t)
-______LT_____MS__(i64, int64_t, ui16, uint16_t, int32_t)
-______LT_____MS__(i64, int64_t, ui32, uint32_t, int32_t)
-______LT_____MS__(i64, int64_t, ui64, uint64_t, int32_t)
-______LT_____MS__(i64, int64_t, ui8, uint8_t, int32_t)
-______LT_____MS__(i8, int8_t, b, int32_t, int32_t)
-______LT_____MS__(i8, int8_t, c, double, int32_t)
-______LT_____MS__(i8, int8_t, d, double, int32_t)
-______LT_____MS__(i8, int8_t, i16, int16_t, int32_t)
-______LT_____MS__(i8, int8_t, i32, int32_t, int32_t)
-______LT_____MS__(i8, int8_t, i64, int64_t, int32_t)
-______LT_____MS__(i8, int8_t, i8, int8_t, int32_t)
-______LT_____MS__(i8, int8_t, ui16, uint16_t, int32_t)
-______LT_____MS__(i8, int8_t, ui32, uint32_t, int32_t)
-______LT_____MS__(i8, int8_t, ui64, uint64_t, int32_t)
-______LT_____MS__(i8, int8_t, ui8, uint8_t, int32_t)
-______LT_____MS__(ui16, uint16_t, b, int32_t, int32_t)
-______LT_____MS__(ui16, uint16_t, c, double, int32_t)
-______LT_____MS__(ui16, uint16_t, d, double, int32_t)
-______LT_____MS__(ui16, uint16_t, i16, int16_t, int32_t)
-______LT_____MS__(ui16, uint16_t, i32, int32_t, int32_t)
-______LT_____MS__(ui16, uint16_t, i64, int64_t, int32_t)
-______LT_____MS__(ui16, uint16_t, i8, int8_t, int32_t)
-______LT_____MS__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LT_____MS__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LT_____MS__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LT_____MS__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LT_____MS__(ui32, uint32_t, b, int32_t, int32_t)
-______LT_____MS__(ui32, uint32_t, c, double, int32_t)
-______LT_____MS__(ui32, uint32_t, d, double, int32_t)
-______LT_____MS__(ui32, uint32_t, i16, int16_t, int32_t)
-______LT_____MS__(ui32, uint32_t, i32, int32_t, int32_t)
-______LT_____MS__(ui32, uint32_t, i64, int64_t, int32_t)
-______LT_____MS__(ui32, uint32_t, i8, int8_t, int32_t)
-______LT_____MS__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LT_____MS__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LT_____MS__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LT_____MS__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LT_____MS__(ui64, uint64_t, b, int32_t, int32_t)
-______LT_____MS__(ui64, uint64_t, c, double, int32_t)
-______LT_____MS__(ui64, uint64_t, d, double, int32_t)
-______LT_____MS__(ui64, uint64_t, i16, int16_t, int32_t)
-______LT_____MS__(ui64, uint64_t, i32, int32_t, int32_t)
-______LT_____MS__(ui64, uint64_t, i64, int64_t, int32_t)
-______LT_____MS__(ui64, uint64_t, i8, int8_t, int32_t)
-______LT_____MS__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LT_____MS__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LT_____MS__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LT_____MS__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LT_____MS__(ui8, uint8_t, b, int32_t, int32_t)
-______LT_____MS__(ui8, uint8_t, c, double, int32_t)
-______LT_____MS__(ui8, uint8_t, d, double, int32_t)
-______LT_____MS__(ui8, uint8_t, i16, int16_t, int32_t)
-______LT_____MS__(ui8, uint8_t, i32, int32_t, int32_t)
-______LT_____MS__(ui8, uint8_t, i64, int64_t, int32_t)
-______LT_____MS__(ui8, uint8_t, i8, int8_t, int32_t)
-______LT_____MS__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LT_____MS__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LT_____MS__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LT_____MS__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LT_____SM__(b, int32_t, b, int32_t, int32_t)
-______LT_____SM__(b, int32_t, c, double, int32_t)
-______LT_____SM__(b, int32_t, d, double, int32_t)
-______LT_____SM__(b, int32_t, i16, int16_t, int32_t)
-______LT_____SM__(b, int32_t, i32, int32_t, int32_t)
-______LT_____SM__(b, int32_t, i64, int64_t, int32_t)
-______LT_____SM__(b, int32_t, i8, int8_t, int32_t)
-______LT_____SM__(b, int32_t, ui16, uint16_t, int32_t)
-______LT_____SM__(b, int32_t, ui32, uint32_t, int32_t)
-______LT_____SM__(b, int32_t, ui64, uint64_t, int32_t)
-______LT_____SM__(b, int32_t, ui8, uint8_t, int32_t)
-______LT_____SM__(c, double, b, int32_t, int32_t)
-______LT_____SM__(c, double, c, double, int32_t)
-______LT_____SM__(c, double, d, double, int32_t)
-______LT_____SM__(c, double, i16, int16_t, int32_t)
-______LT_____SM__(c, double, i32, int32_t, int32_t)
-______LT_____SM__(c, double, i64, int64_t, int32_t)
-______LT_____SM__(c, double, i8, int8_t, int32_t)
-______LT_____SM__(c, double, ui16, uint16_t, int32_t)
-______LT_____SM__(c, double, ui32, uint32_t, int32_t)
-______LT_____SM__(c, double, ui64, uint64_t, int32_t)
-______LT_____SM__(c, double, ui8, uint8_t, int32_t)
-______LT_____SM__(d, double, b, int32_t, int32_t)
-______LT_____SM__(d, double, c, double, int32_t)
-______LT_____SM__(d, double, d, double, int32_t)
-______LT_____SM__(d, double, i16, int16_t, int32_t)
-______LT_____SM__(d, double, i32, int32_t, int32_t)
-______LT_____SM__(d, double, i64, int64_t, int32_t)
-______LT_____SM__(d, double, i8, int8_t, int32_t)
-______LT_____SM__(d, double, ui16, uint16_t, int32_t)
-______LT_____SM__(d, double, ui32, uint32_t, int32_t)
-______LT_____SM__(d, double, ui64, uint64_t, int32_t)
-______LT_____SM__(d, double, ui8, uint8_t, int32_t)
-______LT_____SM__(i16, int16_t, b, int32_t, int32_t)
-______LT_____SM__(i16, int16_t, c, double, int32_t)
-______LT_____SM__(i16, int16_t, d, double, int32_t)
-______LT_____SM__(i16, int16_t, i16, int16_t, int32_t)
-______LT_____SM__(i16, int16_t, i32, int32_t, int32_t)
-______LT_____SM__(i16, int16_t, i64, int64_t, int32_t)
-______LT_____SM__(i16, int16_t, i8, int8_t, int32_t)
-______LT_____SM__(i16, int16_t, ui16, uint16_t, int32_t)
-______LT_____SM__(i16, int16_t, ui32, uint32_t, int32_t)
-______LT_____SM__(i16, int16_t, ui64, uint64_t, int32_t)
-______LT_____SM__(i16, int16_t, ui8, uint8_t, int32_t)
-______LT_____SM__(i32, int32_t, b, int32_t, int32_t)
-______LT_____SM__(i32, int32_t, c, double, int32_t)
-______LT_____SM__(i32, int32_t, d, double, int32_t)
-______LT_____SM__(i32, int32_t, i16, int16_t, int32_t)
-______LT_____SM__(i32, int32_t, i32, int32_t, int32_t)
-______LT_____SM__(i32, int32_t, i64, int64_t, int32_t)
-______LT_____SM__(i32, int32_t, i8, int8_t, int32_t)
-______LT_____SM__(i32, int32_t, ui16, uint16_t, int32_t)
-______LT_____SM__(i32, int32_t, ui32, uint32_t, int32_t)
-______LT_____SM__(i32, int32_t, ui64, uint64_t, int32_t)
-______LT_____SM__(i32, int32_t, ui8, uint8_t, int32_t)
-______LT_____SM__(i64, int64_t, b, int32_t, int32_t)
-______LT_____SM__(i64, int64_t, c, double, int32_t)
-______LT_____SM__(i64, int64_t, d, double, int32_t)
-______LT_____SM__(i64, int64_t, i16, int16_t, int32_t)
-______LT_____SM__(i64, int64_t, i32, int32_t, int32_t)
-______LT_____SM__(i64, int64_t, i64, int64_t, int32_t)
-______LT_____SM__(i64, int64_t, i8, int8_t, int32_t)
-______LT_____SM__(i64, int64_t, ui16, uint16_t, int32_t)
-______LT_____SM__(i64, int64_t, ui32, uint32_t, int32_t)
-______LT_____SM__(i64, int64_t, ui64, uint64_t, int32_t)
-______LT_____SM__(i64, int64_t, ui8, uint8_t, int32_t)
-______LT_____SM__(i8, int8_t, b, int32_t, int32_t)
-______LT_____SM__(i8, int8_t, c, double, int32_t)
-______LT_____SM__(i8, int8_t, d, double, int32_t)
-______LT_____SM__(i8, int8_t, i16, int16_t, int32_t)
-______LT_____SM__(i8, int8_t, i32, int32_t, int32_t)
-______LT_____SM__(i8, int8_t, i64, int64_t, int32_t)
-______LT_____SM__(i8, int8_t, i8, int8_t, int32_t)
-______LT_____SM__(i8, int8_t, ui16, uint16_t, int32_t)
-______LT_____SM__(i8, int8_t, ui32, uint32_t, int32_t)
-______LT_____SM__(i8, int8_t, ui64, uint64_t, int32_t)
-______LT_____SM__(i8, int8_t, ui8, uint8_t, int32_t)
-______LT_____SM__(ui16, uint16_t, b, int32_t, int32_t)
-______LT_____SM__(ui16, uint16_t, c, double, int32_t)
-______LT_____SM__(ui16, uint16_t, d, double, int32_t)
-______LT_____SM__(ui16, uint16_t, i16, int16_t, int32_t)
-______LT_____SM__(ui16, uint16_t, i32, int32_t, int32_t)
-______LT_____SM__(ui16, uint16_t, i64, int64_t, int32_t)
-______LT_____SM__(ui16, uint16_t, i8, int8_t, int32_t)
-______LT_____SM__(ui16, uint16_t, ui16, uint16_t, int32_t)
-______LT_____SM__(ui16, uint16_t, ui32, uint32_t, int32_t)
-______LT_____SM__(ui16, uint16_t, ui64, uint64_t, int32_t)
-______LT_____SM__(ui16, uint16_t, ui8, uint8_t, int32_t)
-______LT_____SM__(ui32, uint32_t, b, int32_t, int32_t)
-______LT_____SM__(ui32, uint32_t, c, double, int32_t)
-______LT_____SM__(ui32, uint32_t, d, double, int32_t)
-______LT_____SM__(ui32, uint32_t, i16, int16_t, int32_t)
-______LT_____SM__(ui32, uint32_t, i32, int32_t, int32_t)
-______LT_____SM__(ui32, uint32_t, i64, int64_t, int32_t)
-______LT_____SM__(ui32, uint32_t, i8, int8_t, int32_t)
-______LT_____SM__(ui32, uint32_t, ui16, uint16_t, int32_t)
-______LT_____SM__(ui32, uint32_t, ui32, uint32_t, int32_t)
-______LT_____SM__(ui32, uint32_t, ui64, uint64_t, int32_t)
-______LT_____SM__(ui32, uint32_t, ui8, uint8_t, int32_t)
-______LT_____SM__(ui64, uint64_t, b, int32_t, int32_t)
-______LT_____SM__(ui64, uint64_t, c, double, int32_t)
-______LT_____SM__(ui64, uint64_t, d, double, int32_t)
-______LT_____SM__(ui64, uint64_t, i16, int16_t, int32_t)
-______LT_____SM__(ui64, uint64_t, i32, int32_t, int32_t)
-______LT_____SM__(ui64, uint64_t, i64, int64_t, int32_t)
-______LT_____SM__(ui64, uint64_t, i8, int8_t, int32_t)
-______LT_____SM__(ui64, uint64_t, ui16, uint16_t, int32_t)
-______LT_____SM__(ui64, uint64_t, ui32, uint32_t, int32_t)
-______LT_____SM__(ui64, uint64_t, ui64, uint64_t, int32_t)
-______LT_____SM__(ui64, uint64_t, ui8, uint8_t, int32_t)
-______LT_____SM__(ui8, uint8_t, b, int32_t, int32_t)
-______LT_____SM__(ui8, uint8_t, c, double, int32_t)
-______LT_____SM__(ui8, uint8_t, d, double, int32_t)
-______LT_____SM__(ui8, uint8_t, i16, int16_t, int32_t)
-______LT_____SM__(ui8, uint8_t, i32, int32_t, int32_t)
-______LT_____SM__(ui8, uint8_t, i64, int64_t, int32_t)
-______LT_____SM__(ui8, uint8_t, i8, int8_t, int32_t)
-______LT_____SM__(ui8, uint8_t, ui16, uint16_t, int32_t)
-______LT_____SM__(ui8, uint8_t, ui32, uint32_t, int32_t)
-______LT_____SM__(ui8, uint8_t, ui64, uint64_t, int32_t)
-______LT_____SM__(ui8, uint8_t, ui8, uint8_t, int32_t)
-______LT_____UU__(b, int32_t, b, int32_t, int32_t)
-______LT_____UU__(b, int32_t, c, double, int32_t)
-______LT_____UU__(b, int32_t, d, double, int32_t)
-______LT_____UU__(b, int32_t, i16, int16_t, int32_t)
-______LT_____UU__(b, int32_t, i32, int32_t, int32_t)
-______LT_____UU__(b, int32_t, i64, int64_t, int32_t)
-______LT_____UU__(b, int32_t, i8, int8_t, int32_t)
-______LT_____UU__(b, int32_t, ui16, uint16_t, int32_t)
-______LT_____UU__(b, int32_t, ui32, uint32_t, int32_t)
-______LT_____UU__(b, int32_t, ui64, uint64_t, int32_t)
-______LT_____UU__(b, int32_t, ui8, uint8_t, int32_t)
-______LT_____UU__(c, double, b, int32_t, int32_t)
-______LT_____UU__(c, double, c, double, int32_t)
-______LT_____UU__(c, double, d, double, int32_t)
-______LT_____UU__(c, double, i16, int16_t, int32_t)
-______LT_____UU__(c, double, i32, int32_t, int32_t)
-______LT_____UU__(c, double, i64, int64_t, int32_t)
-______LT_____UU__(c, double, i8, int8_t, int32_t)
-______LT_____UU__(c, double, ui16, uint16_t, int32_t)
-______LT_____UU__(c, double, ui32, uint32_t, int32_t)
-______LT_____UU__(c, double, ui64, uint64_t, int32_t)
-______LT_____UU__(c, double, ui8, uint8_t, int32_t)
-______LT_____UU__(d, double, b, int32_t, int32_t)
-______LT_____UU__(d, double, c, double, int32_t)
-______LT_____UU__(d, double, d, double, int32_t)
-______LT_____UU__(d, double, i16, int16_t, int32_t)
-______LT_____UU__(d, double, i32, int32_t, int32_t)
-______LT_____UU__(d, double, i64, int64_t, int32_t)
-______LT_____UU__(d, double, i8, int8_t, int32_t)
-______LT_____UU__(d, double, ui16, uint16_t, int32_t)
-______LT_____UU__(d, double, ui32, uint32_t, int32_t)
-______LT_____UU__(d, double, ui64, uint64_t, int32_t)
-______LT_____UU__(d, double, ui8, uint8_t, int32_t)
-______LT_____UU__(i16, int16_t, b, int32_t, int32_t)
-______LT_____UU__(i16, int16_t, c, double, int32_t)
-______LT_____UU__(i16, int16_t, d, double, int32_t)
-______LT_____UU__(i16, int16_t, i16, int16_t, int32_t)
-______LT_____UU__(i16, int16_t, i32, int32_t, int32_t)
-______LT_____UU__(i16, int16_t, i64, int64_t, int32_t)
-______LT_____UU__(i16, int16_t, i8, int8_t, int32_t)
-______LT_____UU__(i16, int16_t, ui16, uint16_t, int32_t)
-______LT_____UU__(i16, int16_t, ui32, uint32_t, int32_t)
-______LT_____UU__(i16, int16_t, ui64, uint64_t, int32_t)
-______LT_____UU__(i16, int16_t, ui8, uint8_t, int32_t)
-______LT_____UU__(i32, int32_t, b, int32_t, int32_t)
-______LT_____UU__(i32, int32_t, c, double, int32_t)
-______LT_____UU__(i32, int32_t, d, double, int32_t)
-______LT_____UU__(i32, int32_t, i16, int16_t, int32_t)
-______LT