kc3-lang/kc3

diff --git a/README.md b/README.md
index 71b9d54..c944001 100644
--- a/README.md
+++ b/README.md
@@ -68,6 +68,9 @@ Support for large integers provided by
 Support for C function calls provided by
 [libffi](https://github.com/libffi/libffi).
 
+Modules are saved as facts databases.
+
+
 #### Parser
 
 The parser is recursive descent.
diff --git a/lib/c3/0.1/array.facts b/lib/c3/0.1/array.facts
new file mode 100644
index 0000000..57fb4ef
--- /dev/null
+++ b/lib/c3/0.1/array.facts
@@ -0,0 +1,7 @@
+%{module: C3.Facts.Dump,
+  version: 1}
+add {Array, :is_a, :module}
+add {Array, :name, "Array"}
+add {Array, :path, "array.facts"}
+add {Array, :symbol, Array.data}
+add {Array.data, :cfn, cfn :tag "array_data_tag" (:tag, :tag, :&result)}
diff --git a/libc3/array.c b/libc3/array.c
index cbb4720..4bab9d0 100644
--- a/libc3/array.c
+++ b/libc3/array.c
@@ -70,6 +70,23 @@ void * array_data (const s_array *a, const uw *address)
   return (s8 *) a->data + offset;
 }
 
+s_tag * array_data_tag (s_tag *a, s_tag *address, s_tag *dest)
+{
+  void *a_data;
+  void *dest_data;
+  sw size;
+  assert(a->type == TAG_ARRAY);
+  assert(address->type == TAG_ARRAY);
+  a_data = array_data(&a->data.array,
+                      address->data.array.data);
+  tag_init(dest);
+  dest->type = a->data.array.type;
+  dest_data = tag_to_pointer(dest, dest->type);
+  size = tag_type_size(dest->type);
+  memcpy(dest_data, a_data, size);
+  return dest;
+}
+
 s_array * array_init (s_array *a, e_tag_type type, uw dimension,
                       const uw *dimensions)
 {
diff --git a/libc3/array.h b/libc3/array.h
index a480103..b36ffe7 100644
--- a/libc3/array.h
+++ b/libc3/array.h
@@ -21,5 +21,6 @@ s_array * array_init (s_array *a, e_tag_type type, uw dimension,
                       const uw *dimensions);
 s_array * array_init_1 (s_array *a, s8 *p);
 void *    array_data (const s_array *a, const uw *address);
+s_tag *   array_data_tag (s_tag *a, s_tag *address, s_tag *dest);
 
 #endif /* ARRAY_H */
diff --git a/libc3/buf_inspect.c b/libc3/buf_inspect.c
index 1a6e950..8235e6a 100644
--- a/libc3/buf_inspect.c
+++ b/libc3/buf_inspect.c
@@ -1430,6 +1430,7 @@ sw buf_inspect_tag (s_buf *buf, const s_tag *tag)
   case TAG_S16:     return buf_inspect_s16(buf, &tag->data.s16);
   case TAG_S32:     return buf_inspect_s32(buf, &tag->data.s32);
   case TAG_S64:     return buf_inspect_s64(buf, &tag->data.s64);
+  case TAG_SW:      return buf_inspect_sw(buf, &tag->data.sw);
   case TAG_STR:     return buf_inspect_str(buf, &tag->data.str);
   case TAG_SYM:     return buf_inspect_sym(buf, tag->data.sym);
   case TAG_TUPLE:   return buf_inspect_tuple(buf, &tag->data.tuple);
@@ -1437,6 +1438,7 @@ sw buf_inspect_tag (s_buf *buf, const s_tag *tag)
   case TAG_U16:     return buf_inspect_u16(buf, &tag->data.u16);
   case TAG_U32:     return buf_inspect_u32(buf, &tag->data.u32);
   case TAG_U64:     return buf_inspect_u64(buf, &tag->data.u64);
+  case TAG_UW:      return buf_inspect_uw(buf, &tag->data.uw);
   case TAG_VAR:     return buf_inspect_var(buf, tag);
   }
   assert(! "buf_inspect_tag: unknown tag type");
@@ -1471,6 +1473,7 @@ sw buf_inspect_tag_size (const s_tag *tag)
   case TAG_S16:      return buf_inspect_s16_size(&tag->data.s16);
   case TAG_S32:      return buf_inspect_s32_size(&tag->data.s32);
   case TAG_S64:      return buf_inspect_s64_size(&tag->data.s64);
+  case TAG_SW:       return buf_inspect_sw_size(&tag->data.sw);
   case TAG_STR:      return buf_inspect_str_size(&tag->data.str);
   case TAG_SYM:      return buf_inspect_sym_size(tag->data.sym);
   case TAG_TUPLE:    return buf_inspect_tuple_size(&tag->data.tuple);
@@ -1478,6 +1481,7 @@ sw buf_inspect_tag_size (const s_tag *tag)
   case TAG_U16:      return buf_inspect_u16_size(&tag->data.u16);
   case TAG_U32:      return buf_inspect_u32_size(&tag->data.u32);
   case TAG_U64:      return buf_inspect_u64_size(&tag->data.u64);
+  case TAG_UW:       return buf_inspect_uw_size(&tag->data.uw);
   case TAG_VAR:      return buf_inspect_var_size(tag);
   }
   assert(! "buf_inspect_tag_size: unknown tag type");
@@ -1526,6 +1530,8 @@ sw buf_inspect_tag_type (s_buf *buf, e_tag_type type)
     return buf_write_1(buf, "s32");
   case TAG_S64:
     return buf_write_1(buf, "s64");
+  case TAG_SW:
+    return buf_write_1(buf, "sw");
   case TAG_STR:
     return buf_write_1(buf, "str");
   case TAG_SYM:
@@ -1540,6 +1546,8 @@ sw buf_inspect_tag_type (s_buf *buf, e_tag_type type)
     return buf_write_1(buf, "u32");
   case TAG_U64:
     return buf_write_1(buf, "u64");
+  case TAG_UW:
+    return buf_write_1(buf, "uw");
   case TAG_VAR:
     return buf_write_1(buf, "var");
   }
@@ -1589,6 +1597,8 @@ sw buf_inspect_tag_type_size (e_tag_type type)
     return strlen("s32");
   case TAG_S64:
     return strlen("s64");
+  case TAG_SW:
+    return strlen("sw");
   case TAG_STR:
     return strlen("str");
   case TAG_SYM:
@@ -1603,6 +1613,8 @@ sw buf_inspect_tag_type_size (e_tag_type type)
     return strlen("u32");
   case TAG_U64:
     return strlen("u64");
+  case TAG_UW:
+    return strlen("uw");
   case TAG_VAR:
     return strlen("var");
   }
diff --git a/libc3/buf_parse.c b/libc3/buf_parse.c
index 025948f..007d5b4 100644
--- a/libc3/buf_parse.c
+++ b/libc3/buf_parse.c
@@ -405,6 +405,65 @@ sw buf_parse_bool (s_buf *buf, bool *p)
   return r;
 }
 
