flush

[m6w6/ext-psi] / src / calc / cmp.h

diff --git a/src/calc/cmp.h b/src/calc/cmp.h
index 8fac2f3291fc4908dfcd9f185fa1c50ba463f387..6bb67de192d8457c26fe32fa7ceda8fd2135fe81 100644 (file)
--- a/src/calc/cmp.h
+++ b/src/calc/cmp.h
@@ -23,7 +23,6 @@
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/
 
-#include "php_psi_stdinc.h"
 #include <assert.h>
 
 #include "token.h"
@@ -57,6 +56,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 == v2->fval;
                        break;
@@ -100,6 +111,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 == v2->fval;
                        break;
@@ -143,6 +166,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 == v2->fval;
                        break;
@@ -186,6 +221,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 == v2->fval;
                        break;
@@ -229,6 +276,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i32 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i32 == v2->fval;
                        break;
@@ -272,6 +331,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u32 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u32 == v2->fval;
                        break;
@@ -315,6 +386,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i64 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i64 == v2->fval;
                        break;
@@ -358,6 +441,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u64 == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u64 == v2->fval;
                        break;
@@ -375,6 +470,122 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
+#if HAVE_INT128
+       case PSI_T_INT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->i128 == v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->i128 == v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->i128 == v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->i128 == v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->i128 == v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->i128 == v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->i128 == v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->i128 == v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 == v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->i128 == v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->i128 == v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->i128 == v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->u128 == v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->u128 == v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->u128 == v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->u128 == v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->u128 == v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->u128 == v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->u128 == v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->u128 == v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 == v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->u128 == v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->u128 == v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->u128 == v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
        case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
@@ -401,6 +612,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->fval == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->fval == v2->fval;
                        break;
@@ -444,6 +667,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->dval == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->dval == v2->fval;
                        break;
@@ -488,6 +723,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->ldval == v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval == v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval == v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->ldval == v2->fval;
                        break;
@@ -543,6 +790,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 != v2->fval;
                        break;
@@ -586,6 +845,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 != v2->fval;
                        break;
@@ -629,6 +900,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 != v2->fval;
                        break;
@@ -672,6 +955,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 != v2->fval;
                        break;
@@ -715,6 +1010,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i32 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i32 != v2->fval;
                        break;
@@ -758,6 +1065,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u32 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u32 != v2->fval;
                        break;
@@ -801,6 +1120,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i64 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i64 != v2->fval;
                        break;
@@ -844,6 +1175,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u64 != v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 != v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u64 != v2->fval;
                        break;
@@ -861,41 +1204,54 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-       case PSI_T_FLOAT:
+#if HAVE_INT128
+       case PSI_T_INT128:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->fval != v2->i8;
+                       res->u8 = v1->i128 != v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->fval != v2->u8;
+                       res->u8 = v1->i128 != v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->fval != v2->i16;
+                       res->u8 = v1->i128 != v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->fval != v2->u16;
+                       res->u8 = v1->i128 != v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->fval != v2->i32;
+                       res->u8 = v1->i128 != v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->fval != v2->u32;
+                       res->u8 = v1->i128 != v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->fval != v2->i64;
+                       res->u8 = v1->i128 != v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->fval != v2->u64;
+                       res->u8 = v1->i128 != v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 != v2->u128;
                        break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->fval != v2->fval;
+                       res->u8 = v1->i128 != v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->fval != v2->dval;
+                       res->u8 = v1->i128 != v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->fval != v2->ldval;
+                       res->u8 = v1->i128 != v2->ldval;
                        break;
 #      endif
 
@@ -904,41 +1260,56 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-       case PSI_T_DOUBLE:
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->dval != v2->i8;
+                       res->u8 = v1->u128 != v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->dval != v2->u8;
+                       res->u8 = v1->u128 != v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->dval != v2->i16;
+                       res->u8 = v1->u128 != v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->dval != v2->u16;
+                       res->u8 = v1->u128 != v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->dval != v2->i32;
+                       res->u8 = v1->u128 != v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->dval != v2->u32;
+                       res->u8 = v1->u128 != v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->dval != v2->i64;
+                       res->u8 = v1->u128 != v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->dval != v2->u64;
+                       res->u8 = v1->u128 != v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 != v2->u128;
                        break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->dval != v2->fval;
+                       res->u8 = v1->u128 != v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->dval != v2->dval;
+                       res->u8 = v1->u128 != v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->dval != v2->ldval;
+                       res->u8 = v1->u128 != v2->ldval;
                        break;
 #      endif
 
