ifdef HAVE_INT128

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

diff --git a/src/calc/cmp.h b/src/calc/cmp.h
index 8fac2f3291fc4908dfcd9f185fa1c50ba463f387..5eaa648cfe98245b986efe4be171cb5bf0daed49 100644 (file)
--- a/src/calc/cmp.h
+++ b/src/calc/cmp.h
@@ -57,6 +57,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 +112,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 +167,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 +222,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 +277,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 +332,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 +387,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 +442,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 +471,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 +613,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 +668,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 +724,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 +791,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 +846,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 +901,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 +956,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 +1011,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 +1066,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 +1121,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 +1176,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 +1205,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 +1261,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 +1319,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 +1525,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 +1580,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 +1635,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 +1690,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 +1745,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 +1800,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 +1855,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 +1910,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 +1939,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 +2081,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 +2136,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 +2192,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 +2259,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 +2314,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 +2369,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 +2424,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 +2479,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 +2534,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 +2589,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 +2644,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 +2673,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 +2815,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 +2870,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 +2926,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 +2993,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 +3048,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 +3103,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 +3158,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 +3196,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 +3352,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 +3407,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 +3463,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 +3521,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 +3549,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 +3604,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 +3660,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 +3727,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 +3782,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 +3837,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 +3892,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 +3947,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 +4002,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 +4057,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 +4112,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 +4141,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 +4283,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 +4338,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 +4394,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;