+sw buf_parse_brackets (s_buf *buf, s_call *dest)
+{
+  s_tag *arg_dimensions;
+  uw d;
+  uw dimension = 0;
+  s_list *dimensions = NULL;
+  s_list **dimensions_last = &dimensions;
+  sw r;
+  sw result = 0;
+  s_buf_save save;
+  s_call tmp;
+  assert(buf);
+  assert(dest);
+  buf_save_init(buf, &save);
+  call_init(&tmp);
+  ident_init(&tmp.ident, sym_1("Array"), sym_1("data"));
+  tmp.arguments = list_new(NULL, list_new(NULL, NULL));
+  arg_dimensions = &(list_next(tmp.arguments)->tag);
+  if ((r = buf_parse_tag(buf, &tmp.arguments->tag)) < 0)
+    goto restore;
+  result += r;
+  while (1) {
+    if ((r = buf_ignore_spaces(buf)) < 0)
+      goto restore;
+    result += r;
+    if ((r = buf_read_1(buf, "[")) < 0)
+      goto restore;
+    if (! r)
+      break;
+    result += r;
+    if ((r = buf_ignore_spaces(buf)) < 0)
+      goto restore;
+    result += r;
+    if ((r = buf_parse_uw(buf, &d)) <= 0)
+      goto restore;
+    result += r;
+    if ((r = buf_ignore_spaces(buf)) < 0)
+      goto restore;
+    result += r;
+    if ((r = buf_read_1(buf, "]")) <= 0)
+      goto restore;
+    result += r;
+    *dimensions_last = list_new(NULL, NULL);
+    tag_init_uw(&(*dimensions_last)->tag, d);
+    dimensions_last = &(*dimensions_last)->next.data.list;
+    dimension++;
+  }
+  arg_dimensions->type = TAG_ARRAY;
+  list_to_array(dimensions, TAG_UW, &arg_dimensions->data.array);
+  *dest = tmp;
+  r = result;
+  goto clean;
+ restore:
+  buf_save_restore_rpos(buf, &save);
+ clean:
+  buf_save_clean(buf, &save);
+  return r;
+}
+
 sw buf_parse_call (s_buf *buf, s_call *dest)
 {
   sw r;
diff --git a/libc3/cfn.c b/libc3/cfn.c
index 28c2bc7..7b92042 100644
--- a/libc3/cfn.c
+++ b/libc3/cfn.c
@@ -155,8 +155,10 @@ s_cfn * cfn_init (s_cfn *cfn, const s_sym *name, s_list *arg_types,
 s_cfn * cfn_link (s_cfn *cfn)
 {
   assert(cfn);
-  if (! (cfn->ptr.p = dlsym(RTLD_DEFAULT, cfn->name->str.ptr.ps8)))
+  if (! (cfn->ptr.p = dlsym(RTLD_DEFAULT, cfn->name->str.ptr.ps8))) {
     warnx("cfn_link: %s: %s", cfn->name->str.ptr.ps8, dlerror());
+    return NULL;
+  }
   return cfn;
 }
 
diff --git a/libc3/compare.c b/libc3/compare.c
index 3b59111..5a5b34f 100644
--- a/libc3/compare.c
+++ b/libc3/compare.c
@@ -14,6 +14,7 @@
 #include <err.h>
 #include <string.h>
 #include "compare.h"
+#include "integer.h"
 #include "list.h"
 #include "tag.h"
 
@@ -314,6 +315,8 @@ COMPARE_DEF(s32)
 
 COMPARE_DEF(s64)
 
+COMPARE_DEF(sw)
+
 s8 compare_s64_u64 (s64 a, u64 b)
 {
   if (b >= 0x8000000000000000)
@@ -356,6 +359,9 @@ s8 compare_sym (const s_sym *a, const s_sym *b)
 }
 
 s8 compare_tag (const s_tag *a, const s_tag *b) {
+  s8 r;
+  s_integer tmp;
+  s_integer tmp2;
   if (a == b)
     return 0;
   if (!a ||
@@ -366,6 +372,375 @@ s8 compare_tag (const s_tag *a, const s_tag *b) {
       a == TAG_LAST ||
       b == TAG_FIRST)
     return 1;
+  switch (a->type) {
+  case TAG_F32:
+    switch (b->type) {
+    case TAG_F32: return compare_f32(a->data.f32, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.f32, b->data.f64);
+    case TAG_INTEGER:
+      return compare_f64((f64) a->data.f32,
+                         integer_to_f64(&b->data.integer));
+    case TAG_S8:  return compare_f32(a->data.f32, (f32) b->data.s8);
+    case TAG_S16: return compare_f32(a->data.f32, (f32) b->data.s16);
+    case TAG_S32: return compare_f32(a->data.f32, (f32) b->data.s32);
+    case TAG_S64: return compare_f32(a->data.f32, (f32) b->data.s64);
+    case TAG_SW:  return compare_f32(a->data.f32, (f32) b->data.sw);
+    case TAG_U8:  return compare_f32(a->data.f32, (f32) b->data.u8);
+    case TAG_U16: return compare_f32(a->data.f32, (f32) b->data.u16);
+    case TAG_U32: return compare_f32(a->data.f32, (f32) b->data.u32);
+    case TAG_U64: return compare_f32(a->data.f32, (f32) b->data.u64);
+    case TAG_UW:  return compare_f32(a->data.f32, (f32) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  case TAG_F64:
+    switch (b->type) {
+    case TAG_F32: return compare_f64(a->data.f64, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.f64, b->data.f64);
+    case TAG_INTEGER:
+      return compare_f64(a->data.f64, integer_to_f64(&b->data.integer));
+    case TAG_S8:  return compare_f64(a->data.f64, (f64) b->data.s8);
+    case TAG_S16: return compare_f64(a->data.f64, (f64) b->data.s16);
+    case TAG_S32: return compare_f64(a->data.f64, (f64) b->data.s32);
+    case TAG_S64: return compare_f64(a->data.f64, (f64) b->data.s64);
+    case TAG_SW:  return compare_f64(a->data.f64, (f64) b->data.sw);
+    case TAG_U8:  return compare_f64(a->data.f64, (f64) b->data.u8);
+    case TAG_U16: return compare_f64(a->data.f64, (f64) b->data.u16);
+    case TAG_U32: return compare_f64(a->data.f64, (f64) b->data.u32);
+    case TAG_U64: return compare_f64(a->data.f64, (f64) b->data.u64);
+    case TAG_UW:  return compare_f64(a->data.f64, (f64) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  case TAG_INTEGER:
+    switch (b->type) {
+    case TAG_F32: return compare_f64(integer_to_f64(&a->data.integer),
+                                     (f64) b->data.f32);
+    case TAG_F64: return compare_f64(integer_to_f64(&a->data.integer),
+                                     b->data.f64);
+    case TAG_INTEGER:
+      return compare_integer(&a->data.integer, &b->data.integer);
+    case TAG_S8:
+      integer_init_s8(&tmp, b->data.s8);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S16:
+      integer_init_s16(&tmp, b->data.s16);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S32:
+      integer_init_s32(&tmp, b->data.s32);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S64:
+      integer_init_s64(&tmp, b->data.s64);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_SW:
+      integer_init_sw(&tmp, b->data.sw);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_U8:
+      integer_init_u8(&tmp, b->data.u8);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_U16:
+      integer_init_u16(&tmp, b->data.u16);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_U32:
+      integer_init_u32(&tmp, b->data.u32);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_U64:
+      integer_init_u64(&tmp, b->data.u64);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    case TAG_UW:
+      integer_init_uw(&tmp, b->data.uw);
+      r = compare_integer(&a->data.integer, &tmp);
+      integer_clean(&tmp);
+      return r;
+    default:
+      break;
+    }
+    break;
+  case TAG_S8:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.s8, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.s8, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_s8(&tmp, a->data.s8);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s8(a->data.s8, b->data.s8);
+    case TAG_S16: return compare_s16((s16) a->data.s8, b->data.s16);
+    case TAG_S32: return compare_s32((s32) a->data.s8, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.s8, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.s8, (s64) b->data.sw);
+    case TAG_U8:  return compare_s16((s16) a->data.s8, (s16) b->data.u8);
+    case TAG_U16: return compare_s32((s32) a->data.s8, (s32) b->data.u16);
+    case TAG_U32: return compare_s64((s64) a->data.s8, (s64) b->data.u32);
+    case TAG_U64:
+      integer_init_s8(&tmp, a->data.s8);
+      integer_init_u64(&tmp2, b->data.u64);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    case TAG_UW:
+      integer_init_s8(&tmp, a->data.s8);
+      integer_init_u64(&tmp2, (u64) b->data.uw);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    default:
+      break;
+    }
+    break;
+  case TAG_S16:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.s16, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.s16, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_s16(&tmp, a->data.s16);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s16(a->data.s16, (s16) b->data.s8);
+    case TAG_S16: return compare_s16(a->data.s16, b->data.s16);
+    case TAG_S32: return compare_s32((s32) a->data.s16, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.s16, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.s16, (s64) b->data.sw);
+    case TAG_U8:  return compare_s16((s16) a->data.s16, (s16) b->data.u8);
+    case TAG_U16: return compare_s32((s32) a->data.s16, (s32) b->data.u16);
+    case TAG_U32: return compare_s64((s64) a->data.s16, (s64) b->data.u32);
+    case TAG_U64:
+      integer_init_s16(&tmp, a->data.s16);
+      integer_init_u64(&tmp2, b->data.u64);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    case TAG_UW:
+      integer_init_s16(&tmp, a->data.s16);
+      integer_init_u64(&tmp2, (u64) b->data.uw);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    default:
+      break;
+    }
+    break;
+  case TAG_S32:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.s32, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.s32, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_s32(&tmp, a->data.s32);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s32(a->data.s32, (s32) b->data.s8);
+    case TAG_S16: return compare_s32(a->data.s32, (s32) b->data.s16);
+    case TAG_S32: return compare_s32(a->data.s32, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.s32, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.s32, (s64) b->data.sw);
+    case TAG_U8:  return compare_s32((s32) a->data.s32, (s32) b->data.u8);
+    case TAG_U16: return compare_s32((s32) a->data.s32, (s32) b->data.u16);
+    case TAG_U32: return compare_s64((s64) a->data.s32, (s64) b->data.u32);
+    case TAG_U64:
+      integer_init_s32(&tmp, a->data.s32);
+      integer_init_u64(&tmp2, b->data.u64);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    case TAG_UW:
+      integer_init_s32(&tmp, a->data.s32);
+      integer_init_u64(&tmp2, (u64) b->data.uw);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    default:
+      break;
+    }
+    break;
+  case TAG_S64:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.s64, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.s64, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_s64(&tmp, a->data.s64);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s64(a->data.s64, (s64) b->data.s8);
+    case TAG_S16: return compare_s64(a->data.s64, (s64) b->data.s16);
+    case TAG_S32: return compare_s64(a->data.s64, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.s64, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.s64, (s64) b->data.sw);
+    case TAG_U8:  return compare_s64((s64) a->data.s64, (s64) b->data.u8);
+    case TAG_U16: return compare_s64((s64) a->data.s64, (s64) b->data.u16);
+    case TAG_U32: return compare_s64((s64) a->data.s64, (s64) b->data.u32);
+    case TAG_U64:
+      integer_init_s64(&tmp, a->data.s64);
+      integer_init_u64(&tmp2, b->data.u64);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    case TAG_UW:
+      integer_init_s64(&tmp, a->data.s64);
+      integer_init_u64(&tmp2, (u64) b->data.uw);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return r;
+    default:
+      break;
+    }
+    break;
+  case TAG_U8:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.u8, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.u8, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_u8(&tmp, a->data.u8);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s16((s16) a->data.u8, (s16) b->data.s8);
+    case TAG_S16: return compare_s16((s16) a->data.u8, b->data.s16);
+    case TAG_S32: return compare_s32((s32) a->data.u8, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.u8, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.u8, (s64) b->data.sw);
+    case TAG_U8:  return compare_u8(a->data.u8, b->data.u8);
+    case TAG_U16: return compare_u16((u16) a->data.u8, b->data.u16);
+    case TAG_U32: return compare_u32((u32) a->data.u8, b->data.u32);
+    case TAG_U64: return compare_u64((u64) a->data.u8, b->data.u64);
+    case TAG_UW: return compare_u64((u64) a->data.u8, (u64) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  case TAG_U16:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.u16, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.u16, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_u16(&tmp, a->data.u16);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s16((s16) a->data.u16, (s16) b->data.s8);
+    case TAG_S16: return compare_s16((s16) a->data.u16, b->data.s16);
+    case TAG_S32: return compare_s32((s32) a->data.u16, b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.u16, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.u16, (s64) b->data.sw);
+    case TAG_U8:  return compare_u16(a->data.u16, (u16) b->data.u8);
+    case TAG_U16: return compare_u16(a->data.u16, b->data.u16);
+    case TAG_U32: return compare_u32((u32) a->data.u16, b->data.u32);
+    case TAG_U64: return compare_u64((u64) a->data.u16, b->data.u64);
+    case TAG_UW: return compare_u64((u64) a->data.u16, (u64) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  case TAG_U32:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.u32, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.u32, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_u32(&tmp, a->data.u32);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:  return compare_s64((s64) a->data.u32, (s64) b->data.s8);
+    case TAG_S16: return compare_s64((s64) a->data.u32, (s64) b->data.s16);
+    case TAG_S32: return compare_s64((s64) a->data.u32, (s64) b->data.s32);
+    case TAG_S64: return compare_s64((s64) a->data.u32, b->data.s64);
+    case TAG_SW:  return compare_s64((s64) a->data.u32, (s64) b->data.sw);
+    case TAG_U8:  return compare_u32(a->data.u32, (u32) b->data.u8);
+    case TAG_U16: return compare_u32(a->data.u32, (u32) b->data.u16);
+    case TAG_U32: return compare_u32((u32) a->data.u32, b->data.u32);
+    case TAG_U64: return compare_u64((u64) a->data.u32, b->data.u64);
+    case TAG_UW: return compare_u64((u64) a->data.u32, (u64) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  case TAG_U64:
+    switch (b->type) {
+    case TAG_F32: return compare_f32((f32) a->data.u64, b->data.f32);
+    case TAG_F64: return compare_f64((f64) a->data.u64, b->data.f64);
+    case TAG_INTEGER:
+      integer_init_u64(&tmp, a->data.u64);
+      r = compare_integer(&tmp, &b->data.integer);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S8:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_s8(&tmp2, b->data.s8);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp2);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S16:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_s16(&tmp2, b->data.s16);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp2);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S32:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_s32(&tmp2, b->data.s32);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp2);
+      integer_clean(&tmp);
+      return r;
+    case TAG_S64:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_s64(&tmp2, b->data.s64);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp2);
+      integer_clean(&tmp);
+      return r;
+    case TAG_SW:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_sw(&tmp2, b->data.sw);
+      r = compare_integer(&tmp, &tmp2);
+      integer_clean(&tmp2);
+      integer_clean(&tmp);
+      return r;
+    case TAG_U8:  return compare_u64(a->data.u64, (u64) b->data.u8);
+    case TAG_U16: return compare_u64(a->data.u64, (u64) b->data.u16);
+    case TAG_U32: return compare_u64(a->data.u64, (u64) b->data.u32);
+    case TAG_U64: return compare_u64(a->data.u64, b->data.u64);
+    case TAG_UW:  return compare_u64(a->data.u64, (u64) b->data.uw);
+    default:
+      break;
+    }
+    break;
+  default:
+    break;
+  }
   if (a->type < b->type)
     return -1;
   if (a->type > b->type)
@@ -381,28 +756,18 @@ s8 compare_tag (const s_tag *a, const s_tag *b) {
   case TAG_CFN: return compare_cfn(&a->data.cfn, &b->data.cfn);
   case TAG_CHARACTER: return compare_character(a->data.character,
                                                b->data.character);
-  case TAG_F32: return compare_f32(a->data.f32, b->data.f32);
-  case TAG_F64: return compare_f64(a->data.f64, b->data.f64);
   case TAG_FN: return compare_fn(a->data.fn, b->data.fn);
   case TAG_IDENT: return compare_ident(&a->data.ident, &b->data.ident);
-  case TAG_INTEGER: return compare_integer(&a->data.integer,
-                                           &b->data.integer);
   case TAG_LIST: return compare_list(a->data.list, b->data.list);
   case TAG_PTAG: return compare_ptag(a->data.ptag, b->data.ptag);
   case TAG_QUOTE: return compare_quote(&a->data.quote, &b->data.quote);
-  case TAG_S8: return compare_s8(a->data.s8, b->data.s8);
-  case TAG_S16: return compare_s16(a->data.s16, b->data.s16);
-  case TAG_S32: return compare_s32(a->data.s32, b->data.s32);
-  case TAG_S64: return compare_s64(a->data.s64, b->data.s64);
   case TAG_STR: return compare_str(&a->data.str, &b->data.str);
   case TAG_SYM: return compare_str(&a->data.sym->str,
                                    &b->data.sym->str);
   case TAG_TUPLE: return compare_tuple(&a->data.tuple, &b->data.tuple);
-  case TAG_U8: return  compare_u8(a->data.u8, b->data.u8);
-  case TAG_U16: return compare_u16(a->data.u16, b->data.u16);
-  case TAG_U32: return compare_u32(a->data.u32, b->data.u32);
-  case TAG_U64: return compare_u64(a->data.u64, b->data.u64);
   case TAG_VAR: return compare_ptr(a, b);
+  default:
+    break;
   }
   assert(! "compare_tag: error");
   errx(1, "compare_tag");
@@ -655,3 +1020,5 @@ COMPARE_DEF(u16)
 COMPARE_DEF(u32)
 
 COMPARE_DEF(u64)
+
+COMPARE_DEF(uw)
diff --git a/libc3/env.c b/libc3/env.c
index 2cdbd76..db15993 100644
--- a/libc3/env.c
+++ b/libc3/env.c
@@ -89,8 +89,9 @@ bool env_eval_call (s_env *env, const s_call *call, s_tag *dest)
   else if (c.fn)
     result = env_eval_call_fn(env, &c, dest);
   else {
-    warnx("env_eval_call: could not resolve call %s.",
-          call->ident.sym->str.ptr.ps8);
+    warnx("env_eval_call: could not resolve call %s.%s.",
+          c.ident.module_name->str.ptr.ps8,
+          c.ident.sym->str.ptr.ps8);
     result = false;
   }
   call_clean(&c);
@@ -209,6 +210,7 @@ bool env_eval_call_macro (s_env *env, const s_call *call, s_tag *dest)
 bool env_eval_call_resolve (s_env *env, s_call *call)
 {
   s_facts_with_cursor cursor;
+  s_module module;
   s_tag tag_cfn;
   s_tag tag_fn;
   s_tag tag_ident;
@@ -248,12 +250,27 @@ bool env_eval_call_resolve (s_env *env, s_call *call)
   facts_with(&env->facts, &cursor, (t_facts_spec) {
       &tag_module_name,
       &tag_is_a, &tag_module,     /* module exists */
+      NULL, NULL });
+  if (! facts_with_cursor_next(&cursor)) {
+    if (! module_load(&module, call->ident.module_name, &env->facts)) {
+      warnx("module not found: %s",
+            call->ident.module_name->str.ptr.ps8);
+      facts_with_cursor_clean(&cursor);
+      return false;
+    }
+  }
+  facts_with_cursor_clean(&cursor);
+  facts_with(&env->facts, &cursor, (t_facts_spec) {
+      &tag_module_name,
       &tag_symbol, &tag_ident,    /* module exports symbol */
       NULL, NULL });
-  if (! facts_with_cursor_next(&cursor))
-    errx(1, "symbol %s not found in module %s",
-         call->ident.sym->str.ptr.ps8,
-         call->ident.module_name->str.ptr.ps8);
+  if (! facts_with_cursor_next(&cursor)) {
+    warnx("symbol %s not found in module %s",
+          call->ident.sym->str.ptr.ps8,
+          call->ident.module_name->str.ptr.ps8);
+    facts_with_cursor_clean(&cursor);
+    return false;
+  }
   facts_with_cursor_clean(&cursor);
   facts_with(&env->facts, &cursor, (t_facts_spec) {
       &tag_ident, &tag_fn, &tag_var,
@@ -416,6 +433,44 @@ bool env_eval_equal_tag (s_env *env, const s_tag *a, const s_tag *b,
     frame_binding_new(env->frame, b->data.ident.sym, a);
     return true;
   }
+  switch (a->type) {
+  case TAG_F32:
+  case TAG_F64:
+  case TAG_S8:
+  case TAG_S16:
+  case TAG_S32:
+  case TAG_S64:
+  case TAG_SW:
+  case TAG_U8:
+  case TAG_U16:
+  case TAG_U32:
+  case TAG_U64:
+  case TAG_UW:
+    switch (b->type) {
+    case TAG_F32:
+    case TAG_F64:
+    case TAG_S8:
+    case TAG_S16:
+    case TAG_S32:
+    case TAG_S64:
+    case TAG_SW:
+    case TAG_U8:
+    case TAG_U16:
+    case TAG_U32:
+    case TAG_U64:
+    case TAG_UW:
+      if (compare_tag(a, b)) {
+        warnx("env_eval_compare_tag: value mismatch");
+        return false;
+      }
+      tag_copy(a, dest);
+      return true;
+    default:
+      break;
+    }
+  default:
+    break;
+  }
   if (a->type != b->type) {
     warnx("env_eval_equal_tag: type mismatch");
     return false;
@@ -440,22 +495,12 @@ bool env_eval_equal_tag (s_env *env, const s_tag *a, const s_tag *b,
   case TAG_BOOL:
   case TAG_CFN:
   case TAG_CHARACTER:
-  case TAG_F32:
-  case TAG_F64:
   case TAG_FN:
   case TAG_IDENT:
   case TAG_INTEGER:
   case TAG_PTAG:
-  case TAG_S16:
-  case TAG_S32:
-  case TAG_S64:
-  case TAG_S8:
   case TAG_STR:
   case TAG_SYM:
-  case TAG_U16:
-  case TAG_U32:
-  case TAG_U64:
-  case TAG_U8:
   case TAG_VAR:
     if (compare_tag(a, b)) {
       warnx("env_eval_compare_tag: value mismatch");
@@ -463,6 +508,8 @@ bool env_eval_equal_tag (s_env *env, const s_tag *a, const s_tag *b,
     }
     tag_copy(a, dest);
     return true;
+  default:
+    break;
   }
   error("env_eval_equal_tag: invalid tag");
   return false;
@@ -500,7 +547,9 @@ bool env_eval_ident (s_env *env, const s_ident *ident, s_tag *dest)
   assert(ident);
   if (! ((tag = frame_get(env->frame, ident->sym)) ||
          (tag = module_get(env->current_module, ident->sym, &tmp)))) {
-    warnx("unbound ident: %s", ident->sym->str.ptr.ps8);
+    warnx("unbound ident: %s.%s",
+          ident->module_name->str.ptr.ps8,
+          ident->sym->str.ptr.ps8);
     return false;
   }
   tag_copy(tag, dest);
@@ -563,17 +612,19 @@ bool env_eval_tag (s_env *env, const s_tag *tag, s_tag *dest)
   case TAG_INTEGER:
   case TAG_LIST:
   case TAG_PTAG:
+  case TAG_S8:
   case TAG_S16:
   case TAG_S32:
   case TAG_S64:
-  case TAG_S8:
+  case TAG_SW:
   case TAG_STR:
   case TAG_SYM:
   case TAG_TUPLE:
+  case TAG_U8:
   case TAG_U16:
   case TAG_U32:
   case TAG_U64:
-  case TAG_U8:
+  case TAG_UW:
   case TAG_VAR:
     tag_copy(tag, dest);
     return true;
@@ -640,8 +691,11 @@ s_module * env_module_load (s_env *env, s_module *module,
   assert(facts);
   module->name = name;
   module->facts = facts;
-  if (! module_name_path(&env->module_path, name, &path))
+  if (! module_name_path(&env->module_path, name, &path)) {
+    warnx("env_module_load: %s: module_name_path",
+          name->str.ptr.ps8);
     return 0;
+  }
   /*
   buf_write_1(&env->out, "module_load ");
   buf_write_str(&env->out, &name->str);
@@ -651,6 +705,8 @@ s_module * env_module_load (s_env *env, s_module *module,
   buf_flush(&env->out);
   */
   if (facts_load_file(facts, &path) < 0) {
+    warnx("env_module_load: %s: facts_load_file",
+          path.ptr.ps8);
     str_clean(&path);
     return 0;
   }
diff --git a/libc3/hash.c b/libc3/hash.c
index becfe77..2455720 100644
--- a/libc3/hash.c
+++ b/libc3/hash.c
@@ -226,6 +226,8 @@ HASH_UPDATE_DEF(s32)
 
 HASH_UPDATE_DEF(s64)
 
+HASH_UPDATE_DEF(sw)
+
 void hash_update_str (t_hash *hash, const s_str *str)
 {
   s8 type[] = "str";
@@ -273,6 +275,7 @@ void hash_update_tag (t_hash *hash, const s_tag *tag)
   case TAG_S16: hash_update_s16(hash, tag->data.s16);          break;
   case TAG_S32: hash_update_s32(hash, tag->data.s32);          break;
   case TAG_S64: hash_update_s64(hash, tag->data.s64);          break;
+  case TAG_SW: hash_update_sw(hash, tag->data.sw);             break;
   case TAG_STR: hash_update_str(hash, &tag->data.str);         break;
   case TAG_SYM: hash_update_sym(hash, tag->data.sym);          break;
   case TAG_TUPLE: hash_update_tuple(hash, &tag->data.tuple);   break;
@@ -280,6 +283,7 @@ void hash_update_tag (t_hash *hash, const s_tag *tag)
   case TAG_U16: hash_update_u16(hash, tag->data.u16);          break;
   case TAG_U32: hash_update_u32(hash, tag->data.u32);          break;
   case TAG_U64: hash_update_u64(hash, tag->data.u64);          break;
+  case TAG_UW: hash_update_uw(hash, tag->data.uw);             break;
   case TAG_VAR:
     assert(! "var hash update");
     errx(1, "var hash update");
diff --git a/libc3/hash.h b/libc3/hash.h
index 1ac5db4..e8ebbfa 100644
--- a/libc3/hash.h
+++ b/libc3/hash.h
@@ -41,6 +41,7 @@ HASH_UPDATE_PROTOTYPE(s8);
 HASH_UPDATE_PROTOTYPE(s16);
 HASH_UPDATE_PROTOTYPE(s32);
 HASH_UPDATE_PROTOTYPE(s64);
+HASH_UPDATE_PROTOTYPE(sw);
 void hash_update_str (t_hash *hash, const s_str *src);
 void hash_update_sym (t_hash *hash, const s_sym *sym);
 void hash_update_tag (t_hash *hash, const s_tag *tag);
diff --git a/libc3/ident.c b/libc3/ident.c
index 5b34869..7059c26 100644
--- a/libc3/ident.c
+++ b/libc3/ident.c
@@ -73,11 +73,12 @@ bool ident_has_reserved_characters (const s_ident *ident)
   return false;
 }
 
-s_ident * ident_init (s_ident *ident, const s_sym *sym)
+s_ident * ident_init (s_ident *ident, const s_sym *module_name,
+                      const s_sym *sym)
 {
   assert(ident);
   assert(sym);
-  ident->module_name = NULL;
+  ident->module_name = module_name;
   ident->sym = sym;
   return ident;
 }
diff --git a/libc3/ident.h b/libc3/ident.h
index e9cc243..17242a8 100644
--- a/libc3/ident.h
+++ b/libc3/ident.h
@@ -19,7 +19,9 @@
 /* Maximum number of bytes in UTF-8 of an identifier. */
 #define IDENT_MAX SYM_MAX
 
-/* Constructors, call ident_clean after use. */
+/* Stack-allocation compatible functions */
+s_ident * ident_init (s_ident *ident, const s_sym *module_name,
+                      const s_sym *sym);
 s_ident * ident_init_1 (s_ident *ident, const s8 *p);
 
 /* Modifiers */
@@ -38,8 +40,6 @@ bool ident_first_character_is_reserved (character c);
 /* Returns true iff ident contains reserved characters. */
 bool ident_has_reserved_characters (const s_ident *ident);
 
-s_ident * ident_init (s_ident *ident, const s_sym *sym);
-
 s_str * ident_inspect (const s_ident *ident, s_str *dest);
 
 bool ident_to_tag_type (const s_ident *ident, e_tag_type *dest);
diff --git a/libc3/list.c b/libc3/list.c
index a1f9882..0e27469 100644
--- a/libc3/list.c
+++ b/libc3/list.c
@@ -12,6 +12,7 @@
  */
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 #include "buf.h"
 #include "buf_inspect.h"
 #include "buf_parse.h"
@@ -138,3 +139,33 @@ s_list * list_new (const s_tag *tag, s_list *next)
     errx(1, "list_new: out of memory");
   return list_init(list, tag, next);
 }
+
+s_array * list_to_array (s_list *list, e_tag_type type,
+                         s_array *dest)
+{
+  s8 *data;
+  s8 *data_list;
+  s_list *l;
+  uw len;
+  uw size;
+  assert(list);
+  assert(dest);
+  len = list_length(list);
+  size = tag_type_size(type);
+  dest->dimension = 1;
+  if (! (dest->dimensions = calloc(1, sizeof(s_array_dimension))))
+    errx(1, "list_to_array: out of memory: 1");
+  dest->dimensions[0].count = len;
+  dest->dimensions[0].item_size = size;
+  if (! (data = dest->data = calloc(len, size)))
+    errx(1, "list_to_array: out of memory: 2");
+  data = dest->data;
+  l = list;
+  while (l) {
+    data_list = tag_to_pointer(&l->tag, type);
+    memcpy(data, data_list, size);
+    data += size;
+    l = list_next(l);
+  }
+  return dest;
+}
diff --git a/libc3/list.h b/libc3/list.h
index 145f40d..acf394f 100644
--- a/libc3/list.h
+++ b/libc3/list.h
@@ -40,7 +40,9 @@ void     list_delete_all (s_list *list);
 s_list *  list_copy (const s_list *src, s_list **dest);
 sw        list_length (const s_list *list);
 s_list *  list_next (const s_list *list);
-s_tuple * list_to_tuple_reverse (s_list *list, s_tuple *tuple);
+s_array * list_to_array (s_list *list, e_tag_type type,
+                         s_array *dest);
+s_tuple * list_to_tuple_reverse (const s_list *list, s_tuple *dest);
 /* Call str_delete after use. */
 s_str *   list_inspect (const s_list *list, s_str *dest);
 
diff --git a/libc3/module.c b/libc3/module.c
index b94ff1b..a674b6f 100644
--- a/libc3/module.c
+++ b/libc3/module.c
@@ -33,8 +33,7 @@ s_tag * module_get (const s_module *module, const s_sym *sym,
   tag_init_1(  &tag_is_a, ":is_a");
   tag_init_1(  &tag_module, ":module");
   tag_init_1(  &tag_symbol, ":symbol");
-  ident_init(&ident, sym);
-  ident.module_name = module->name;
+  ident_init(&ident, module->name, sym);
   tag_init_ident(&tag_ident, &ident);
   facts_with(module->facts, &cursor, (t_facts_spec) {
       &tag_name, &tag_is_a, &tag_module,
diff --git a/libc3/str.c b/libc3/str.c
index cdf90c1..79cad1a 100644
--- a/libc3/str.c
+++ b/libc3/str.c
@@ -390,7 +390,7 @@ s_ident * str_to_ident (const s_str *src, s_ident *ident)
 {
   const s_sym *sym;
   sym = str_to_sym(src);
-  return ident_init(ident, sym);
+  return ident_init(ident, NULL, sym);
 }
 
 const s_sym * str_to_sym (const s_str *src)
diff --git a/libc3/sym.c b/libc3/sym.c
index d28b665..799b952 100644
--- a/libc3/sym.c
+++ b/libc3/sym.c
@@ -159,7 +159,7 @@ ffi_type * sym_to_ffi_type (const s_sym *sym, ffi_type *result_type)
   if (sym == sym_1("s64"))
     return &ffi_type_sint64;
   if (sym == sym_1("sw"))
-    return &ffi_type_sint;
+    return &ffi_type_slong;
   if (sym == sym_1("tag"))
     return &ffi_type_pointer;
   if (sym == sym_1("u8") ||
@@ -172,7 +172,7 @@ ffi_type * sym_to_ffi_type (const s_sym *sym, ffi_type *result_type)
   if (sym == sym_1("u64"))
     return &ffi_type_uint64;
   if (sym == sym_1("uw"))
-    return &ffi_type_uint;
+    return &ffi_type_ulong;
   if (sym == sym_1("void"))
     return &ffi_type_void;
   assert(! "sym_to_ffi_type: unknown type");
@@ -230,6 +230,10 @@ bool sym_to_tag_type (const s_sym *sym, e_tag_type *dest)
     *dest = TAG_INTEGER;
     return true;
   }
+  if (sym == sym_1("sw")) {
+    *dest = TAG_SW;
+    return true;
+  }
   if (sym == sym_1("s64")) {
     *dest = TAG_S64;
     return true;
@@ -262,6 +266,10 @@ bool sym_to_tag_type (const s_sym *sym, e_tag_type *dest)
     *dest = TAG_U64;
     return true;
   }
+  if (sym == sym_1("uw")) {
+    *dest = TAG_UW;
+    return true;
+  }
   if (sym == sym_1("list")) {
     *dest = TAG_LIST;
     return true;
diff --git a/libc3/tag.c b/libc3/tag.c
index 130e178..5aac834 100644
--- a/libc3/tag.c
+++ b/libc3/tag.c
@@ -52,6 +52,8 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       return tag_init_f32(dest, a->data.f32 + (f32) b->data.s32);
     case TAG_S64:
       return tag_init_f32(dest, a->data.f32 + (f32) b->data.s64);
+    case TAG_SW:
+      return tag_init_f32(dest, a->data.f32 + (f32) b->data.sw);
     case TAG_U8:
       return tag_init_f32(dest, a->data.f32 + (f32) b->data.u8);
     case TAG_U16:
@@ -60,6 +62,8 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       return tag_init_f32(dest, a->data.f32 + (f32) b->data.u32);
     case TAG_U64:
       return tag_init_f32(dest, a->data.f32 + (f32) b->data.u64);
+    case TAG_UW:
+      return tag_init_f32(dest, a->data.f32 + (f32) b->data.uw);
     default:
       goto ko;
   }
@@ -80,6 +84,8 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       return tag_init_f64(dest, a->data.f64 + (f64) b->data.s32);
     case TAG_S64:
       return tag_init_f64(dest, a->data.f64 + (f64) b->data.s64);
+    case TAG_SW:
+      return tag_init_f64(dest, a->data.f64 + (f64) b->data.sw);
     case TAG_U8:
       return tag_init_f64(dest, a->data.f64 + (f64) b->data.u8);
     case TAG_U16:
@@ -88,6 +94,8 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       return tag_init_f64(dest, a->data.f64 + (f64) b->data.u32);
     case TAG_U64:
       return tag_init_f64(dest, a->data.f64 + (f64) b->data.u64);
+    case TAG_UW:
+      return tag_init_f64(dest, a->data.f64 + (f64) b->data.uw);
     default:
       goto ko;
   }
@@ -128,6 +136,12 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       integer_add(&a->data.integer, &tmp, &dest->data.integer);
       integer_clean(&tmp);
       return dest;
+    case TAG_SW:
+      integer_init_sw(&tmp, b->data.sw);
+      tag_init_integer_zero(dest);
+      integer_add(&a->data.integer, &tmp, &dest->data.integer);
+      integer_clean(&tmp);
+      return dest;
     case TAG_U8:
       integer_init_u32(&tmp, (u32) b->data.u8);
       tag_init_integer_zero(dest);
@@ -152,6 +166,12 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       integer_add(&a->data.integer, &tmp, &dest->data.integer);
       integer_clean(&tmp);
       return dest;
+    case TAG_UW:
+      integer_init_uw(&tmp, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&a->data.integer, &tmp, &dest->data.integer);
+      integer_clean(&tmp);
+      return dest;
     default:
       goto ko;
     }
@@ -198,6 +218,19 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.s8 + b->data.s64);
+    case TAG_SW:
+      if (a->data.s8 < SW_MIN - b->data.sw ||
+          a->data.s8 > SW_MAX - b->data.sw) {
+        integer_init_s32(&tmp, (s32) a->data.s8);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, (sw) a->data.s8 + b->data.sw);
     case TAG_U8:
       if (a->data.s8 < S8_MIN - b->data.u8 ||
           a->data.s8 > S8_MAX - b->data.u8)
@@ -211,24 +244,27 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       else
         return tag_init_s16(dest, (s16) a->data.s8 + (s16) b->data.u16);
     case TAG_U32:
-      if (a->data.s8 < (s32) (S32_MIN - b->data.u32) ||
-          a->data.s8 > (s32) (S32_MAX - b->data.u32))
+      if (a->data.s8 < (s64) S32_MIN - (s64) b->data.u32 ||
+          a->data.s8 > (s64) S32_MAX - (s64) b->data.u32)
         return tag_init_s64(dest, (s64) a->data.s8 + (s64) b->data.u32);
       else
         return tag_init_s32(dest, (s32) a->data.s8 + (s32) b->data.u32);
     case TAG_U64:
-      if (a->data.s8 < (s64) (S64_MIN - b->data.u64) ||
-          a->data.s8 > (s64) (S64_MAX - b->data.u64)) {
-        integer_init_s32(&tmp, (s32) a->data.s8);
-        integer_init_u64(&tmp2, b->data.u64);
-        tag_init_integer_zero(dest);
-        integer_add(&tmp, &tmp2, &dest->data.integer);
-        integer_clean(&tmp);
-        integer_clean(&tmp2);
-        return dest;
-      }
-      else
-        return tag_init_s64(dest, (s64) a->data.s8 + (s64) b->data.u64);
+      integer_init_s8(&tmp, a->data.s8);
+      integer_init_u64(&tmp2, b->data.u64);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_UW:
+      integer_init_s8(&tmp, a->data.s8);
+      integer_init_uw(&tmp2, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
     default:
       goto ko;
   }
@@ -265,7 +301,7 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
     case TAG_S64:
       if (a->data.s16 < S64_MIN - b->data.s64 ||
           a->data.s16 > S64_MAX - b->data.s64) {
-        integer_init_s32(&tmp, (s32) a->data.s16);
+        integer_init_s16(&tmp, a->data.s16);
         integer_init_s64(&tmp2, b->data.s64);
         tag_init_integer_zero(dest);
         integer_add(&tmp, &tmp2, &dest->data.integer);
@@ -275,6 +311,19 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.s16 + b->data.s64);
+    case TAG_SW:
+      if (a->data.s16 < SW_MIN - b->data.sw ||
+          a->data.s16 > SW_MAX - b->data.sw) {
+        integer_init_s16(&tmp, a->data.s16);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_s64(dest, (s64) a->data.s16 + b->data.s64);
     case TAG_U8:
       if (a->data.s16 > S16_MAX - b->data.u8)
         return tag_init_s32(dest, (s32) a->data.s16 + (s32) b->data.u8);
@@ -295,6 +344,14 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       integer_clean(&tmp);
       integer_clean(&tmp2);
       return dest;
+    case TAG_UW:
+      integer_init_s32(&tmp, (s32) a->data.s16);
+      integer_init_uw(&tmp2, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
     default:
       goto ko;
     }
@@ -341,6 +398,19 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.s32 + b->data.s64);
+    case TAG_SW:
+      if (a->data.s32 < SW_MIN - b->data.sw ||
+          a->data.s32 > SW_MAX - b->data.sw) {
+        integer_init_s32(&tmp, a->data.s32);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, (sw) a->data.s32 + b->data.sw);
     case TAG_U8:
       if (a->data.s32 > S32_MAX - b->data.u8)
         return tag_init_s64(dest, (s64) a->data.s32 + (s64) b->data.u8);
@@ -352,22 +422,26 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       else
         return tag_init_s32(dest, a->data.s32 + (s32) b->data.u16);
     case TAG_U32:
-      if (a->data.s32 > (s32) (S32_MAX - b->data.u32))
+      if (a->data.s32 > (s64) S32_MAX - (s64) b->data.u32)
         return tag_init_s64(dest, (s64) a->data.s32 + (s64) b->data.u32);
       else
         return tag_init_s32(dest, a->data.s32 + (s32) b->data.u32);
     case TAG_U64:
-      if (a->data.s32 > (s64) (S64_MAX - b->data.u64)) {
-        integer_init_s32(&tmp, a->data.s32);
-        integer_init_u64(&tmp2, b->data.u64);
-        tag_init_integer_zero(dest);
-        integer_add(&tmp, &tmp2, &dest->data.integer);
-        integer_clean(&tmp);
-        integer_clean(&tmp2);
-        return dest;
-      }
-      else
-        return tag_init_s64(dest, (s64) a->data.s32 + (s64) b->data.u64);
+      integer_init_s32(&tmp, a->data.s32);
+      integer_init_u64(&tmp2, b->data.u64);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_UW:
+      integer_init_s32(&tmp, a->data.s32);
+      integer_init_uw(&tmp2, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
     default:
       goto ko;
   }
@@ -435,6 +509,19 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, a->data.s64 + b->data.s64);
+    case TAG_SW:
+      if (a->data.s64 < S64_MIN - (s64) b->data.sw ||
+          a->data.s64 > S64_MAX - (s64) b->data.sw) {
+        integer_init_s64(&tmp, a->data.s64);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_s64(dest, a->data.s64 + b->data.s64);
     case TAG_U8:
       if (a->data.s64 > S64_MAX - b->data.u8) {
         integer_init_s64(&tmp, a->data.s64);
@@ -479,6 +566,146 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       integer_clean(&tmp);
       integer_clean(&tmp2);
       return dest;
+    case TAG_UW:
+      integer_init_s64(&tmp, a->data.s64);
+      integer_init_uw(&tmp2, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    default:
+      goto ko;
+  }
+  case TAG_SW:
+    switch (b->type) {
+    case TAG_F32:
+      return tag_init_f32(dest, (f32) a->data.sw + b->data.f32);
+    case TAG_F64:
+      return tag_init_f64(dest, (f64) a->data.sw + b->data.f64);
+    case TAG_INTEGER:
+      integer_init_sw(&tmp, a->data.sw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &b->data.integer, &dest->data.integer);
+      integer_clean(&tmp);
+      return dest;
+    case TAG_S8:
+      if (a->data.sw < SW_MIN - b->data.s8 ||
+          a->data.sw > SW_MAX - b->data.s8) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_s32(&tmp2, (s32) b->data.s8);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.s8);
+    case TAG_S16:
+      if (a->data.sw < SW_MIN - b->data.s16 ||
+          a->data.sw > SW_MAX - b->data.s16) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_s32(&tmp2, (s32) b->data.s16);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.s16);
+    case TAG_S32:
+      if (a->data.sw < SW_MIN - b->data.s32 ||
+          a->data.sw > SW_MAX - b->data.s32) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_s32(&tmp2, b->data.s32);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.s32);
+    case TAG_S64:
+      if (a->data.sw < S64_MIN - b->data.s64 ||
+          a->data.sw > S64_MAX - b->data.s64) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_s64(&tmp2, b->data.s64);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_s64(dest, (s64) a->data.sw + b->data.s64);
+    case TAG_SW:
+      if (a->data.sw < SW_MIN - b->data.sw ||
+          a->data.sw > SW_MAX - b->data.sw) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + b->data.sw);
+    case TAG_U8:
+      if (a->data.sw > SW_MAX - b->data.u8) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_u32(&tmp2, (u32) b->data.u8);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.u8);
+    case TAG_U16:
+      if (a->data.sw > SW_MAX - b->data.u16) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_u32(&tmp2, (u32) b->data.u16);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.u16);
+    case TAG_U32:
+      if (a->data.sw > SW_MAX - b->data.u32) {
+        integer_init_sw(&tmp, a->data.sw);
+        integer_init_u32(&tmp2, b->data.u32);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, a->data.sw + (sw) b->data.u32);
+    case TAG_U64:
+      integer_init_sw(&tmp, a->data.sw);
+      integer_init_u64(&tmp2, b->data.u64);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_UW:
+      integer_init_sw(&tmp, a->data.sw);
+      integer_init_uw(&tmp2, b->data.uw);
+      tag_init_integer_zero(dest);
+      integer_add(&tmp, &tmp2, &dest->data.integer);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
     default:
       goto ko;
   }
@@ -511,7 +738,7 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
         return tag_init_s32(dest, (s32) a->data.u8 + b->data.s32);
     case TAG_S64:
       if (a->data.u8 > S64_MAX - b->data.s64) {
-        integer_init_u32(&tmp, (u32) a->data.u8);
+        integer_init_u8(&tmp, a->data.u8);
         integer_init_s64(&tmp2, b->data.s64);
         tag_init_integer_zero(dest);
         integer_add(&tmp, &tmp2, &dest->data.integer);
@@ -521,6 +748,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.u8 + b->data.s64);
+    case TAG_SW:
+      if (a->data.u8 > SW_MAX - b->data.sw) {
+        integer_init_u8(&tmp, a->data.u8);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_s64(dest, (s64) a->data.u8 + b->data.s64);
     case TAG_U8:
       if (a->data.u8 > U8_MAX - b->data.u8)
         return tag_init_u16(dest, (u16) a->data.u8 + (u16) b->data.u8);
@@ -548,6 +787,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_u64(dest, (u64) a->data.u8 + b->data.u64);
+    case TAG_UW:
+      if (a->data.u8 > UW_MAX - b->data.uw) {
+        integer_init_u8(&tmp, a->data.u8);
+        integer_init_uw(&tmp2, b->data.uw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, (uw) a->data.u8 + b->data.uw);
     default:
       goto ko;
   }
@@ -580,7 +831,7 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
         return tag_init_s32(dest, (s32) a->data.u16 + b->data.s32);
     case TAG_S64:
       if (a->data.u16 > S64_MAX - b->data.s64) {
-        integer_init_u32(&tmp, (u32) a->data.u16);
+        integer_init_u16(&tmp, a->data.u16);
         integer_init_s64(&tmp2, b->data.s64);
         tag_init_integer_zero(dest);
         integer_add(&tmp, &tmp2, &dest->data.integer);
@@ -590,6 +841,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.u16 + b->data.s64);
+    case TAG_SW:
+      if (a->data.u16 > SW_MAX - b->data.sw) {
+        integer_init_u16(&tmp, a->data.u16);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, (sw) a->data.u16 + b->data.sw);
     case TAG_U8:
       if (a->data.u16 > U16_MAX - b->data.u8)
         return tag_init_u32(dest, (u32) a->data.u16 + (u32) b->data.u8);
@@ -617,6 +880,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_u64(dest, (u64) a->data.u16 + b->data.u64);
+    case TAG_UW:
+      if (a->data.u16 > UW_MAX - b->data.uw) {
+        integer_init_u32(&tmp, (u32) a->data.u16);
+        integer_init_uw(&tmp2, b->data.uw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, (uw) a->data.u16 + b->data.uw);
     default:
       goto ko;
   }
@@ -659,6 +934,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_s64(dest, (s64) a->data.u32 + b->data.s64);
+    case TAG_SW:
+      if (a->data.u32 > SW_MAX - b->data.sw) {
+        integer_init_u32(&tmp, a->data.u32);
+        integer_init_sw(&tmp2, b->data.sw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_sw(dest, (sw) a->data.u32 + b->data.sw);
     case TAG_U8:
       if (a->data.u32 > U32_MAX - b->data.u8)
         return tag_init_u64(dest, (u64) a->data.u32 + (u64) b->data.u8);
@@ -686,6 +973,18 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_u64(dest, (u64) a->data.u32 + b->data.u64);
+    case TAG_UW:
+      if (a->data.u32 > UW_MAX - b->data.uw) {
+        integer_init_u32(&tmp, a->data.u32);
+        integer_init_uw(&tmp2, b->data.uw);
+        tag_init_integer_zero(dest);
+        integer_add(&tmp, &tmp2, &dest->data.integer);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, (uw) a->data.u32 + b->data.uw);
     default:
       goto ko;
   }
@@ -733,6 +1032,14 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       integer_clean(&tmp);
       integer_clean(&tmp2);
       return dest;
+    case TAG_SW:
+      integer_init_u64(&tmp, a->data.u64);
+      integer_init_sw(&tmp2, b->data.sw);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
     case TAG_U8:
       if (a->data.u64 > U64_MAX - b->data.u8) {
         integer_init_u64(&tmp, a->data.u64);
@@ -781,6 +1088,133 @@ s_tag * tag_add (const s_tag *a, const s_tag *b, s_tag *dest)
       }
       else
         return tag_init_u64(dest, a->data.u64 + b->data.u64);
+    case TAG_UW:
+      if (a->data.u64 > U64_MAX - b->data.uw) {
+        integer_init_u64(&tmp, a->data.u64);
+        integer_init_uw(&tmp2, b->data.uw);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_u64(dest, a->data.u64 + b->data.uw);
+    default:
+      goto ko;
+    }
+  case TAG_UW:
+    switch (b->type) {
+    case TAG_F32:
+      return tag_init_f32(dest, (f32) a->data.uw + b->data.f32);
+    case TAG_F64:
+      return tag_init_f64(dest, (f64) a->data.uw + b->data.f64);
+    case TAG_INTEGER:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_add(&tmp, &b->data.integer, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      return dest;
+    case TAG_S8:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_init_s8(&tmp2, b->data.s8);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_S16:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_init_s16(&tmp2, b->data.s16);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_S32:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_init_s32(&tmp2, b->data.s32);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_S64:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_init_s64(&tmp2, b->data.s64);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_SW:
+      integer_init_uw(&tmp, a->data.uw);
+      integer_init_sw(&tmp2, b->data.sw);
+      integer_add(&tmp, &tmp2, &tmp);
+      tag_init_integer(dest, &tmp);
+      integer_clean(&tmp);
+      integer_clean(&tmp2);
+      return dest;
+    case TAG_U8:
+      if (a->data.uw > UW_MAX - b->data.u8) {
+        integer_init_uw(&tmp, a->data.uw);
+        integer_init_u8(&tmp2, b->data.u8);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, a->data.uw + (uw) b->data.u8);
+    case TAG_U16:
+      if (a->data.uw > UW_MAX - b->data.u16) {
+        integer_init_uw(&tmp, a->data.uw);
+        integer_init_u16(&tmp2, b->data.u16);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, a->data.uw + (uw) b->data.u16);
+    case TAG_U32:
+      if (a->data.uw > UW_MAX - b->data.u32) {
+        integer_init_uw(&tmp, a->data.uw);
+        integer_init_u32(&tmp2, b->data.u32);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, a->data.uw + (uw) b->data.u32);
+    case TAG_U64:
+      if (a->data.uw > U64_MAX - b->data.u64) {
+        integer_init_uw(&tmp, a->data.uw);
+        integer_init_u64(&tmp2, b->data.u64);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_u64(dest, (u64) a->data.uw + b->data.u64);
+    case TAG_UW:
+      if (a->data.uw > UW_MAX - b->data.uw) {
+        integer_init_uw(&tmp, a->data.uw);
+        integer_init_uw(&tmp2, b->data.uw);
+        integer_add(&tmp, &tmp2, &tmp);
+        tag_init_integer(dest, &tmp);
+        integer_clean(&tmp);
+        integer_clean(&tmp2);
+        return dest;
+      }
+      else
+        return tag_init_uw(dest, a->data.uw + b->data.uw);
     default:
       goto ko;
     }
@@ -919,11 +1353,13 @@ void tag_clean (s_tag *tag)
   case TAG_S16:
   case TAG_S32:
   case TAG_S64:
+  case TAG_SW:
   case TAG_SYM:
   case TAG_U8:
   case TAG_U16:
   case TAG_U32:
   case TAG_U64:
+  case TAG_UW:
   case TAG_VAR:
   case TAG_VOID:
     break;
@@ -980,11 +1416,13 @@ s_tag * tag_copy (const s_tag *src, s_tag *dest)
   case TAG_S16:
   case TAG_S32:
   case TAG_S64:
+  case TAG_SW:
   case TAG_SYM:
   case TAG_U8:
   case TAG_U16:
   case TAG_U32:
   case TAG_U64:
+  case TAG_UW:
     dest->data = src->data;
   }
   dest->type = src->type;
@@ -1720,6 +2158,15 @@ s_tag * tag_init_s64 (s_tag *tag, s64 i)
   return tag;
 }
 
+s_tag * tag_init_sw (s_tag *tag, sw i)
+{
+  assert(tag);
+  bzero(tag, sizeof(s_tag));
+  tag->type = TAG_SW;
+  tag->data.sw = i;
+  return tag;
+}
+
 s_tag * tag_init_str (s_tag *tag, s8 *free, uw size, const s8 *p)
 {
   assert(tag);
@@ -1802,6 +2249,15 @@ s_tag * tag_init_u64 (s_tag *tag, u64 i)
   return tag;
 }
 
+s_tag * tag_init_uw (s_tag *tag, uw i)
+{
+  assert(tag);
+  bzero(tag, sizeof(s_tag));
+  tag->type = TAG_UW;
+  tag->data.uw = i;
+  return tag;
+}
+
 s_tag * tag_init_var (s_tag *tag)
 {
   assert(tag);
@@ -2570,6 +3026,13 @@ s_tag * tag_s64 (s_tag *tag, s64 x)
   return tag_init_s64(tag, x);
 }
 
+s_tag * tag_sw (s_tag *tag, sw x)
+{
+  assert(tag);
+  tag_clean(tag);
+  return tag_init_sw(tag, x);
+}
+
 s_tag * tag_str (s_tag *tag, s8 *free, uw size, const s8 *p)
 {
   assert(tag);
@@ -3214,6 +3677,10 @@ void * tag_to_ffi_pointer (s_tag *tag, const s_sym *type)
     if (type == sym_1("integer"))
       return &tag->data.integer;
     goto invalid_type;
+  case TAG_SW:
+    if (type == sym_1("sw"))
+      return &tag->data.sw;
+    goto invalid_type;
   case TAG_S64:
     if (type == sym_1("s64"))
       return &tag->data.s64;
@@ -3246,6 +3713,10 @@ void * tag_to_ffi_pointer (s_tag *tag, const s_sym *type)
     if (type == sym_1("u64"))
       return &tag->data.u64;
     goto invalid_type;
+  case TAG_UW:
+    if (type == sym_1("uw"))
+      return &tag->data.uw;
+    goto invalid_type;
   case TAG_LIST:
     if (type == sym_1("list"))
       return tag->data.list;
@@ -3324,6 +3795,8 @@ void * tag_to_pointer (s_tag *tag, e_tag_type type)
     return &tag->data.ident;
   case TAG_INTEGER:
     return &tag->data.integer;
+  case TAG_SW:
+    return &tag->data.sw;
   case TAG_S64:
     return &tag->data.s64;
   case TAG_S32:
@@ -3340,6 +3813,8 @@ void * tag_to_pointer (s_tag *tag, e_tag_type type)
     return &tag->data.u32;
   case TAG_U64:
     return &tag->data.u64;
+  case TAG_UW:
+    return &tag->data.uw;
   case TAG_LIST:
     return tag->data.list;
   case TAG_PTAG:
@@ -3395,6 +3870,8 @@ sw tag_type_size (e_tag_type type)
     return sizeof(s_ident);
   case TAG_INTEGER:
     return sizeof(s_integer);
+  case TAG_SW:
+    return sizeof(sw);
   case TAG_S64:
     return sizeof(s64);
   case TAG_S32:
@@ -3411,6 +3888,8 @@ sw tag_type_size (e_tag_type type)
     return sizeof(u32);
   case TAG_U64:
     return sizeof(u64);
+  case TAG_UW:
+    return sizeof(uw);
   case TAG_LIST:
     return sizeof(s_list *);
   case TAG_PTAG:
@@ -3457,6 +3936,8 @@ f_buf_inspect tag_type_to_buf_inspect (e_tag_type type)
     return (f_buf_inspect) buf_inspect_ident;
   case TAG_INTEGER:
     return (f_buf_inspect) buf_inspect_integer;
+  case TAG_SW:
+    return (f_buf_inspect) buf_inspect_sw;
   case TAG_S64:
     return (f_buf_inspect) buf_inspect_s64;
   case TAG_S32:
@@ -3473,6 +3954,8 @@ f_buf_inspect tag_type_to_buf_inspect (e_tag_type type)
     return (f_buf_inspect) buf_inspect_u32;
   case TAG_U64:
     return (f_buf_inspect) buf_inspect_u64;
+  case TAG_UW:
+    return (f_buf_inspect) buf_inspect_uw;
   case TAG_LIST:
     return (f_buf_inspect) buf_inspect_list;
   case TAG_PTAG:
@@ -3519,6 +4002,8 @@ f_buf_inspect_size tag_type_to_buf_inspect_size (e_tag_type type)
     return (f_buf_inspect_size) buf_inspect_ident_size;
   case TAG_INTEGER:
     return (f_buf_inspect_size) buf_inspect_integer_size;
+  case TAG_SW:
+    return (f_buf_inspect_size) buf_inspect_sw_size;
   case TAG_S64:
     return (f_buf_inspect_size) buf_inspect_s64_size;
   case TAG_S32:
@@ -3535,6 +4020,8 @@ f_buf_inspect_size tag_type_to_buf_inspect_size (e_tag_type type)
     return (f_buf_inspect_size) buf_inspect_u32_size;
   case TAG_U64:
     return (f_buf_inspect_size) buf_inspect_u64_size;
+  case TAG_UW:
+    return (f_buf_inspect_size) buf_inspect_uw_size;
   case TAG_LIST:
     return (f_buf_inspect_size) buf_inspect_list_size;
   case TAG_PTAG:
@@ -3582,6 +4069,8 @@ f_buf_parse tag_type_to_buf_parse (e_tag_type type)
     return (f_buf_parse) buf_parse_ident;
   case TAG_INTEGER:
     return (f_buf_parse) buf_parse_integer;
+  case TAG_SW:
+    return (f_buf_parse) buf_parse_sw;
   case TAG_S64:
     return (f_buf_parse) buf_parse_s64;
   case TAG_S32:
@@ -3598,6 +4087,8 @@ f_buf_parse tag_type_to_buf_parse (e_tag_type type)
     return (f_buf_parse) buf_parse_u32;
   case TAG_U64:
     return (f_buf_parse) buf_parse_u64;
+  case TAG_UW:
+    return (f_buf_parse) buf_parse_uw;
   case TAG_LIST:
     return (f_buf_parse) buf_parse_list;
   case TAG_PTAG:
@@ -3657,6 +4148,8 @@ ffi_type * tag_type_to_ffi_type (e_tag_type type)
     return &ffi_type_sint32;
   case TAG_S64:
     return &ffi_type_sint64;
+  case TAG_SW:
+    return &ffi_type_slong;
   case TAG_STR:
     return &ffi_type_pointer;
   case TAG_SYM:
@@ -3671,6 +4164,8 @@ ffi_type * tag_type_to_ffi_type (e_tag_type type)
     return &ffi_type_uint32;
   case TAG_U64:
     return &ffi_type_uint64;
+  case TAG_UW:
+    return &ffi_type_ulong;
   case TAG_VAR:
     return &ffi_type_pointer;
   case TAG_VOID:
@@ -3697,6 +4192,7 @@ s8 * tag_type_to_string (e_tag_type type)
   case TAG_FN: return "fn";
   case TAG_IDENT: return "ident";
   case TAG_INTEGER: return "integer";
+  case TAG_SW: return "sw";
   case TAG_S64: return "s64";
   case TAG_S32: return "s32";
   case TAG_S16: return "s16";
@@ -3705,6 +4201,7 @@ s8 * tag_type_to_string (e_tag_type type)
   case TAG_U16: return "u16";
   case TAG_U32: return "u32";
   case TAG_U64: return "u64";
+  case TAG_UW: return "uw";
   case TAG_LIST: return "list";
   case TAG_PTAG: return "ptag";
   case TAG_QUOTE: return "quote";
@@ -3734,6 +4231,7 @@ const s_sym * tag_type_to_sym (e_tag_type tag_type)
   case TAG_FN:         return sym_1("fn");
   case TAG_IDENT:      return sym_1("ident");
   case TAG_INTEGER:    return sym_1("integer");
+  case TAG_SW:         return sym_1("sw");
   case TAG_S64:        return sym_1("s64");
   case TAG_S32:        return sym_1("s32");
   case TAG_S16:        return sym_1("s16");
@@ -3742,6 +4240,7 @@ const s_sym * tag_type_to_sym (e_tag_type tag_type)
   case TAG_U16:        return sym_1("u16");
   case TAG_U32:        return sym_1("u32");
   case TAG_U64:        return sym_1("u64");
+  case TAG_UW:         return sym_1("uw");
   case TAG_LIST:       return sym_1("list");
   case TAG_PTAG:       return sym_1("ptag");
   case TAG_QUOTE:      return sym_1("quote");
@@ -3783,6 +4282,13 @@ s_tag * tag_u64 (s_tag *tag, u64 x)
   return tag_init_u64(tag, x);
 }
 
+s_tag * tag_uw (s_tag *tag, uw x)
+{
+  assert(tag);
+  tag_clean(tag);
+  return tag_init_uw(tag, x);
+}
+
 s_tag * tag_var (s_tag *tag)
 {
   assert(tag);
diff --git a/libc3/tag.h b/libc3/tag.h
index be3d406..de9c303 100644
--- a/libc3/tag.h
+++ b/libc3/tag.h
@@ -30,14 +30,13 @@ extern s_tag g_tag_first;
 extern s_tag g_tag_last;
 
 /* Stack allocation compatible functions */
+void    tag_clean (s_tag *tag);
 s_tag * tag_init (s_tag *tag);
 s_tag * tag_init_1 (s_tag *tag, const s8 *p);
 s_tag * tag_init_array (s_tag *tag, const s_array *a);
 s_tag * tag_init_bool (s_tag *tag, bool p);
 s_tag * tag_init_call (s_tag *tag, const s_call *call);
 s_tag * tag_init_character (s_tag *tag, character c);
-s_tag * tag_init_f32 (s_tag *tag, f32 f);
-s_tag * tag_init_f64 (s_tag *tag, f64 f);
 s_tag * tag_init_ident (s_tag *tag, const s_ident *ident);
 s_tag * tag_init_ident_1 (s_tag *tag, const s8 *p);
 s_tag * tag_init_integer (s_tag *tag, const s_integer *i);
@@ -45,23 +44,28 @@ s_tag * tag_init_integer_1 (s_tag *tag, const s8 *p);
 s_tag * tag_init_integer_zero (s_tag *tag);
 s_tag * tag_init_list (s_tag *tag, s_list *list);
 s_tag * tag_init_list_1 (s_tag *tag, const s8 *p);
-s_tag * tag_init_s8 (s_tag *tag, s8 i);
-s_tag * tag_init_s16 (s_tag *tag, s16 i);
-s_tag * tag_init_s32 (s_tag *tag, s32 i);
-s_tag * tag_init_s64 (s_tag *tag, s64 i);
 s_tag * tag_init_str (s_tag *tag, s8 *free, uw size, const s8 *p);
 s_tag * tag_init_str_1 (s_tag *tag, s8 *free, const s8 *p);
 s_tag * tag_init_sym (s_tag *tag, const s_sym *p);
 s_tag * tag_init_sym_1 (s_tag *tag, const s8 *p);
 s_tag * tag_init_tuple (s_tag *tag, uw count);
 s_tag * tag_init_tuple_2 (s_tag *tag, s_tag *a, s_tag *b);
+s_tag * tag_init_var (s_tag *tag);
+s_tag * tag_init_void (s_tag *tag);
+
+/* Numbers */
+s_tag * tag_init_f32 (s_tag *tag, f32 f);
+s_tag * tag_init_f64 (s_tag *tag, f64 f);
+s_tag * tag_init_s8 (s_tag *tag, s8 i);
+s_tag * tag_init_s16 (s_tag *tag, s16 i);
+s_tag * tag_init_s32 (s_tag *tag, s32 i);
+s_tag * tag_init_s64 (s_tag *tag, s64 i);
+s_tag * tag_init_sw (s_tag *tag, sw i);
 s_tag * tag_init_u8 (s_tag *tag, u8 i);
 s_tag * tag_init_u16 (s_tag *tag, u16 i);
 s_tag * tag_init_u32 (s_tag *tag, u32 i);
 s_tag * tag_init_u64 (s_tag *tag, u64 i);
-s_tag * tag_init_var (s_tag *tag);
-s_tag * tag_init_void (s_tag *tag);
-void    tag_clean (s_tag *tag);
+s_tag * tag_init_uw (s_tag *tag, uw i);
 
 /* Constructors, call tag_delete after use */
 s_tag * tag_new ();
diff --git a/libc3/types.h b/libc3/types.h
index aada376..6770af1 100644
--- a/libc3/types.h
+++ b/libc3/types.h
@@ -80,6 +80,7 @@ typedef enum {
   TAG_FN,
   TAG_IDENT,
   TAG_INTEGER,
+  TAG_SW,
   TAG_S64,
   TAG_S32,
   TAG_S16,
@@ -88,6 +89,7 @@ typedef enum {
   TAG_U16,
   TAG_U32,
   TAG_U64,
+  TAG_UW,
   TAG_LIST,
   TAG_PTAG,
   TAG_QUOTE,
@@ -356,11 +358,13 @@ union tag_data {
   s16          s16;
   s32          s32;
   s64          s64;
+  sw           sw;
   s_tuple      tuple;
   u8           u8;
   u16          u16;
   u32          u32;
   u64          u64;
+  uw           uw;
 };
 
 /* 6 */
diff --git a/test/compare_test.c b/test/compare_test.c
index d8f69a3..f853260 100644
--- a/test/compare_test.c
+++ b/test/compare_test.c
@@ -21,8 +21,9 @@
     s_list *tmp_b = (b);                                               \
     test_context("compare_list(" # a ", " # b ") -> " # expected);     \
     TEST_EQ(compare_list(tmp_a, tmp_b), (expected));                   \
-    list_delete_all(tmp_a);                                                \
-    list_delete_all(tmp_b);                                                \
+    list_delete_all(tmp_a);                                            \
+    list_delete_all(tmp_b);                                            \
+    test_context(NULL);                                                \
   } while (0)
 
 #define COMPARE_TEST_TAG(a, b, expected)                               \
@@ -204,24 +205,24 @@ TEST_CASE(compare_tag)
                    tag_1(&b, "-0x10000000000000000"), 1);
   /* integer <> u8 */
   COMPARE_TEST_TAG(tag_1(&a, "0xFF"),
-                   tag_1(&b, "0x10000000000000000"), 1);
+                   tag_1(&b, "0x10000000000000000"), -1);
   COMPARE_TEST_TAG(tag_1(&a, "0x10000000000000000"),
-                   tag_1(&b, "0xFF"), -1);
+                   tag_1(&b, "0xFF"), 1);
   /* integer <> u16 */
   COMPARE_TEST_TAG(tag_1(&a, "0xFFFF"),
-                   tag_1(&b, "0x10000000000000000"), 1);
+                   tag_1(&b, "0x10000000000000000"), -1);
   COMPARE_TEST_TAG(tag_1(&a, "0x10000000000000000"),
-                   tag_1(&b, "0xFFFF"), -1);
+                   tag_1(&b, "0xFFFF"), 1);
   /* integer <> u32 */
   COMPARE_TEST_TAG(tag_1(&a, "0xFFFFFFFF"),
-                   tag_1(&b, "0x10000000000000000"), 1);
+                   tag_1(&b, "0x10000000000000000"), -1);
   COMPARE_TEST_TAG(tag_1(&a, "0x10000000000000000"),
-                   tag_1(&b, "0xFFFFFFFF"), -1);
+                   tag_1(&b, "0xFFFFFFFF"), 1);
   /* integer <> u64 */
   COMPARE_TEST_TAG(tag_1(&a, "0xFFFFFFFFFFFFFFFF"),
-                   tag_1(&b, "0x10000000000000000"), 1);
+                   tag_1(&b, "0x10000000000000000"), -1);
   COMPARE_TEST_TAG(tag_1(&a, "0x10000000000000000"),
-                   tag_1(&b, "0xFFFFFFFFFFFFFFFF"), -1);
+                   tag_1(&b, "0xFFFFFFFFFFFFFFFF"), 1);
   /* s8 <> s8 */
   COMPARE_TEST_TAG(tag_1(&a, "-0x7F"), tag_1(&b, "-0x7F"), 0);
   COMPARE_TEST_TAG(tag_1(&a, "-0x7F"), tag_1(&b, "-1"), -1);