@@ -947,38 +1318,162 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-#if HAVE_LONG_DOUBLE
-       case PSI_T_LONG_DOUBLE:
+#endif
+
+       case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->ldval != v2->i8;
+                       res->u8 = v1->fval != v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->ldval != v2->u8;
+                       res->u8 = v1->fval != v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->ldval != v2->i16;
+                       res->u8 = v1->fval != v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->ldval != v2->u16;
+                       res->u8 = v1->fval != v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->ldval != v2->i32;
+                       res->u8 = v1->fval != v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->ldval != v2->u32;
+                       res->u8 = v1->fval != v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->ldval != v2->i64;
+                       res->u8 = v1->fval != v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->ldval != v2->u64;
-                       break;
-               case PSI_T_FLOAT:
-                       res->u8 = v1->ldval != v2->fval;
+                       res->u8 = v1->fval != v2->u64;
                        break;
-               case PSI_T_DOUBLE:
-                       res->u8 = v1->ldval != v2->dval;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval != v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->fval != v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->fval != v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->fval != v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+       case PSI_T_DOUBLE:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->dval != v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->dval != v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->dval != v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->dval != v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->dval != v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->dval != v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->dval != v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->dval != v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval != v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->dval != v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->dval != v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->dval != v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#if HAVE_LONG_DOUBLE
+       case PSI_T_LONG_DOUBLE:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->ldval != v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->ldval != v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->ldval != v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->ldval != v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->ldval != v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->ldval != v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->ldval != v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->ldval != v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval != v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval != v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->ldval != v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->ldval != v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
@@ -1029,6 +1524,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 < v2->fval;
                        break;
@@ -1072,6 +1579,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 < v2->fval;
                        break;
@@ -1115,6 +1634,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 < v2->fval;
                        break;
@@ -1158,6 +1689,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 < v2->fval;
                        break;
@@ -1201,6 +1744,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i32 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i32 < v2->fval;
                        break;
@@ -1244,6 +1799,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u32 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u32 < v2->fval;
                        break;
@@ -1287,6 +1854,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i64 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i64 < v2->fval;
                        break;
@@ -1330,6 +1909,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u64 < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u64 < v2->fval;
                        break;
@@ -1347,6 +1938,122 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
+#if HAVE_INT128
+       case PSI_T_INT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->i128 < v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->i128 < v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->i128 < v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->i128 < v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->i128 < v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->i128 < v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->i128 < v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->i128 < v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 < v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->i128 < v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->i128 < v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->i128 < v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->u128 < v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->u128 < v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->u128 < v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->u128 < v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->u128 < v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->u128 < v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->u128 < v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->u128 < v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 < v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->u128 < v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->u128 < v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->u128 < v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
        case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
@@ -1373,6 +2080,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->fval < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->fval < v2->fval;
                        break;
@@ -1416,6 +2135,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->dval < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->dval < v2->fval;
                        break;
@@ -1460,6 +2191,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->ldval < v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval < v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval < v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->ldval < v2->fval;
                        break;
@@ -1515,6 +2258,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 > v2->fval;
                        break;
@@ -1558,6 +2313,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 > v2->fval;
                        break;
@@ -1601,6 +2368,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 > v2->fval;
                        break;
@@ -1644,6 +2423,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 > v2->fval;
                        break;
@@ -1687,6 +2478,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i32 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i32 > v2->fval;
                        break;
@@ -1730,6 +2533,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u32 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u32 > v2->fval;
                        break;
@@ -1773,6 +2588,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i64 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i64 > v2->fval;
                        break;
@@ -1816,6 +2643,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u64 > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u64 > v2->fval;
                        break;
@@ -1833,6 +2672,122 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
+#if HAVE_INT128
+       case PSI_T_INT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->i128 > v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->i128 > v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->i128 > v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->i128 > v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->i128 > v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->i128 > v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->i128 > v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->i128 > v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 > v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->i128 > v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->i128 > v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->i128 > v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->u128 > v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->u128 > v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->u128 > v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->u128 > v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->u128 > v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->u128 > v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->u128 > v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->u128 > v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 > v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->u128 > v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->u128 > v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->u128 > v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
        case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
@@ -1859,6 +2814,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->fval > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->fval > v2->fval;
                        break;
@@ -1902,6 +2869,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->dval > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->dval > v2->fval;
                        break;
@@ -1946,6 +2925,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->ldval > v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval > v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval > v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->ldval > v2->fval;
                        break;
@@ -2001,6 +2992,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 <= v2->fval;
                        break;
@@ -2044,6 +3047,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 <= v2->fval;
                        break;
@@ -2087,6 +3102,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 <= v2->fval;
                        break;
@@ -2130,6 +3157,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 <= v2->fval;
                        break;