diff --git a/test/facts_cursor_test.c b/test/facts_cursor_test.c
index fb245c2..0e70809 100644
--- a/test/facts_cursor_test.c
+++ b/test/facts_cursor_test.c
@@ -116,7 +116,6 @@ TEST_CASE(facts_cursor_next)
   s8 *p[24] = {
     "a",
     "-0x10000000000000000",
-    "0x10000000000000000",
     "-0x100000000",
     "-0x10000",
     "-0x100",
@@ -128,6 +127,7 @@ TEST_CASE(facts_cursor_next)
     "0x100",
     "0x10000",
     "0x100000000",
+    "0x10000000000000000",
     "()",
     "((), ())",
     "\"a\"",
diff --git a/test/facts_test_dump_file.expected.facts b/test/facts_test_dump_file.expected.facts
index cd38dd2..2eb5553 100644
--- a/test/facts_test_dump_file.expected.facts
+++ b/test/facts_test_dump_file.expected.facts
@@ -2,7 +2,6 @@
   version: 1}
 add {a, a, a}
 add {-18446744073709551616, -18446744073709551616, -18446744073709551616}
-add {18446744073709551616, 18446744073709551616, 18446744073709551616}
 add {-4294967296, -4294967296, -4294967296}
 add {-65536, -65536, -65536}
 add {-256, -256, -256}
@@ -14,6 +13,7 @@ add {10, 10, 10}
 add {256, 256, 256}
 add {65536, 65536, 65536}
 add {4294967296, 4294967296, 4294967296}
+add {18446744073709551616, 18446744073709551616, 18446744073709551616}
 add {(), (), ()}
 add {((), ()), ((), ()), ((), ())}
 add {"a", "a", "a"}
diff --git a/test/facts_test_save.expected.facts b/test/facts_test_save.expected.facts
index cd38dd2..2eb5553 100644
--- a/test/facts_test_save.expected.facts
+++ b/test/facts_test_save.expected.facts
@@ -2,7 +2,6 @@
   version: 1}
 add {a, a, a}
 add {-18446744073709551616, -18446744073709551616, -18446744073709551616}
-add {18446744073709551616, 18446744073709551616, 18446744073709551616}
 add {-4294967296, -4294967296, -4294967296}
 add {-65536, -65536, -65536}
 add {-256, -256, -256}
@@ -14,6 +13,7 @@ add {10, 10, 10}
 add {256, 256, 256}
 add {65536, 65536, 65536}
 add {4294967296, 4294967296, 4294967296}
+add {18446744073709551616, 18446744073709551616, 18446744073709551616}
 add {(), (), ()}
 add {((), ()), ((), ()), ((), ())}
 add {"a", "a", "a"}