@@ -2156,32 +3195,154 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                        res->u8 = v1->i32 <= v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->i32 <= v2->i16;
+                       res->u8 = v1->i32 <= v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->i32 <= v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->i32 <= v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->i32 <= v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->i32 <= v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->i32 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 <= v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->i32 <= v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->i32 <= v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->i32 <= v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+       case PSI_T_UINT32:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->u32 <= v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->u32 <= v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->u32 <= v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->u32 <= v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->u32 <= v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->u32 <= v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->u32 <= v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->u32 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 <= v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->u32 <= v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->u32 <= v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->u32 <= v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+       case PSI_T_INT64:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->i64 <= v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->i64 <= v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->i64 <= v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->i32 <= v2->u16;
+                       res->u8 = v1->i64 <= v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->i32 <= v2->i32;
+                       res->u8 = v1->i64 <= v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->i32 <= v2->u32;
+                       res->u8 = v1->i64 <= v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->i32 <= v2->i64;
+                       res->u8 = v1->i64 <= v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->i32 <= v2->u64;
+                       res->u8 = v1->i64 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 <= v2->u128;
                        break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->i32 <= v2->fval;
+                       res->u8 = v1->i64 <= v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->i32 <= v2->dval;
+                       res->u8 = v1->i64 <= v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->i32 <= v2->ldval;
+                       res->u8 = v1->i64 <= v2->ldval;
                        break;
 #      endif
 
@@ -2190,41 +3351,53 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-       case PSI_T_UINT32:
+       case PSI_T_UINT64:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->u32 <= v2->i8;
+                       res->u8 = v1->u64 <= v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->u32 <= v2->u8;
+                       res->u8 = v1->u64 <= v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->u32 <= v2->i16;
+                       res->u8 = v1->u64 <= v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->u32 <= v2->u16;
+                       res->u8 = v1->u64 <= v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->u32 <= v2->i32;
+                       res->u8 = v1->u64 <= v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->u32 <= v2->u32;
+                       res->u8 = v1->u64 <= v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->u32 <= v2->i64;
+                       res->u8 = v1->u64 <= v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->u32 <= v2->u64;
+                       res->u8 = v1->u64 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 <= v2->u128;
                        break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->u32 <= v2->fval;
+                       res->u8 = v1->u64 <= v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->u32 <= v2->dval;
+                       res->u8 = v1->u64 <= v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->u32 <= v2->ldval;
+                       res->u8 = v1->u64 <= v2->ldval;
                        break;
 #      endif
 
@@ -2233,41 +3406,54 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-       case PSI_T_INT64:
+#if HAVE_INT128
+       case PSI_T_INT128:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->i64 <= v2->i8;
+                       res->u8 = v1->i128 <= v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->i64 <= v2->u8;
+                       res->u8 = v1->i128 <= v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->i64 <= v2->i16;
+                       res->u8 = v1->i128 <= v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->i64 <= v2->u16;
+                       res->u8 = v1->i128 <= v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->i64 <= v2->i32;
+                       res->u8 = v1->i128 <= v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->i64 <= v2->u32;
+                       res->u8 = v1->i128 <= v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->i64 <= v2->i64;
+                       res->u8 = v1->i128 <= v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->i64 <= v2->u64;
+                       res->u8 = v1->i128 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 <= v2->i128;
                        break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->i64 <= v2->fval;
+                       res->u8 = v1->i128 <= v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->i64 <= v2->dval;
+                       res->u8 = v1->i128 <= v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->i64 <= v2->ldval;
+                       res->u8 = v1->i128 <= v2->ldval;
                        break;
 #      endif
 