diff --git a/test/ic3/array.in b/test/ic3/array.in
index f80d93d..bd82e6b 100644
--- a/test/ic3/array.in
+++ b/test/ic3/array.in
@@ -1,15 +1,75 @@
-(u8) {0, 1}
-(u8) {{0, 1},
-      {2, 3}}
-(u8) {{{0, 1},
-       {2, 3}},
-      {{4, 5},
-       {6, 7}}}
-(u8) {{{{0, 1},
-        {2, 3}},
-       {{4, 5},
-        {6, 7}}},
-      {{{8, 9},
-        {10, 11}},
-       {{12, 13},
-        {14, 15}}}}
+a = (u8) {0, 1}
+Array.data(a, (uw) {0})
+Array.data(a, (uw) {1})
+a[0]
+a[1]
+b = (u8) {{0, 1},
+          {2, 3}}
+Array.data(b, (uw) {0, 0})
+Array.data(b, (uw) {0, 1})
+Array.data(b, (uw) {1, 0})
+Array.data(b, (uw) {1, 1})
+b[0][0]
+b[0][1]
+b[1][0]
+b[1][1]
+c = (u8) {{{0, 1},
+           {2, 3}},
+          {{4, 5},
+           {6, 7}}}
+Array.data(c, (uw) {0, 0, 0})
+Array.data(c, (uw) {0, 0, 1})
+Array.data(c, (uw) {0, 1, 0})
+Array.data(c, (uw) {0, 1, 1})
+Array.data(c, (uw) {1, 0, 0})
+Array.data(c, (uw) {1, 0, 1})
+Array.data(c, (uw) {1, 1, 0})
+Array.data(c, (uw) {1, 1, 1})
+c[0][0][0]
+c[0][0][1]
+c[0][1][0]
+c[0][1][1]
+c[1][0][0]
+c[1][0][1]
+c[1][1][0]
+c[1][1][1]
+d = (u8) {{{{0, 1},
+            {2, 3}},
+           {{4, 5},
+            {6, 7}}},
+          {{{8, 9},
+            {10, 11}},
+           {{12, 13},
+            {14, 15}}}}
+Array.data(d, (uw) {0, 0, 0, 0})
+Array.data(d, (uw) {0, 0, 0, 1})
+Array.data(d, (uw) {0, 0, 1, 0})
+Array.data(d, (uw) {0, 0, 1, 1})
+Array.data(d, (uw) {0, 1, 0, 0})
+Array.data(d, (uw) {0, 1, 0, 1})
+Array.data(d, (uw) {0, 1, 1, 0})
+Array.data(d, (uw) {0, 1, 1, 1})
+Array.data(d, (uw) {1, 0, 0, 0})
+Array.data(d, (uw) {1, 0, 0, 1})
+Array.data(d, (uw) {1, 0, 1, 0})
+Array.data(d, (uw) {1, 0, 1, 1})
+Array.data(d, (uw) {1, 1, 0, 0})
+Array.data(d, (uw) {1, 1, 0, 1})
+Array.data(d, (uw) {1, 1, 1, 0})
+Array.data(d, (uw) {1, 1, 1, 1})
+d[0][0][0][0]
+d[0][0][0][1]
+d[0][0][1][0]
+d[0][0][1][1]
+d[0][1][0][0]
+d[0][1][0][1]
+d[0][1][1][0]
+d[0][1][1][1]
+d[1][0][0][0]
+d[1][0][0][1]
+d[1][0][1][0]
+d[1][0][1][1]
+d[1][1][0][0]
+d[1][1][0][1]
+d[1][1][1][0]
+d[1][1][1][1]
diff --git a/test/ic3/array.out.expected b/test/ic3/array.out.expected
index 2171adb..9ab6798 100644
--- a/test/ic3/array.out.expected
+++ b/test/ic3/array.out.expected
@@ -1,4 +1,64 @@
 (u8) {0, 1}
+0
+1
+0
+1
 (u8) {{0, 1}, {2, 3}}
+0
+1
+2
+3
+0
+1
+2
+3
 (u8) {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}}
+0
+1
+2
+3
+4
+5
+6
+7
+0
+1
+2
+3
+4
+5
+6
+7
 (u8) {{{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}}, {{{8, 9}, {10, 11}}, {{12, 13}, {14, 15}}}}
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
diff --git a/test/ic3/integer.in b/test/ic3/integer.in
index e9b034a..2d92c5d 100644
--- a/test/ic3/integer.in
+++ b/test/ic3/integer.in
@@ -1658,3 +1658,1203 @@
 340282366920938463463374607431768211456 / 18446744073709551616
 340282366920938463463374607431768211456 / 340282366920938463463374607431768211455
 340282366920938463463374607431768211456 / 340282366920938463463374607431768211456
+-170141183460469231731687303715884105728 < -170141183460469231731687303715884105728
+-170141183460469231731687303715884105728 < -170141183460469231731687303715884105727
+-170141183460469231731687303715884105728 < -9223372036854775808
+-170141183460469231731687303715884105728 < -9223372036854775807
+-170141183460469231731687303715884105728 < -2147483648
+-170141183460469231731687303715884105728 < -2147483647
+-170141183460469231731687303715884105728 < -32768
+-170141183460469231731687303715884105728 < -32767
+-170141183460469231731687303715884105728 < -128
+-170141183460469231731687303715884105728 < -127
+-170141183460469231731687303715884105728 < 255
+-170141183460469231731687303715884105728 < 256
+-170141183460469231731687303715884105728 < 65535
+-170141183460469231731687303715884105728 < 65536
+-170141183460469231731687303715884105728 < 4294967295
+-170141183460469231731687303715884105728 < 4294967296
+-170141183460469231731687303715884105728 < 18446744073709551615
+-170141183460469231731687303715884105728 < 18446744073709551616
+-170141183460469231731687303715884105728 < 340282366920938463463374607431768211455
+-170141183460469231731687303715884105728 < 340282366920938463463374607431768211456
+-170141183460469231731687303715884105727 < -170141183460469231731687303715884105728
+-170141183460469231731687303715884105727 < -170141183460469231731687303715884105727
+-170141183460469231731687303715884105727 < -9223372036854775808
+-170141183460469231731687303715884105727 < -9223372036854775807
+-170141183460469231731687303715884105727 < -2147483648
+-170141183460469231731687303715884105727 < -2147483647
+-170141183460469231731687303715884105727 < -32768
+-170141183460469231731687303715884105727 < -32767
+-170141183460469231731687303715884105727 < -128
+-170141183460469231731687303715884105727 < -127
+-170141183460469231731687303715884105727 < 255
+-170141183460469231731687303715884105727 < 256
+-170141183460469231731687303715884105727 < 65535
+-170141183460469231731687303715884105727 < 65536
+-170141183460469231731687303715884105727 < 4294967295
+-170141183460469231731687303715884105727 < 4294967296
+-170141183460469231731687303715884105727 < 18446744073709551615
+-170141183460469231731687303715884105727 < 18446744073709551616
+-170141183460469231731687303715884105727 < 340282366920938463463374607431768211455
+-170141183460469231731687303715884105727 < 340282366920938463463374607431768211456
+-9223372036854775808 < -170141183460469231731687303715884105728
+-9223372036854775808 < -170141183460469231731687303715884105727
+-9223372036854775808 < -9223372036854775808
+-9223372036854775808 < -9223372036854775807
+-9223372036854775808 < -2147483648
+-9223372036854775808 < -2147483647
+-9223372036854775808 < -32768
+-9223372036854775808 < -32767
+-9223372036854775808 < -128
+-9223372036854775808 < -127
+-9223372036854775808 < 255
+-9223372036854775808 < 256
+-9223372036854775808 < 65535
+-9223372036854775808 < 65536
+-9223372036854775808 < 4294967295
+-9223372036854775808 < 4294967296
+-9223372036854775808 < 18446744073709551615
+-9223372036854775808 < 18446744073709551616
+-9223372036854775808 < 340282366920938463463374607431768211455
+-9223372036854775808 < 340282366920938463463374607431768211456
+-9223372036854775807 < -170141183460469231731687303715884105728
+-9223372036854775807 < -170141183460469231731687303715884105727
+-9223372036854775807 < -9223372036854775808
+-9223372036854775807 < -9223372036854775807
+-9223372036854775807 < -2147483648
+-9223372036854775807 < -2147483647
+-9223372036854775807 < -32768
+-9223372036854775807 < -32767
+-9223372036854775807 < -128
+-9223372036854775807 < -127
+-9223372036854775807 < 255
+-9223372036854775807 < 256
+-9223372036854775807 < 65535
+-9223372036854775807 < 65536
+-9223372036854775807 < 4294967295
+-9223372036854775807 < 4294967296
+-9223372036854775807 < 18446744073709551615
+-9223372036854775807 < 18446744073709551616
+-9223372036854775807 < 340282366920938463463374607431768211455
+-9223372036854775807 < 340282366920938463463374607431768211456
+-2147483648 < -170141183460469231731687303715884105728
+-2147483648 < -170141183460469231731687303715884105727
+-2147483648 < -9223372036854775808
+-2147483648 < -9223372036854775807
+-2147483648 < -2147483648
+-2147483648 < -2147483647
+-2147483648 < -32768
+-2147483648 < -32767
+-2147483648 < -128
+-2147483648 < -127
+-2147483648 < 255
+-2147483648 < 256
+-2147483648 < 65535
+-2147483648 < 65536
+-2147483648 < 4294967295
+-2147483648 < 4294967296
+-2147483648 < 18446744073709551615
+-2147483648 < 18446744073709551616
+-2147483648 < 340282366920938463463374607431768211455
+-2147483648 < 340282366920938463463374607431768211456
+-2147483647 < -170141183460469231731687303715884105728
+-2147483647 < -170141183460469231731687303715884105727
+-2147483647 < -9223372036854775808
+-2147483647 < -9223372036854775807
+-2147483647 < -2147483648
+-2147483647 < -2147483647
+-2147483647 < -32768
+-2147483647 < -32767
+-2147483647 < -128
+-2147483647 < -127
+-2147483647 < 255
+-2147483647 < 256
+-2147483647 < 65535
+-2147483647 < 65536
+-2147483647 < 4294967295
+-2147483647 < 4294967296
+-2147483647 < 18446744073709551615
+-2147483647 < 18446744073709551616
+-2147483647 < 340282366920938463463374607431768211455
+-2147483647 < 340282366920938463463374607431768211456
+-32768 < -170141183460469231731687303715884105728
+-32768 < -170141183460469231731687303715884105727
+-32768 < -9223372036854775808
+-32768 < -9223372036854775807
+-32768 < -2147483648
+-32768 < -2147483647
+-32768 < -32768
+-32768 < -32767
+-32768 < -128
+-32768 < -127
+-32768 < 255
+-32768 < 256
+-32768 < 65535
+-32768 < 65536
+-32768 < 4294967295
+-32768 < 4294967296
+-32768 < 18446744073709551615
+-32768 < 18446744073709551616
+-32768 < 340282366920938463463374607431768211455
+-32768 < 340282366920938463463374607431768211456
+-32767 < -170141183460469231731687303715884105728
+-32767 < -170141183460469231731687303715884105727
+-32767 < -9223372036854775808
+-32767 < -9223372036854775807
+-32767 < -2147483648
+-32767 < -2147483647
+-32767 < -32768
+-32767 < -32767
+-32767 < -128
+-32767 < -127
+-32767 < 255
+-32767 < 256
+-32767 < 65535
+-32767 < 65536
+-32767 < 4294967295
+-32767 < 4294967296
+-32767 < 18446744073709551615
+-32767 < 18446744073709551616
+-32767 < 340282366920938463463374607431768211455
+-32767 < 340282366920938463463374607431768211456
+-128 < -170141183460469231731687303715884105728
+-128 < -170141183460469231731687303715884105727
+-128 < -9223372036854775808
+-128 < -9223372036854775807
+-128 < -2147483648
+-128 < -2147483647
+-128 < -32768
+-128 < -32767
+-128 < -128
+-128 < -127
+-128 < 255
+-128 < 256
+-128 < 65535
+-128 < 65536
+-128 < 4294967295
+-128 < 4294967296
+-128 < 18446744073709551615
+-128 < 18446744073709551616
+-128 < 340282366920938463463374607431768211455
+-128 < 340282366920938463463374607431768211456
+-127 < -170141183460469231731687303715884105728
+-127 < -170141183460469231731687303715884105727
+-127 < -9223372036854775808
+-127 < -9223372036854775807
+-127 < -2147483648
+-127 < -2147483647
+-127 < -32768
+-127 < -32767
+-127 < -128
+-127 < -127
+-127 < 255
+-127 < 256
+-127 < 65535
+-127 < 65536
+-127 < 4294967295
+-127 < 4294967296
+-127 < 18446744073709551615
+-127 < 18446744073709551616
+-127 < 340282366920938463463374607431768211455
+-127 < 340282366920938463463374607431768211456
+255 < -170141183460469231731687303715884105728
+255 < -170141183460469231731687303715884105727
+255 < -9223372036854775808
+255 < -9223372036854775807
+255 < -2147483648
+255 < -2147483647
+255 < -32768
+255 < -32767
+255 < -128
+255 < -127
+255 < 255
+255 < 256
+255 < 65535
+255 < 65536
+255 < 4294967295
+255 < 4294967296
+255 < 18446744073709551615
+255 < 18446744073709551616
+255 < 340282366920938463463374607431768211455
+255 < 340282366920938463463374607431768211456
+256 < -170141183460469231731687303715884105728
+256 < -170141183460469231731687303715884105727
+256 < -9223372036854775808
+256 < -9223372036854775807
+256 < -2147483648
+256 < -2147483647
+256 < -32768
+256 < -32767
+256 < -128
+256 < -127
+256 < 255
+256 < 256
+256 < 65535
+256 < 65536
+256 < 4294967295
+256 < 4294967296
+256 < 18446744073709551615
+256 < 18446744073709551616
+256 < 340282366920938463463374607431768211455
+256 < 340282366920938463463374607431768211456
+65535 < -170141183460469231731687303715884105728
+65535 < -170141183460469231731687303715884105727
+65535 < -9223372036854775808
+65535 < -9223372036854775807
+65535 < -2147483648
+65535 < -2147483647
+65535 < -32768
+65535 < -32767
+65535 < -128
+65535 < -127
+65535 < 255
+65535 < 256
+65535 < 65535
+65535 < 65536
+65535 < 4294967295
+65535 < 4294967296
+65535 < 18446744073709551615
+65535 < 18446744073709551616
+65535 < 340282366920938463463374607431768211455
+65535 < 340282366920938463463374607431768211456
+65536 < -170141183460469231731687303715884105728
+65536 < -170141183460469231731687303715884105727
+65536 < -9223372036854775808
+65536 < -9223372036854775807
+65536 < -2147483648
+65536 < -2147483647
+65536 < -32768
+65536 < -32767
+65536 < -128
+65536 < -127
+65536 < 255
+65536 < 256
+65536 < 65535
+65536 < 65536
+65536 < 4294967295
+65536 < 4294967296
+65536 < 18446744073709551615
+65536 < 18446744073709551616
+65536 < 340282366920938463463374607431768211455
+65536 < 340282366920938463463374607431768211456
+4294967295 < -170141183460469231731687303715884105728
+4294967295 < -170141183460469231731687303715884105727
+4294967295 < -9223372036854775808
+4294967295 < -9223372036854775807
+4294967295 < -2147483648
+4294967295 < -2147483647
+4294967295 < -32768
+4294967295 < -32767
+4294967295 < -128
+4294967295 < -127
+4294967295 < 255
+4294967295 < 256
+4294967295 < 65535
+4294967295 < 65536
+4294967295 < 4294967295
+4294967295 < 4294967296
+4294967295 < 18446744073709551615
+4294967295 < 18446744073709551616
+4294967295 < 340282366920938463463374607431768211455
+4294967295 < 340282366920938463463374607431768211456
+4294967296 < -170141183460469231731687303715884105728
+4294967296 < -170141183460469231731687303715884105727
+4294967296 < -9223372036854775808
+4294967296 < -9223372036854775807
+4294967296 < -2147483648
+4294967296 < -2147483647
+4294967296 < -32768
+4294967296 < -32767
+4294967296 < -128
+4294967296 < -127
+4294967296 < 255
+4294967296 < 256
+4294967296 < 65535
+4294967296 < 65536
+4294967296 < 4294967295
+4294967296 < 4294967296
+4294967296 < 18446744073709551615
+4294967296 < 18446744073709551616
+4294967296 < 340282366920938463463374607431768211455
+4294967296 < 340282366920938463463374607431768211456
+18446744073709551615 < -170141183460469231731687303715884105728
+18446744073709551615 < -170141183460469231731687303715884105727
+18446744073709551615 < -9223372036854775808
+18446744073709551615 < -9223372036854775807
+18446744073709551615 < -2147483648
+18446744073709551615 < -2147483647
+18446744073709551615 < -32768
+18446744073709551615 < -32767
+18446744073709551615 < -128
+18446744073709551615 < -127
+18446744073709551615 < 255
+18446744073709551615 < 256
+18446744073709551615 < 65535
+18446744073709551615 < 65536
+18446744073709551615 < 4294967295
+18446744073709551615 < 4294967296
+18446744073709551615 < 18446744073709551615
+18446744073709551615 < 18446744073709551616
+18446744073709551615 < 340282366920938463463374607431768211455
+18446744073709551615 < 340282366920938463463374607431768211456
+18446744073709551616 < -170141183460469231731687303715884105728
+18446744073709551616 < -170141183460469231731687303715884105727
+18446744073709551616 < -9223372036854775808
+18446744073709551616 < -9223372036854775807
+18446744073709551616 < -2147483648
+18446744073709551616 < -2147483647
+18446744073709551616 < -32768
+18446744073709551616 < -32767
+18446744073709551616 < -128
+18446744073709551616 < -127
+18446744073709551616 < 255
+18446744073709551616 < 256
+18446744073709551616 < 65535
+18446744073709551616 < 65536
+18446744073709551616 < 4294967295
+18446744073709551616 < 4294967296
+18446744073709551616 < 18446744073709551615
+18446744073709551616 < 18446744073709551616
+18446744073709551616 < 340282366920938463463374607431768211455
+18446744073709551616 < 340282366920938463463374607431768211456
+340282366920938463463374607431768211455 < -170141183460469231731687303715884105728
+340282366920938463463374607431768211455 < -170141183460469231731687303715884105727
+340282366920938463463374607431768211455 < -9223372036854775808
+340282366920938463463374607431768211455 < -9223372036854775807
+340282366920938463463374607431768211455 < -2147483648
+340282366920938463463374607431768211455 < -2147483647
+340282366920938463463374607431768211455 < -32768
+340282366920938463463374607431768211455 < -32767
+340282366920938463463374607431768211455 < -128
+340282366920938463463374607431768211455 < -127
+340282366920938463463374607431768211455 < 255
+340282366920938463463374607431768211455 < 256
+340282366920938463463374607431768211455 < 65535
+340282366920938463463374607431768211455 < 65536
+340282366920938463463374607431768211455 < 4294967295
+340282366920938463463374607431768211455 < 4294967296
+340282366920938463463374607431768211455 < 18446744073709551615
+340282366920938463463374607431768211455 < 18446744073709551616
+340282366920938463463374607431768211455 < 340282366920938463463374607431768211455
+340282366920938463463374607431768211455 < 340282366920938463463374607431768211456
+340282366920938463463374607431768211456 < -170141183460469231731687303715884105728
+340282366920938463463374607431768211456 < -170141183460469231731687303715884105727
+340282366920938463463374607431768211456 < -9223372036854775808
+340282366920938463463374607431768211456 < -9223372036854775807
+340282366920938463463374607431768211456 < -2147483648
+340282366920938463463374607431768211456 < -2147483647
+340282366920938463463374607431768211456 < -32768
+340282366920938463463374607431768211456 < -32767
+340282366920938463463374607431768211456 < -128
+340282366920938463463374607431768211456 < -127
+340282366920938463463374607431768211456 < 255
+340282366920938463463374607431768211456 < 256
+340282366920938463463374607431768211456 < 65535
+340282366920938463463374607431768211456 < 65536
+340282366920938463463374607431768211456 < 4294967295
+340282366920938463463374607431768211456 < 4294967296
+340282366920938463463374607431768211456 < 18446744073709551615
+340282366920938463463374607431768211456 < 18446744073709551616
+340282366920938463463374607431768211456 < 340282366920938463463374607431768211455
+340282366920938463463374607431768211456 < 340282366920938463463374607431768211456
+-170141183460469231731687303715884105728 == -170141183460469231731687303715884105728
+-170141183460469231731687303715884105728 == -170141183460469231731687303715884105727
+-170141183460469231731687303715884105728 == -9223372036854775808
+-170141183460469231731687303715884105728 == -9223372036854775807
+-170141183460469231731687303715884105728 == -2147483648
+-170141183460469231731687303715884105728 == -2147483647
+-170141183460469231731687303715884105728 == -32768
+-170141183460469231731687303715884105728 == -32767
+-170141183460469231731687303715884105728 == -128
+-170141183460469231731687303715884105728 == -127
+-170141183460469231731687303715884105728 == 255
+-170141183460469231731687303715884105728 == 256
+-170141183460469231731687303715884105728 == 65535
+-170141183460469231731687303715884105728 == 65536
+-170141183460469231731687303715884105728 == 4294967295
+-170141183460469231731687303715884105728 == 4294967296
+-170141183460469231731687303715884105728 == 18446744073709551615
+-170141183460469231731687303715884105728 == 18446744073709551616
+-170141183460469231731687303715884105728 == 340282366920938463463374607431768211455
+-170141183460469231731687303715884105728 == 340282366920938463463374607431768211456
+-170141183460469231731687303715884105727 == -170141183460469231731687303715884105728
+-170141183460469231731687303715884105727 == -170141183460469231731687303715884105727
+-170141183460469231731687303715884105727 == -9223372036854775808
+-170141183460469231731687303715884105727 == -9223372036854775807
+-170141183460469231731687303715884105727 == -2147483648
+-170141183460469231731687303715884105727 == -2147483647
+-170141183460469231731687303715884105727 == -32768
+-170141183460469231731687303715884105727 == -32767
+-170141183460469231731687303715884105727 == -128
+-170141183460469231731687303715884105727 == -127
+-170141183460469231731687303715884105727 == 255
+-170141183460469231731687303715884105727 == 256
+-170141183460469231731687303715884105727 == 65535
+-170141183460469231731687303715884105727 == 65536
+-170141183460469231731687303715884105727 == 4294967295
+-170141183460469231731687303715884105727 == 4294967296
+-170141183460469231731687303715884105727 == 18446744073709551615
+-170141183460469231731687303715884105727 == 18446744073709551616
+-170141183460469231731687303715884105727 == 340282366920938463463374607431768211455
+-170141183460469231731687303715884105727 == 340282366920938463463374607431768211456
+-9223372036854775808 == -170141183460469231731687303715884105728
+-9223372036854775808 == -170141183460469231731687303715884105727
+-9223372036854775808 == -9223372036854775808
+-9223372036854775808 == -9223372036854775807
+-9223372036854775808 == -2147483648
+-9223372036854775808 == -2147483647
+-9223372036854775808 == -32768
+-9223372036854775808 == -32767
+-9223372036854775808 == -128
+-9223372036854775808 == -127
+-9223372036854775808 == 255
+-9223372036854775808 == 256
+-9223372036854775808 == 65535
+-9223372036854775808 == 65536
+-9223372036854775808 == 4294967295
+-9223372036854775808 == 4294967296
+-9223372036854775808 == 18446744073709551615
+-9223372036854775808 == 18446744073709551616
+-9223372036854775808 == 340282366920938463463374607431768211455
+-9223372036854775808 == 340282366920938463463374607431768211456
+-9223372036854775807 == -170141183460469231731687303715884105728
+-9223372036854775807 == -170141183460469231731687303715884105727
+-9223372036854775807 == -9223372036854775808
+-9223372036854775807 == -9223372036854775807
+-9223372036854775807 == -2147483648
+-9223372036854775807 == -2147483647
+-9223372036854775807 == -32768
+-9223372036854775807 == -32767
+-9223372036854775807 == -128
+-9223372036854775807 == -127
+-9223372036854775807 == 255
+-9223372036854775807 == 256
+-9223372036854775807 == 65535
+-9223372036854775807 == 65536
+-9223372036854775807 == 4294967295
+-9223372036854775807 == 4294967296
+-9223372036854775807 == 18446744073709551615
+-9223372036854775807 == 18446744073709551616
+-9223372036854775807 == 340282366920938463463374607431768211455
+-9223372036854775807 == 340282366920938463463374607431768211456
+-2147483648 == -170141183460469231731687303715884105728
+-2147483648 == -170141183460469231731687303715884105727
+-2147483648 == -9223372036854775808
+-2147483648 == -9223372036854775807
+-2147483648 == -2147483648
+-2147483648 == -2147483647
+-2147483648 == -32768
+-2147483648 == -32767
+-2147483648 == -128
+-2147483648 == -127
+-2147483648 == 255
+-2147483648 == 256
+-2147483648 == 65535
+-2147483648 == 65536
+-2147483648 == 4294967295
+-2147483648 == 4294967296
+-2147483648 == 18446744073709551615
+-2147483648 == 18446744073709551616
+-2147483648 == 340282366920938463463374607431768211455
+-2147483648 == 340282366920938463463374607431768211456
+-2147483647 == -170141183460469231731687303715884105728
+-2147483647 == -170141183460469231731687303715884105727
+-2147483647 == -9223372036854775808
+-2147483647 == -9223372036854775807
+-2147483647 == -2147483648
+-2147483647 == -2147483647
+-2147483647 == -32768
+-2147483647 == -32767
+-2147483647 == -128
+-2147483647 == -127
+-2147483647 == 255
+-2147483647 == 256
+-2147483647 == 65535
+-2147483647 == 65536
+-2147483647 == 4294967295
+-2147483647 == 4294967296
+-2147483647 == 18446744073709551615
+-2147483647 == 18446744073709551616
+-2147483647 == 340282366920938463463374607431768211455
+-2147483647 == 340282366920938463463374607431768211456
+-32768 == -170141183460469231731687303715884105728
+-32768 == -170141183460469231731687303715884105727
+-32768 == -9223372036854775808
+-32768 == -9223372036854775807
+-32768 == -2147483648
+-32768 == -2147483647
+-32768 == -32768
+-32768 == -32767
+-32768 == -128
+-32768 == -127
+-32768 == 255
+-32768 == 256
+-32768 == 65535
+-32768 == 65536
+-32768 == 4294967295
+-32768 == 4294967296
+-32768 == 18446744073709551615
+-32768 == 18446744073709551616
+-32768 == 340282366920938463463374607431768211455
+-32768 == 340282366920938463463374607431768211456
+-32767 == -170141183460469231731687303715884105728
+-32767 == -170141183460469231731687303715884105727
+-32767 == -9223372036854775808
+-32767 == -9223372036854775807
+-32767 == -2147483648
+-32767 == -2147483647
+-32767 == -32768
+-32767 == -32767
+-32767 == -128
+-32767 == -127
+-32767 == 255
+-32767 == 256
+-32767 == 65535
+-32767 == 65536
+-32767 == 4294967295
+-32767 == 4294967296
+-32767 == 18446744073709551615
+-32767 == 18446744073709551616
+-32767 == 340282366920938463463374607431768211455
+-32767 == 340282366920938463463374607431768211456
+-128 == -170141183460469231731687303715884105728
+-128 == -170141183460469231731687303715884105727
+-128 == -9223372036854775808
+-128 == -9223372036854775807
+-128 == -2147483648
+-128 == -2147483647
+-128 == -32768
+-128 == -32767
+-128 == -128
+-128 == -127
+-128 == 255
+-128 == 256
+-128 == 65535
+-128 == 65536
+-128 == 4294967295
+-128 == 4294967296
+-128 == 18446744073709551615
+-128 == 18446744073709551616
+-128 == 340282366920938463463374607431768211455
+-128 == 340282366920938463463374607431768211456
+-127 == -170141183460469231731687303715884105728
+-127 == -170141183460469231731687303715884105727
+-127 == -9223372036854775808
+-127 == -9223372036854775807
+-127 == -2147483648
+-127 == -2147483647
+-127 == -32768
+-127 == -32767
+-127 == -128
+-127 == -127
+-127 == 255
+-127 == 256
+-127 == 65535
+-127 == 65536
+-127 == 4294967295
+-127 == 4294967296
+-127 == 18446744073709551615
+-127 == 18446744073709551616
+-127 == 340282366920938463463374607431768211455
+-127 == 340282366920938463463374607431768211456
+255 == -170141183460469231731687303715884105728
+255 == -170141183460469231731687303715884105727
+255 == -9223372036854775808
+255 == -9223372036854775807
+255 == -2147483648
+255 == -2147483647
+255 == -32768
+255 == -32767
+255 == -128
+255 == -127
+255 == 255
+255 == 256
+255 == 65535
+255 == 65536
+255 == 4294967295
+255 == 4294967296
+255 == 18446744073709551615
+255 == 18446744073709551616
+255 == 340282366920938463463374607431768211455
+255 == 340282366920938463463374607431768211456
+256 == -170141183460469231731687303715884105728
+256 == -170141183460469231731687303715884105727
+256 == -9223372036854775808
+256 == -9223372036854775807
+256 == -2147483648
+256 == -2147483647
+256 == -32768
+256 == -32767
+256 == -128
+256 == -127
+256 == 255
+256 == 256
+256 == 65535
+256 == 65536
+256 == 4294967295
+256 == 4294967296
+256 == 18446744073709551615
+256 == 18446744073709551616
+256 == 340282366920938463463374607431768211455
+256 == 340282366920938463463374607431768211456
+65535 == -170141183460469231731687303715884105728
+65535 == -170141183460469231731687303715884105727
+65535 == -9223372036854775808
+65535 == -9223372036854775807
+65535 == -2147483648
+65535 == -2147483647
+65535 == -32768
+65535 == -32767
+65535 == -128
+65535 == -127
+65535 == 255
+65535 == 256
+65535 == 65535
+65535 == 65536
+65535 == 4294967295
+65535 == 4294967296
+65535 == 18446744073709551615
+65535 == 18446744073709551616
+65535 == 340282366920938463463374607431768211455
+65535 == 340282366920938463463374607431768211456
+65536 == -170141183460469231731687303715884105728
+65536 == -170141183460469231731687303715884105727
+65536 == -9223372036854775808
+65536 == -9223372036854775807
+65536 == -2147483648
+65536 == -2147483647
+65536 == -32768
+65536 == -32767
+65536 == -128
+65536 == -127
+65536 == 255
+65536 == 256
+65536 == 65535
+65536 == 65536
+65536 == 4294967295
+65536 == 4294967296
+65536 == 18446744073709551615
+65536 == 18446744073709551616
+65536 == 340282366920938463463374607431768211455
+65536 == 340282366920938463463374607431768211456
+4294967295 == -170141183460469231731687303715884105728
+4294967295 == -170141183460469231731687303715884105727
+4294967295 == -9223372036854775808
+4294967295 == -9223372036854775807
+4294967295 == -2147483648
+4294967295 == -2147483647
+4294967295 == -32768
+4294967295 == -32767
+4294967295 == -128
+4294967295 == -127
+4294967295 == 255
+4294967295 == 256
+4294967295 == 65535
+4294967295 == 65536
+4294967295 == 4294967295
+4294967295 == 4294967296
+4294967295 == 18446744073709551615
+4294967295 == 18446744073709551616
+4294967295 == 340282366920938463463374607431768211455
+4294967295 == 340282366920938463463374607431768211456
+4294967296 == -170141183460469231731687303715884105728
+4294967296 == -170141183460469231731687303715884105727
+4294967296 == -9223372036854775808
+4294967296 == -9223372036854775807
+4294967296 == -2147483648
+4294967296 == -2147483647
+4294967296 == -32768
+4294967296 == -32767
+4294967296 == -128
+4294967296 == -127
+4294967296 == 255
+4294967296 == 256
+4294967296 == 65535
+4294967296 == 65536
+4294967296 == 4294967295
+4294967296 == 4294967296
+4294967296 == 18446744073709551615
+4294967296 == 18446744073709551616
+4294967296 == 340282366920938463463374607431768211455
+4294967296 == 340282366920938463463374607431768211456
+18446744073709551615 == -170141183460469231731687303715884105728
+18446744073709551615 == -170141183460469231731687303715884105727
+18446744073709551615 == -9223372036854775808
+18446744073709551615 == -9223372036854775807
+18446744073709551615 == -2147483648
+18446744073709551615 == -2147483647
+18446744073709551615 == -32768
+18446744073709551615 == -32767
+18446744073709551615 == -128
+18446744073709551615 == -127
+18446744073709551615 == 255
+18446744073709551615 == 256
+18446744073709551615 == 65535
+18446744073709551615 == 65536
+18446744073709551615 == 4294967295
+18446744073709551615 == 4294967296
+18446744073709551615 == 18446744073709551615
+18446744073709551615 == 18446744073709551616
+18446744073709551615 == 340282366920938463463374607431768211455
+18446744073709551615 == 340282366920938463463374607431768211456
+18446744073709551616 == -170141183460469231731687303715884105728
+18446744073709551616 == -170141183460469231731687303715884105727
+18446744073709551616 == -9223372036854775808
+18446744073709551616 == -9223372036854775807
+18446744073709551616 == -2147483648
+18446744073709551616 == -2147483647
+18446744073709551616 == -32768
+18446744073709551616 == -32767
+18446744073709551616 == -128
+18446744073709551616 == -127
+18446744073709551616 == 255
+18446744073709551616 == 256
+18446744073709551616 == 65535
+18446744073709551616 == 65536
+18446744073709551616 == 4294967295
+18446744073709551616 == 4294967296
+18446744073709551616 == 18446744073709551615
+18446744073709551616 == 18446744073709551616
+18446744073709551616 == 340282366920938463463374607431768211455
+18446744073709551616 == 340282366920938463463374607431768211456
+340282366920938463463374607431768211455 == -170141183460469231731687303715884105728
+340282366920938463463374607431768211455 == -170141183460469231731687303715884105727
+340282366920938463463374607431768211455 == -9223372036854775808
+340282366920938463463374607431768211455 == -9223372036854775807
+340282366920938463463374607431768211455 == -2147483648
+340282366920938463463374607431768211455 == -2147483647
+340282366920938463463374607431768211455 == -32768
+340282366920938463463374607431768211455 == -32767
+340282366920938463463374607431768211455 == -128
+340282366920938463463374607431768211455 == -127
+340282366920938463463374607431768211455 == 255
+340282366920938463463374607431768211455 == 256
+340282366920938463463374607431768211455 == 65535
+340282366920938463463374607431768211455 == 65536
+340282366920938463463374607431768211455 == 4294967295
+340282366920938463463374607431768211455 == 4294967296
+340282366920938463463374607431768211455 == 18446744073709551615
+340282366920938463463374607431768211455 == 18446744073709551616
+340282366920938463463374607431768211455 == 340282366920938463463374607431768211455
+340282366920938463463374607431768211455 == 340282366920938463463374607431768211456
+340282366920938463463374607431768211456 == -170141183460469231731687303715884105728
+340282366920938463463374607431768211456 == -170141183460469231731687303715884105727
+340282366920938463463374607431768211456 == -9223372036854775808
+340282366920938463463374607431768211456 == -9223372036854775807
+340282366920938463463374607431768211456 == -2147483648
+340282366920938463463374607431768211456 == -2147483647
+340282366920938463463374607431768211456 == -32768
+340282366920938463463374607431768211456 == -32767
+340282366920938463463374607431768211456 == -128
+340282366920938463463374607431768211456 == -127
+340282366920938463463374607431768211456 == 255
+340282366920938463463374607431768211456 == 256
+340282366920938463463374607431768211456 == 65535
+340282366920938463463374607431768211456 == 65536
+340282366920938463463374607431768211456 == 4294967295
+340282366920938463463374607431768211456 == 4294967296
+340282366920938463463374607431768211456 == 18446744073709551615
+340282366920938463463374607431768211456 == 18446744073709551616
+340282366920938463463374607431768211456 == 340282366920938463463374607431768211455
+340282366920938463463374607431768211456 == 340282366920938463463374607431768211456
+-170141183460469231731687303715884105728 > -170141183460469231731687303715884105728
+-170141183460469231731687303715884105728 > -170141183460469231731687303715884105727
+-170141183460469231731687303715884105728 > -9223372036854775808
+-170141183460469231731687303715884105728 > -9223372036854775807
+-170141183460469231731687303715884105728 > -2147483648
+-170141183460469231731687303715884105728 > -2147483647
+-170141183460469231731687303715884105728 > -32768
+-170141183460469231731687303715884105728 > -32767
+-170141183460469231731687303715884105728 > -128
+-170141183460469231731687303715884105728 > -127
+-170141183460469231731687303715884105728 > 255
+-170141183460469231731687303715884105728 > 256
+-170141183460469231731687303715884105728 > 65535
+-170141183460469231731687303715884105728 > 65536
+-170141183460469231731687303715884105728 > 4294967295
+-170141183460469231731687303715884105728 > 4294967296
+-170141183460469231731687303715884105728 > 18446744073709551615
+-170141183460469231731687303715884105728 > 18446744073709551616
+-170141183460469231731687303715884105728 > 340282366920938463463374607431768211455
+-170141183460469231731687303715884105728 > 340282366920938463463374607431768211456
+-170141183460469231731687303715884105727 > -170141183460469231731687303715884105728
+-170141183460469231731687303715884105727 > -170141183460469231731687303715884105727
+-170141183460469231731687303715884105727 > -9223372036854775808
+-170141183460469231731687303715884105727 > -9223372036854775807
+-170141183460469231731687303715884105727 > -2147483648
+-170141183460469231731687303715884105727 > -2147483647
+-170141183460469231731687303715884105727 > -32768
+-170141183460469231731687303715884105727 > -32767
+-170141183460469231731687303715884105727 > -128
+-170141183460469231731687303715884105727 > -127
+-170141183460469231731687303715884105727 > 255
+-170141183460469231731687303715884105727 > 256
+-170141183460469231731687303715884105727 > 65535
+-170141183460469231731687303715884105727 > 65536
+-170141183460469231731687303715884105727 > 4294967295
+-170141183460469231731687303715884105727 > 4294967296
+-170141183460469231731687303715884105727 > 18446744073709551615
+-170141183460469231731687303715884105727 > 18446744073709551616
+-170141183460469231731687303715884105727 > 340282366920938463463374607431768211455
+-170141183460469231731687303715884105727 > 340282366920938463463374607431768211456
+-9223372036854775808 > -170141183460469231731687303715884105728
+-9223372036854775808 > -170141183460469231731687303715884105727
+-9223372036854775808 > -9223372036854775808
+-9223372036854775808 > -9223372036854775807
+-9223372036854775808 > -2147483648
+-9223372036854775808 > -2147483647
+-9223372036854775808 > -32768
+-9223372036854775808 > -32767
+-9223372036854775808 > -128
+-9223372036854775808 > -127
+-9223372036854775808 > 255
+-9223372036854775808 > 256
+-9223372036854775808 > 65535
+-9223372036854775808 > 65536
+-9223372036854775808 > 4294967295
+-9223372036854775808 > 4294967296
+-9223372036854775808 > 18446744073709551615
+-9223372036854775808 > 18446744073709551616
+-9223372036854775808 > 340282366920938463463374607431768211455
+-9223372036854775808 > 340282366920938463463374607431768211456
+-9223372036854775807 > -170141183460469231731687303715884105728
+-9223372036854775807 > -170141183460469231731687303715884105727
+-9223372036854775807 > -9223372036854775808
+-9223372036854775807 > -9223372036854775807
+-9223372036854775807 > -2147483648
+-9223372036854775807 > -2147483647
+-9223372036854775807 > -32768
+-9223372036854775807 > -32767
+-9223372036854775807 > -128
+-9223372036854775807 > -127
+-9223372036854775807 > 255
+-9223372036854775807 > 256
+-9223372036854775807 > 65535
+-9223372036854775807 > 65536
+-9223372036854775807 > 4294967295
+-9223372036854775807 > 4294967296
+-9223372036854775807 > 18446744073709551615
+-9223372036854775807 > 18446744073709551616
+-9223372036854775807 > 340282366920938463463374607431768211455
+-9223372036854775807 > 340282366920938463463374607431768211456
+-2147483648 > -170141183460469231731687303715884105728
+-2147483648 > -170141183460469231731687303715884105727
+-2147483648 > -9223372036854775808
+-2147483648 > -9223372036854775807
+-2147483648 > -2147483648
+-2147483648 > -2147483647
+-2147483648 > -32768
+-2147483648 > -32767
+-2147483648 > -128
+-2147483648 > -127
+-2147483648 > 255
+-2147483648 > 256
+-2147483648 > 65535
+-2147483648 > 65536
+-2147483648 > 4294967295
+-2147483648 > 4294967296
+-2147483648 > 18446744073709551615
+-2147483648 > 18446744073709551616
+-2147483648 > 340282366920938463463374607431768211455
+-2147483648 > 340282366920938463463374607431768211456
+-2147483647 > -170141183460469231731687303715884105728
+-2147483647 > -170141183460469231731687303715884105727
+-2147483647 > -9223372036854775808
+-2147483647 > -9223372036854775807
+-2147483647 > -2147483648
+-2147483647 > -2147483647
+-2147483647 > -32768
+-2147483647 > -32767
+-2147483647 > -128
+-2147483647 > -127
+-2147483647 > 255
+-2147483647 > 256
+-2147483647 > 65535
+-2147483647 > 65536
+-2147483647 > 4294967295
+-2147483647 > 4294967296
+-2147483647 > 18446744073709551615
+-2147483647 > 18446744073709551616
+-2147483647 > 340282366920938463463374607431768211455
+-2147483647 > 340282366920938463463374607431768211456
+-32768 > -170141183460469231731687303715884105728
+-32768 > -170141183460469231731687303715884105727
+-32768 > -9223372036854775808
+-32768 > -9223372036854775807
+-32768 > -2147483648
+-32768 > -2147483647
+-32768 > -32768
+-32768 > -32767
+-32768 > -128
+-32768 > -127
+-32768 > 255
+-32768 > 256
+-32768 > 65535
+-32768 > 65536
+-32768 > 4294967295
+-32768 > 4294967296
+-32768 > 18446744073709551615
+-32768 > 18446744073709551616
+-32768 > 340282366920938463463374607431768211455
+-32768 > 340282366920938463463374607431768211456
+-32767 > -170141183460469231731687303715884105728
+-32767 > -170141183460469231731687303715884105727
+-32767 > -9223372036854775808
+-32767 > -9223372036854775807
+-32767 > -2147483648
+-32767 > -2147483647
+-32767 > -32768
+-32767 > -32767
+-32767 > -128
+-32767 > -127
+-32767 > 255
+-32767 > 256
+-32767 > 65535
+-32767 > 65536
+-32767 > 4294967295
+-32767 > 4294967296
+-32767 > 18446744073709551615
+-32767 > 18446744073709551616
+-32767 > 340282366920938463463374607431768211455
+-32767 > 340282366920938463463374607431768211456
+-128 > -170141183460469231731687303715884105728
+-128 > -170141183460469231731687303715884105727
+-128 > -9223372036854775808
+-128 > -9223372036854775807
+-128 > -2147483648
+-128 > -2147483647
+-128 > -32768
+-128 > -32767
+-128 > -128
+-128 > -127
+-128 > 255
+-128 > 256
+-128 > 65535
+-128 > 65536
+-128 > 4294967295
+-128 > 4294967296
+-128 > 18446744073709551615
+-128 > 18446744073709551616
+-128 > 340282366920938463463374607431768211455
+-128 > 340282366920938463463374607431768211456
+-127 > -170141183460469231731687303715884105728
+-127 > -170141183460469231731687303715884105727
+-127 > -9223372036854775808
+-127 > -9223372036854775807
+-127 > -2147483648
+-127 > -2147483647
+-127 > -32768
+-127 > -32767
+-127 > -128
+-127 > -127
+-127 > 255
+-127 > 256
+-127 > 65535
+-127 > 65536
+-127 > 4294967295
+-127 > 4294967296
+-127 > 18446744073709551615
+-127 > 18446744073709551616
+-127 > 340282366920938463463374607431768211455
+-127 > 340282366920938463463374607431768211456
+255 > -170141183460469231731687303715884105728
+255 > -170141183460469231731687303715884105727
+255 > -9223372036854775808
+255 > -9223372036854775807
+255 > -2147483648
+255 > -2147483647
+255 > -32768
+255 > -32767
+255 > -128
+255 > -127
+255 > 255
+255 > 256
+255 > 65535
+255 > 65536
+255 > 4294967295
+255 > 4294967296
+255 > 18446744073709551615
+255 > 18446744073709551616
+255 > 340282366920938463463374607431768211455
+255 > 340282366920938463463374607431768211456
+256 > -170141183460469231731687303715884105728
+256 > -170141183460469231731687303715884105727
+256 > -9223372036854775808
+256 > -9223372036854775807
+256 > -2147483648
+256 > -2147483647
+256 > -32768
+256 > -32767
+256 > -128
+256 > -127
+256 > 255
+256 > 256
+256 > 65535
+256 > 65536
+256 > 4294967295
+256 > 4294967296
+256 > 18446744073709551615
+256 > 18446744073709551616
+256 > 340282366920938463463374607431768211455
+256 > 340282366920938463463374607431768211456
+65535 > -170141183460469231731687303715884105728
+65535 > -170141183460469231731687303715884105727
+65535 > -9223372036854775808
+65535 > -9223372036854775807
+65535 > -2147483648
+65535 > -2147483647
+65535 > -32768
+65535 > -32767
+65535 > -128
+65535 > -127
+65535 > 255
+65535 > 256
+65535 > 65535
+65535 > 65536
+65535 > 4294967295
+65535 > 4294967296
+65535 > 18446744073709551615
+65535 > 18446744073709551616
+65535 > 340282366920938463463374607431768211455
+65535 > 340282366920938463463374607431768211456
+65536 > -170141183460469231731687303715884105728
+65536 > -170141183460469231731687303715884105727
+65536 > -9223372036854775808
+65536 > -9223372036854775807
+65536 > -2147483648
+65536 > -2147483647
+65536 > -32768
+65536 > -32767
+65536 > -128
+65536 > -127
+65536 > 255
+65536 > 256
+65536 > 65535
+65536 > 65536
+65536 > 4294967295
+65536 > 4294967296
+65536 > 18446744073709551615
+65536 > 18446744073709551616
+65536 > 340282366920938463463374607431768211455
+65536 > 340282366920938463463374607431768211456
+4294967295 > -170141183460469231731687303715884105728
+4294967295 > -170141183460469231731687303715884105727
+4294967295 > -9223372036854775808
+4294967295 > -9223372036854775807
+4294967295 > -2147483648
+4294967295 > -2147483647
+4294967295 > -32768
+4294967295 > -32767
+4294967295 > -128
+4294967295 > -127
+4294967295 > 255
+4294967295 > 256
+4294967295 > 65535
+4294967295 > 65536
+4294967295 > 4294967295
+4294967295 > 4294967296
+4294967295 > 18446744073709551615
+4294967295 > 18446744073709551616
+4294967295 > 340282366920938463463374607431768211455
+4294967295 > 340282366920938463463374607431768211456
+4294967296 > -170141183460469231731687303715884105728
+4294967296 > -170141183460469231731687303715884105727
+4294967296 > -9223372036854775808
+4294967296 > -9223372036854775807
+4294967296 > -2147483648
+4294967296 > -2147483647
+4294967296 > -32768
+4294967296 > -32767
+4294967296 > -128
+4294967296 > -127
+4294967296 > 255
+4294967296 > 256
+4294967296 > 65535
+4294967296 > 65536
+4294967296 > 4294967295
+4294967296 > 4294967296
+4294967296 > 18446744073709551615
+4294967296 > 18446744073709551616
+4294967296 > 340282366920938463463374607431768211455
+4294967296 > 340282366920938463463374607431768211456
+18446744073709551615 > -170141183460469231731687303715884105728
+18446744073709551615 > -170141183460469231731687303715884105727
+18446744073709551615 > -9223372036854775808
+18446744073709551615 > -9223372036854775807
+18446744073709551615 > -2147483648
+18446744073709551615 > -2147483647
+18446744073709551615 > -32768
+18446744073709551615 > -32767
+18446744073709551615 > -128
+18446744073709551615 > -127
+18446744073709551615 > 255
+18446744073709551615 > 256
+18446744073709551615 > 65535
+18446744073709551615 > 65536
+18446744073709551615 > 4294967295
+18446744073709551615 > 4294967296
+18446744073709551615 > 18446744073709551615
+18446744073709551615 > 18446744073709551616
+18446744073709551615 > 340282366920938463463374607431768211455
+18446744073709551615 > 340282366920938463463374607431768211456
+18446744073709551616 > -170141183460469231731687303715884105728
+18446744073709551616 > -170141183460469231731687303715884105727
+18446744073709551616 > -9223372036854775808
+18446744073709551616 > -9223372036854775807
+18446744073709551616 > -2147483648
+18446744073709551616 > -2147483647
+18446744073709551616 > -32768
+18446744073709551616 > -32767
+18446744073709551616 > -128
+18446744073709551616 > -127
+18446744073709551616 > 255
+18446744073709551616 > 256
+18446744073709551616 > 65535
+18446744073709551616 > 65536
+18446744073709551616 > 4294967295
+18446744073709551616 > 4294967296
+18446744073709551616 > 18446744073709551615
+18446744073709551616 > 18446744073709551616
+18446744073709551616 > 340282366920938463463374607431768211455
+18446744073709551616 > 340282366920938463463374607431768211456
+340282366920938463463374607431768211455 > -170141183460469231731687303715884105728
+340282366920938463463374607431768211455 > -170141183460469231731687303715884105727
+340282366920938463463374607431768211455 > -9223372036854775808
+340282366920938463463374607431768211455 > -9223372036854775807
+340282366920938463463374607431768211455 > -2147483648
+340282366920938463463374607431768211455 > -2147483647
+340282366920938463463374607431768211455 > -32768
+340282366920938463463374607431768211455 > -32767
+340282366920938463463374607431768211455 > -128
+340282366920938463463374607431768211455 > -127
+340282366920938463463374607431768211455 > 255
+340282366920938463463374607431768211455 > 256
+340282366920938463463374607431768211455 > 65535
+340282366920938463463374607431768211455 > 65536
+340282366920938463463374607431768211455 > 4294967295
+340282366920938463463374607431768211455 > 4294967296
+340282366920938463463374607431768211455 > 18446744073709551615
+340282366920938463463374607431768211455 > 18446744073709551616
+340282366920938463463374607431768211455 > 340282366920938463463374607431768211455
+340282366920938463463374607431768211455 > 340282366920938463463374607431768211456
+340282366920938463463374607431768211456 > -170141183460469231731687303715884105728
+340282366920938463463374607431768211456 > -170141183460469231731687303715884105727
+340282366920938463463374607431768211456 > -9223372036854775808
+340282366920938463463374607431768211456 > -9223372036854775807
+340282366920938463463374607431768211456 > -2147483648
+340282366920938463463374607431768211456 > -2147483647
+340282366920938463463374607431768211456 > -32768
+340282366920938463463374607431768211456 > -32767
+340282366920938463463374607431768211456 > -128
+340282366920938463463374607431768211456 > -127
+340282366920938463463374607431768211456 > 255
+340282366920938463463374607431768211456 > 256
+340282366920938463463374607431768211456 > 65535
+340282366920938463463374607431768211456 > 65536
+340282366920938463463374607431768211456 > 4294967295
+340282366920938463463374607431768211456 > 4294967296
+340282366920938463463374607431768211456 > 18446744073709551615
+340282366920938463463374607431768211456 > 18446744073709551616
+340282366920938463463374607431768211456 > 340282366920938463463374607431768211455
+340282366920938463463374607431768211456 > 340282366920938463463374607431768211456
diff --git a/test/ic3/integer.lisp b/test/ic3/integer.lisp
index 9630164..5ed6291 100644
--- a/test/ic3/integer.lisp
+++ b/test/ic3/integer.lisp
@@ -1,11 +1,30 @@
 (in-package :cl-user)
 