@@ -2276,41 +3462,56 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
-       case PSI_T_UINT64:
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
                switch (t2) {
                case PSI_T_INT8:
-                       res->u8 = v1->u64 <= v2->i8;
+                       res->u8 = v1->u128 <= v2->i8;
                        break;
                case PSI_T_UINT8:
-                       res->u8 = v1->u64 <= v2->u8;
+                       res->u8 = v1->u128 <= v2->u8;
                        break;
                case PSI_T_INT16:
-                       res->u8 = v1->u64 <= v2->i16;
+                       res->u8 = v1->u128 <= v2->i16;
                        break;
                case PSI_T_UINT16:
-                       res->u8 = v1->u64 <= v2->u16;
+                       res->u8 = v1->u128 <= v2->u16;
                        break;
                case PSI_T_INT32:
-                       res->u8 = v1->u64 <= v2->i32;
+                       res->u8 = v1->u128 <= v2->i32;
                        break;
                case PSI_T_UINT32:
-                       res->u8 = v1->u64 <= v2->u32;
+                       res->u8 = v1->u128 <= v2->u32;
                        break;
                case PSI_T_INT64:
-                       res->u8 = v1->u64 <= v2->i64;
+                       res->u8 = v1->u128 <= v2->i64;
                        break;
                case PSI_T_UINT64:
-                       res->u8 = v1->u64 <= v2->u64;
+                       res->u8 = v1->u128 <= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 <= v2->i128;
                        break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
-                       res->u8 = v1->u64 <= v2->fval;
+                       res->u8 = v1->u128 <= v2->fval;
                        break;
                case PSI_T_DOUBLE:
-                       res->u8 = v1->u64 <= v2->dval;
+                       res->u8 = v1->u128 <= v2->dval;
                        break;
 #      if HAVE_LONG_DOUBLE
                case PSI_T_LONG_DOUBLE:
-                       res->u8 = v1->u64 <= v2->ldval;
+                       res->u8 = v1->u128 <= v2->ldval;
                        break;
 #      endif
 
@@ -2319,6 +3520,8 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
+#endif
+
        case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
@@ -2345,6 +3548,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->fval <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->fval <= v2->fval;
                        break;
@@ -2388,6 +3603,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->dval <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->dval <= v2->fval;
                        break;
@@ -2432,6 +3659,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->ldval <= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval <= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval <= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->ldval <= v2->fval;
                        break;
@@ -2487,6 +3726,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i8 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i8 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i8 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i8 >= v2->fval;
                        break;
@@ -2530,6 +3781,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u8 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u8 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u8 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u8 >= v2->fval;
                        break;
@@ -2573,6 +3836,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i16 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i16 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i16 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i16 >= v2->fval;
                        break;
@@ -2616,6 +3891,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u16 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u16 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u16 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u16 >= v2->fval;
                        break;
@@ -2659,6 +3946,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i32 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i32 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i32 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i32 >= v2->fval;
                        break;
@@ -2702,6 +4001,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u32 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u32 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u32 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u32 >= v2->fval;
                        break;
@@ -2745,6 +4056,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->i64 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i64 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i64 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->i64 >= v2->fval;
                        break;
@@ -2788,6 +4111,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->u64 >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u64 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u64 >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->u64 >= v2->fval;
                        break;
@@ -2805,6 +4140,122 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                        break;
                }
                break;
+#if HAVE_INT128
+       case PSI_T_INT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->i128 >= v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->i128 >= v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->i128 >= v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->i128 >= v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->i128 >= v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->i128 >= v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->i128 >= v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->i128 >= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->i128 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->i128 >= v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->i128 >= v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->i128 >= v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->i128 >= v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
+#if HAVE_UINT128
+       case PSI_T_UINT128:
+               switch (t2) {
+               case PSI_T_INT8:
+                       res->u8 = v1->u128 >= v2->i8;
+                       break;
+               case PSI_T_UINT8:
+                       res->u8 = v1->u128 >= v2->u8;
+                       break;
+               case PSI_T_INT16:
+                       res->u8 = v1->u128 >= v2->i16;
+                       break;
+               case PSI_T_UINT16:
+                       res->u8 = v1->u128 >= v2->u16;
+                       break;
+               case PSI_T_INT32:
+                       res->u8 = v1->u128 >= v2->i32;
+                       break;
+               case PSI_T_UINT32:
+                       res->u8 = v1->u128 >= v2->u32;
+                       break;
+               case PSI_T_INT64:
+                       res->u8 = v1->u128 >= v2->i64;
+                       break;
+               case PSI_T_UINT64:
+                       res->u8 = v1->u128 >= v2->u64;
+                       break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->u128 >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->u128 >= v2->u128;
+                       break;
+#      endif
+
+               case PSI_T_FLOAT:
+                       res->u8 = v1->u128 >= v2->fval;
+                       break;
+               case PSI_T_DOUBLE:
+                       res->u8 = v1->u128 >= v2->dval;
+                       break;
+#      if HAVE_LONG_DOUBLE
+               case PSI_T_LONG_DOUBLE:
+                       res->u8 = v1->u128 >= v2->ldval;
+                       break;
+#      endif
+
+               default:
+                       assert(0);
+                       break;
+               }
+               break;
+#endif
+
        case PSI_T_FLOAT:
                switch (t2) {
                case PSI_T_INT8:
@@ -2831,6 +4282,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->fval >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->fval >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->fval >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->fval >= v2->fval;
                        break;
@@ -2874,6 +4337,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->dval >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->dval >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->dval >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->dval >= v2->fval;
                        break;
@@ -2918,6 +4393,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl
                case PSI_T_UINT64:
                        res->u8 = v1->ldval >= v2->u64;
                        break;
+#      if HAVE_INT128
+               case PSI_T_INT128:
+                       res->u8 = v1->ldval >= v2->i128;
+                       break;
+#      endif
+
+#      if HAVE_UINT128
+               case PSI_T_UINT128:
+                       res->u8 = v1->ldval >= v2->u128;
+                       break;
+#      endif
+
                case PSI_T_FLOAT:
                        res->u8 = v1->ldval >= v2->fval;
                        break;