-(defparameter *ops* '(+ - * /))
+(require :positional)
+
+(defparameter *ops* '(+ - * / < == >))
 
 (defparameter *su* '(s u))
 
 (defparameter *bits* '(8 16 32 64 128))
 
+(defun == (a b)
+  (= a b))
+
+(defgeneric translate (x))
+
+(defmethod translate ((x integer))
+  x)
+
+(defmethod translate ((x number))
+  (truncate x))
+
+(defmethod translate ((x (eql 't)))
+  "true")
+
+(defmethod translate ((x null))
+  "false")
+
 (defun do-numbers (fn)
   (dolist (su *su*)
     (let ((sign (if (eq su 's) -1 1)))
@@ -43,5 +62,5 @@
           (lambda (a)
             (do-numbers
                 (lambda (b)
-                  (format expected "~A~%" (truncate (funcall op a b)))
+                  (format expected "~A~%" (translate (funcall op a b)))
                   (format in "~A ~A ~A~%" a op b))))))))
diff --git a/test/ic3/integer.out.expected b/test/ic3/integer.out.expected
index e3c7d41..b83ea51 100644
--- a/test/ic3/integer.out.expected
+++ b/test/ic3/integer.out.expected
@@ -1658,3 +1658,1203 @@
 18446744073709551616
 1
 1
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
+false
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+false
diff --git a/test/ic3_test b/test/ic3_test
index 4a1c276..9b80c1c 100755
--- a/test/ic3_test
+++ b/test/ic3_test
@@ -36,16 +36,12 @@ fi
 
 for TARGET in $TARGETS; do
     RESULT=test_ok
-    $IC3 < ${TARGET}.in > ${TARGET}.out 2> ${TARGET}.err
+    $IC3 < ${TARGET}.in > ${TARGET}.out 2>&1
     echo $? > ${TARGET}.ret
     if ! diff -au ${TARGET}.out.expected ${TARGET}.out > ${TARGET}.diff
     then
         RESULT=test_ko
     fi
-    if ! diff -au ${TARGET}.err.expected ${TARGET}.err >> ${TARGET}.diff
-    then
-        RESULT=test_ko
-    fi
     if ! diff -au ${TARGET}.ret.expected ${TARGET}.ret >> ${TARGET}.diff
     then
         RESULT=test_ko