Replace ExprInt[num](x) -> ExprInt(x, num)

12 files changed, 269 insertions, 271 deletions

diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py
index a40d000a..1784f87f 100644
--- a/test/analysis/data_flow.py
+++ b/test/analysis/data_flow.py
@@ -1,5 +1,5 @@
 """ Test cases for dead code elimination"""
-from miasm2.expression.expression import ExprId, ExprInt32, ExprAff, ExprMem
+from miasm2.expression.expression import ExprId, ExprInt, ExprAff, ExprMem
 from miasm2.core.asmblock import AsmLabel
 from miasm2.analysis.data_flow import *
 from miasm2.ir.analysis import ira
@@ -20,9 +20,9 @@ r_init = ExprId("r_init") # Return register
 pc = ExprId("pc")
 sp = ExprId("sp")
 
-CST1 = ExprInt32(0x11)
-CST2 = ExprInt32(0x12)
-CST3 = ExprInt32(0x13)
+CST1 = ExprInt(0x11, 32)
+CST2 = ExprInt(0x12, 32)
+CST3 = ExprInt(0x13, 32)
 
 LBL0 = AsmLabel("lbl0")
 LBL1 = AsmLabel("lbl1")
diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py
index 24095c7b..005ab32c 100644
--- a/test/analysis/depgraph.py
+++ b/test/analysis/depgraph.py
@@ -1,6 +1,5 @@
 """Regression test module for DependencyGraph"""
-from miasm2.expression.expression import ExprId, ExprInt32, ExprAff, ExprCond, \
-    ExprInt
+from miasm2.expression.expression import ExprId, ExprInt, ExprAff, ExprCond
 from miasm2.core.asmblock import AsmLabel
 from miasm2.ir.analysis import ira
 from miasm2.ir.ir import IRBlock, AssignBlock
@@ -31,16 +30,16 @@ D_INIT = ExprId("d_init")
 PC = ExprId("pc")
 SP = ExprId("sp")
 
-CST0 = ExprInt32(0x0)
-CST1 = ExprInt32(0x1)
-CST2 = ExprInt32(0x2)
-CST3 = ExprInt32(0x3)
-CST22 = ExprInt32(0x22)
-CST23 = ExprInt32(0x23)
-CST24 = ExprInt32(0x24)
-CST33 = ExprInt32(0x33)
-CST35 = ExprInt32(0x35)
-CST37 = ExprInt32(0x37)
+CST0 = ExprInt(0x0, 32)
+CST1 = ExprInt(0x1, 32)
+CST2 = ExprInt(0x2, 32)
+CST3 = ExprInt(0x3, 32)
+CST22 = ExprInt(0x22, 32)
+CST23 = ExprInt(0x23, 32)
+CST24 = ExprInt(0x24, 32)
+CST33 = ExprInt(0x33, 32)
+CST35 = ExprInt(0x35, 32)
+CST37 = ExprInt(0x37, 32)
 
 LBL0 = AsmLabel("lbl0")
 LBL1 = AsmLabel("lbl1")
diff --git a/test/analysis/range.py b/test/analysis/range.py
index 4cc27f2c..8b1224f9 100644
--- a/test/analysis/range.py
+++ b/test/analysis/range.py
@@ -11,62 +11,62 @@ for expr in [
         a,
         b,
         b[4:6],
-        a + ExprInt8(4),
-        ExprInt8(5) + ExprInt8(4),
-        a.zeroExtend(32) + ExprInt32(0x100),
-        (a.zeroExtend(32) * ExprInt32(3)) + ExprInt32(0x100),
-        (a.zeroExtend(32) + ExprInt32(0x80)) * ExprInt32(3),
-        ExprCond(b, a.zeroExtend(32) + ExprInt32(0x100),
-                 a.zeroExtend(32) + ExprInt32(0x500)),
-        ExprCond(b[1:2], a.zeroExtend(32), a.zeroExtend(32) + ExprInt32(0x1000)) + \
-        ExprCond(b[0:1], a.zeroExtend(32) + ExprInt32(0x5000), a.zeroExtend(32) + ExprInt32(0x10000)),
+        a + ExprInt(4, 8),
+        ExprInt(5, 8) + ExprInt(4, 8),
+        a.zeroExtend(32) + ExprInt(0x100, 32),
+        (a.zeroExtend(32) * ExprInt(3, 32)) + ExprInt(0x100, 32),
+        (a.zeroExtend(32) + ExprInt(0x80, 32)) * ExprInt(3, 32),
+        ExprCond(b, a.zeroExtend(32) + ExprInt(0x100, 32),
+                 a.zeroExtend(32) + ExprInt(0x500, 32)),
+        ExprCond(b[1:2], a.zeroExtend(32), a.zeroExtend(32) + ExprInt(0x1000, 32)) + \
+        ExprCond(b[0:1], a.zeroExtend(32) + ExprInt(0x5000, 32), a.zeroExtend(32) + ExprInt(0x10000, 32)),
         - a,
-        - ExprInt8(4),
-        b[:8].zeroExtend(16) - ExprInt16(4),
-        a[4:6].zeroExtend(32) + ExprInt32(-1),
-        a >> ExprInt8(4),
-        a << ExprInt8(4),
-        ExprOp("a>>", a, ExprInt8(4)),
-        ExprInt8(4) >> a,
-        ExprInt8(4) << a,
-        ExprOp("a>>", ExprInt8(4), a),
+        - ExprInt(4, 8),
+        b[:8].zeroExtend(16) - ExprInt(4, 16),
+        a[4:6].zeroExtend(32) + ExprInt(-1, 32),
+        a >> ExprInt(4, 8),
+        a << ExprInt(4, 8),
+        ExprOp("a>>", a, ExprInt(4, 8)),
+        ExprInt(4, 8) >> a,
+        ExprInt(4, 8) << a,
+        ExprOp("a>>", ExprInt(4, 8), a),
         a >> a,
         a << a,
         ExprOp("a>>", a, a),
-        ExprInt8(4) >> ExprCond(b[0:1], ExprInt8(1), ExprInt8(10)),
-        ExprInt8(4) << ExprCond(b[0:1], ExprInt8(1), ExprInt8(10)),
-        ExprOp("a>>", ExprInt8(4), ExprCond(b[0:1], ExprInt8(1), ExprInt8(10))),
-        a | ExprInt8(4),
+        ExprInt(4, 8) >> ExprCond(b[0:1], ExprInt(1, 8), ExprInt(10, 8)),
+        ExprInt(4, 8) << ExprCond(b[0:1], ExprInt(1, 8), ExprInt(10, 8)),
+        ExprOp("a>>", ExprInt(4, 8), ExprCond(b[0:1], ExprInt(1, 8), ExprInt(10, 8))),
+        a | ExprInt(4, 8),
         a[3:5] | a[6:8],
-        ExprInt8(0) | a,
-        ExprInt8(0xF) | ExprInt8(0xC),
-        ExprCond(a[0:1], ExprInt8(5), ExprInt8(18)) | a[5:7].zeroExtend(8),
-        a & ExprInt8(4),
+        ExprInt(0, 8) | a,
+        ExprInt(0xF, 8) | ExprInt(0xC, 8),
+        ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8)) | a[5:7].zeroExtend(8),
+        a & ExprInt(4, 8),
         a[3:5] & a[6:8],
-        ExprInt8(8) & a,
-        ExprInt8(0xF) & ExprInt8(0xC),
-        ExprCond(a[0:1], ExprInt8(5), ExprInt8(18)) & (a[4:7].zeroExtend(8) << ExprInt8(2)),
-        a ^ ExprInt8(4),
+        ExprInt(8, 8) & a,
+        ExprInt(0xF, 8) & ExprInt(0xC, 8),
+        ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8)) & (a[4:7].zeroExtend(8) << ExprInt(2, 8)),
+        a ^ ExprInt(4, 8),
         a[3:5] ^ a[6:8],
-        ExprInt8(0xF) ^ a,
-        ExprInt8(0xF) ^ ExprInt8(0xC),
-        ExprCond(a[0:1], ExprInt8(5), ExprInt8(18)) ^ (a[4:7].zeroExtend(8) << ExprInt8(2)),
-        a % ExprInt8(8),
-        ExprInt8(33) % ExprInt8(8),
+        ExprInt(0xF, 8) ^ a,
+        ExprInt(0xF, 8) ^ ExprInt(0xC, 8),
+        ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8)) ^ (a[4:7].zeroExtend(8) << ExprInt(2, 8)),
+        a % ExprInt(8, 8),
+        ExprInt(33, 8) % ExprInt(8, 8),
         a % a,
-        a[:2].zeroExtend(8) + ExprInt8(0xF) % ExprCond(a[0:1], ExprInt8(5), ExprInt8(18)),
-        ExprOp("<<<", ExprInt8(4), ExprInt8(1)),
-        ExprOp("<<<", ExprInt8(4), ExprInt8(14)),
-        ExprOp("<<<", ExprInt8(4), a),
-        ExprOp("<<<", a, ExprInt8(4)),
+        a[:2].zeroExtend(8) + ExprInt(0xF, 8) % ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8)),
+        ExprOp("<<<", ExprInt(4, 8), ExprInt(1, 8)),
+        ExprOp("<<<", ExprInt(4, 8), ExprInt(14, 8)),
+        ExprOp("<<<", ExprInt(4, 8), a),
+        ExprOp("<<<", a, ExprInt(4, 8)),
         ExprOp("<<<", a, a),
-        ExprOp("<<<", a[1:2].zeroExtend(8) + ExprInt8(1), ExprCond(a[0:1], ExprInt8(5), ExprInt8(18))),
-        ExprOp(">>>", ExprInt8(4), ExprInt8(1)),
-        ExprOp(">>>", ExprInt8(4), ExprInt8(14)),
-        ExprOp(">>>", ExprInt8(4), a),
-        ExprOp(">>>", a, ExprInt8(4)),
+        ExprOp("<<<", a[1:2].zeroExtend(8) + ExprInt(1, 8), ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8))),
+        ExprOp(">>>", ExprInt(4, 8), ExprInt(1, 8)),
+        ExprOp(">>>", ExprInt(4, 8), ExprInt(14, 8)),
+        ExprOp(">>>", ExprInt(4, 8), a),
+        ExprOp(">>>", a, ExprInt(4, 8)),
         ExprOp(">>>", a, a),
-        ExprOp(">>>", a[1:2].zeroExtend(8) + ExprInt8(1), ExprCond(a[0:1], ExprInt8(5), ExprInt8(18))),
+        ExprOp(">>>", a[1:2].zeroExtend(8) + ExprInt(1, 8), ExprCond(a[0:1], ExprInt(5, 8), ExprInt(18, 8))),
 
         # Fuzzed by ExprRandom, with previous bug
         ExprSlice(ExprSlice(ExprOp('<<<', ExprInt(0x7FBE84D6, 51), ExprId('WYBZj', 51)), 6, 48), 3, 35),
diff --git a/test/expression/expression.py b/test/expression/expression.py
index 8e8b5e07..ac145a04 100644
--- a/test/expression/expression.py
+++ b/test/expression/expression.py
@@ -6,8 +6,8 @@ from miasm2.expression.expression import *
 from miasm2.expression.expression_helper import *
 
 # Expression comparison
-assert(ExprInt64(-1) != ExprInt64(-2))
-assert(ExprInt64(1) != ExprInt32(1))
+assert(ExprInt(-1, 64) != ExprInt(-2, 64))
+assert(ExprInt(1, 64) != ExprInt(1, 32))
 
 # Expression size
 big_cst = ExprInt(1, size=0x1000)
@@ -18,10 +18,10 @@ assert big_cst.size == 0x1000
 A = ExprId("A")
 cond1 = ExprId("cond1", 1)
 cond2 = ExprId("cond2", 16)
-cst1 = ExprInt32(1)
-cst2 = ExprInt32(2)
-cst3 = ExprInt32(3)
-cst4 = ExprInt32(4)
+cst1 = ExprInt(1, 32)
+cst2 = ExprInt(2, 32)
+cst3 = ExprInt(3, 32)
+cst4 = ExprInt(4, 32)
 
 #- Launch tests
 for expr in [
diff --git a/test/expression/expression_helper.py b/test/expression/expression_helper.py
index 6c800020..a4c221e9 100755
--- a/test/expression/expression_helper.py
+++ b/test/expression/expression_helper.py
@@ -11,7 +11,7 @@ class TestExpressionExpressionHelper(unittest.TestCase):
         from miasm2.expression.expression_helper import Variables_Identifier
 
         # Build a complex expression
-        cst = m2_expr.ExprInt16(0x100)
+        cst = m2_expr.ExprInt(0x100, 16)
         eax = m2_expr.ExprId("EAX")
         ebx = m2_expr.ExprId("EBX")
         ax = eax[0:16]
@@ -62,7 +62,7 @@ class TestExpressionExpressionHelper(unittest.TestCase):
         ## Corner case: each sub var depends on itself
         mem1 = m2_expr.ExprMem(ebx, size=32)
         mem2 = m2_expr.ExprMem(mem1, size=32)
-        cst2 = m2_expr.ExprInt32(-1)
+        cst2 = m2_expr.ExprInt(-1, 32)
         expr_mini = ((eax ^ mem2 ^ cst2) & (mem2 ^ (eax + mem2)))[31:32]
 
         ## Build
diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index 5391fbee..d4553495 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -32,23 +32,23 @@ l = [a[:8], b[:8], c[:8], m[:8], s, i1[:8], i2[:8], o[:8]]
 l2 = l[::-1]
 
 
-x = ExprMem(a + b + ExprInt32(0x42))
+x = ExprMem(a + b + ExprInt(0x42, 32))
 
 # Define tests: (expression to simplify, expected value)
-to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
-           ((ExprInt32(5) + c + a + b - a + ExprInt32(1) - ExprInt32(5)),
-            ExprOp('+', b, c, ExprInt32(1))),
+to_test = [(ExprInt(1, 32) - ExprInt(1, 32), ExprInt(0, 32)),
+           ((ExprInt(5, 32) + c + a + b - a + ExprInt(1, 32) - ExprInt(5, 32)),
+            ExprOp('+', b, c, ExprInt(1, 32))),
            (a + b + c - a - b - c + a, a),
            (a + a + b + c - (a + (b + c)), a),
            (c ^ b ^ a ^ c ^ b, a),
-           (a ^ ExprInt32(0), a),
+           (a ^ ExprInt(0, 32), a),
            ((a + b) - b, a),
-           (-(ExprInt32(0) - ((a + b) - b)), a),
+           (-(ExprInt(0, 32) - ((a + b) - b)), a),
 
-           (ExprOp('<<<', a, ExprInt32(32)), a),
-           (ExprOp('>>>', a, ExprInt32(32)), a),
-           (ExprOp('>>>', a, ExprInt32(0)), a),
-           (ExprOp('<<', a, ExprInt32(0)), a),
+           (ExprOp('<<<', a, ExprInt(32, 32)), a),
+           (ExprOp('>>>', a, ExprInt(32, 32)), a),
+           (ExprOp('>>>', a, ExprInt(0, 32)), a),
+           (ExprOp('<<', a, ExprInt(0, 32)), a),
 
            (ExprOp('<<<', a, ExprOp('<<<', b, c)),
             ExprOp('<<<', a, ExprOp('<<<', b, c))),
@@ -60,31 +60,31 @@ to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
             ExprOp('<<<', a, (b-c))),
            (ExprOp('>>>', ExprOp('<<<', a, b), b),
             a),
-           (ExprOp(">>>", ExprInt16(0x1000), ExprInt16(0x11)),
-            ExprInt16(0x800)),
-           (ExprOp("<<<", ExprInt16(0x1000), ExprInt16(0x11)),
-            ExprInt16(0x2000)),
-
-           (ExprOp('>>>', ExprOp('<<<', a, ExprInt32(10)), ExprInt32(2)),
-            ExprOp('<<<', a, ExprInt32(8))),
-
-           (ExprOp('>>>', ExprOp('<<<', a, ExprInt32(10)), ExprInt32(2)) ^ ExprOp('>>>', ExprOp('<<<', a, ExprInt32(10)), ExprInt32(2)),
-            ExprInt32(0)),
-           (ExprOp(">>", (a & ExprInt32(0xF)), ExprInt32(0x15)),
-            ExprInt32(0)),
-           (ExprOp(">>", (ExprInt32(0x12345678)), ExprInt32(0x4)),
-            ExprInt32(0x1234567)),
-           (ExprOp("a>>", (ExprInt32(0x12345678)), ExprInt32(0x4)),
-            ExprInt32(0x1234567)),
-           (ExprOp("a>>", (ExprInt32(0xF1234567)), ExprInt32(0x4)),
-            ExprInt32(0xFF123456)),
-           (ExprOp("a>>", (ExprInt32(0xF1234567)), ExprInt32(28)),
-            ExprInt32(0xFFFFFFFF)),
-           (ExprOp("parity", ExprInt32(0xf)), ExprInt1(1)),
-           (ExprOp("parity", ExprInt32(0xe)), ExprInt1(0)),
-           (ExprInt32(0x4142)[:32], ExprInt32(0x4142)),
-           (ExprInt32(0x4142)[:8], ExprInt8(0x42)),
-           (ExprInt32(0x4142)[8:16], ExprInt8(0x41)),
+           (ExprOp(">>>", ExprInt(0x1000, 16), ExprInt(0x11, 16)),
+            ExprInt(0x800, 16)),
+           (ExprOp("<<<", ExprInt(0x1000, 16), ExprInt(0x11, 16)),
+            ExprInt(0x2000, 16)),
+
+           (ExprOp('>>>', ExprOp('<<<', a, ExprInt(10, 32)), ExprInt(2, 32)),
+            ExprOp('<<<', a, ExprInt(8, 32))),
+
+           (ExprOp('>>>', ExprOp('<<<', a, ExprInt(10, 32)), ExprInt(2, 32)) ^ ExprOp('>>>', ExprOp('<<<', a, ExprInt(10, 32)), ExprInt(2, 32)),
+            ExprInt(0, 32)),
+           (ExprOp(">>", (a & ExprInt(0xF, 32)), ExprInt(0x15, 32)),
+            ExprInt(0, 32)),
+           (ExprOp(">>", (ExprInt(0x12345678, 32)), ExprInt(0x4, 32)),
+            ExprInt(0x1234567, 32)),
+           (ExprOp("a>>", (ExprInt(0x12345678, 32)), ExprInt(0x4, 32)),
+            ExprInt(0x1234567, 32)),
+           (ExprOp("a>>", (ExprInt(0xF1234567, 32)), ExprInt(0x4, 32)),
+            ExprInt(0xFF123456, 32)),
+           (ExprOp("a>>", (ExprInt(0xF1234567, 32)), ExprInt(28, 32)),
+            ExprInt(0xFFFFFFFF, 32)),
+           (ExprOp("parity", ExprInt(0xf, 32)), ExprInt(1, 1)),
+           (ExprOp("parity", ExprInt(0xe, 32)), ExprInt(0, 1)),
+           (ExprInt(0x4142, 32)[:32], ExprInt(0x4142, 32)),
+           (ExprInt(0x4142, 32)[:8], ExprInt(0x42, 8)),
+           (ExprInt(0x4142, 32)[8:16], ExprInt(0x41, 8)),
            (a[:32], a),
            (a[:8][:8], a[:8]),
            (a[:16][:8], a[:8]),
@@ -100,59 +100,59 @@ to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
            (ExprMem(a)[:32], ExprMem(a)),
            (ExprMem(a)[:16], ExprMem(a, size=16)),
 
-           (ExprCond(ExprInt32(1), a, b), a),
-           (ExprCond(ExprInt32(0), b, a), a),
+           (ExprCond(ExprInt(1, 32), a, b), a),
+           (ExprCond(ExprInt(0, 32), b, a), a),
 
-           (ExprInt32(0x80000000)[31:32], ExprInt1(1)),
-           (ExprCompose(ExprInt16(0x1337)[:8], ExprInt16(0x1337)[8:16]),
-            ExprInt16(0x1337)),
+           (ExprInt(0x80000000, 32)[31:32], ExprInt(1, 1)),
+           (ExprCompose(ExprInt(0x1337, 16)[:8], ExprInt(0x1337, 16)[8:16]),
+            ExprInt(0x1337, 16)),
 
-           (ExprCompose(ExprInt32(0x1337beef)[:8],
-                        ExprInt32(0x1337beef)[8:16],
-                        ExprInt32(0x1337beef)[16:32]),
-            ExprInt32(0x1337BEEF)),
+           (ExprCompose(ExprInt(0x1337beef, 32)[:8],
+                        ExprInt(0x1337beef, 32)[8:16],
+                        ExprInt(0x1337beef, 32)[16:32]),
+            ExprInt(0x1337BEEF, 32)),
            (ExprCond(a,
                      ExprCond(a,
                               b,
                               c),
                      d), ExprCond(a, b, d)),
-           ((a & b & ExprInt32(0x12))[31:32], ExprInt1(0)),
+           ((a & b & ExprInt(0x12, 32))[31:32], ExprInt(0, 1)),
 
            (ExprCompose(
-               ExprCond(a, ExprInt16(0x10), ExprInt16(0x20)),
-               ExprInt16(0x1337)),
-               ExprCond(a, ExprInt32(0x13370010), ExprInt32(0x13370020))),
-    (ExprCond(ExprCond(a, ExprInt1(0), ExprInt1(1)), b, c),
+               ExprCond(a, ExprInt(0x10, 16), ExprInt(0x20, 16)),
+               ExprInt(0x1337, 16)),
+               ExprCond(a, ExprInt(0x13370010, 32), ExprInt(0x13370020, 32))),
+    (ExprCond(ExprCond(a, ExprInt(0, 1), ExprInt(1, 1)), b, c),
      ExprCond(a, c, b)),
-    (ExprCond(a, ExprInt32(0x10), ExprInt32(0x20)) + ExprInt32(0x13370000),
-     ExprCond(a, ExprInt32(0x13370010), ExprInt32(0x13370020))),
-
-    (ExprCond(a, ExprInt32(0x10), ExprInt32(0x20)) + ExprCond(a, ExprInt32(0x13370000), ExprInt32(0x13380000)),
-     ExprCond(a, ExprInt32(0x13370010), ExprInt32(0x13380020))),
-    (-ExprCond(a, ExprInt32(0x1), ExprInt32(0x2)),
-     ExprCond(a, ExprInt32(-0x1), ExprInt32(-0x2))),
-    (ExprOp('*', a, b, c, ExprInt32(0x12))[0:17],
+    (ExprCond(a, ExprInt(0x10, 32), ExprInt(0x20, 32)) + ExprInt(0x13370000, 32),
+     ExprCond(a, ExprInt(0x13370010, 32), ExprInt(0x13370020, 32))),
+
+    (ExprCond(a, ExprInt(0x10, 32), ExprInt(0x20, 32)) + ExprCond(a, ExprInt(0x13370000, 32), ExprInt(0x13380000, 32)),
+     ExprCond(a, ExprInt(0x13370010, 32), ExprInt(0x13380020, 32))),
+    (-ExprCond(a, ExprInt(0x1, 32), ExprInt(0x2, 32)),
+     ExprCond(a, ExprInt(-0x1, 32), ExprInt(-0x2, 32))),
+    (ExprOp('*', a, b, c, ExprInt(0x12, 32))[0:17],
      ExprOp(
      '*', a[0:17], b[0:17], c[0:17], ExprInt(0x12, 17))),
-    (ExprOp('*', a, ExprInt32(0xffffffff)),
+    (ExprOp('*', a, ExprInt(0xffffffff, 32)),
      -a),
-    (ExprOp('*', -a, -b, c, ExprInt32(0x12)),
-     ExprOp('*', a, b, c, ExprInt32(0x12))),
-    (ExprOp('*', -a, -b, -c, ExprInt32(0x12)),
-     - ExprOp('*', a, b, c, ExprInt32(0x12))),
-     (ExprOp('**', ExprInt32(2), ExprInt32(8)), ExprInt32(0x100)),
-     (ExprInt32(2)**ExprInt32(8), ExprInt32(256)),
-    (a | ExprInt32(0xffffffff),
-     ExprInt32(0xffffffff)),
-    (ExprCond(a, ExprInt32(1), ExprInt32(2)) * ExprInt32(4),
-     ExprCond(a, ExprInt32(4), ExprInt32(8))),
+    (ExprOp('*', -a, -b, c, ExprInt(0x12, 32)),
+     ExprOp('*', a, b, c, ExprInt(0x12, 32))),
+    (ExprOp('*', -a, -b, -c, ExprInt(0x12, 32)),
+     - ExprOp('*', a, b, c, ExprInt(0x12, 32))),
+     (ExprOp('**', ExprInt(2, 32), ExprInt(8, 32)), ExprInt(0x100, 32)),
+     (ExprInt(2, 32)**ExprInt(8, 32), ExprInt(256, 32)),
+    (a | ExprInt(0xffffffff, 32),
+     ExprInt(0xffffffff, 32)),
+    (ExprCond(a, ExprInt(1, 32), ExprInt(2, 32)) * ExprInt(4, 32),
+     ExprCond(a, ExprInt(4, 32), ExprInt(8, 32))),
     (ExprCond(a, b, c) + ExprCond(a, d, e),
      ExprCond(a, b + d, c + e)),
     (ExprCond(a, b, c) * ExprCond(a, d, e),
      ExprCond(a, b * d, c * e)),
 
-    (ExprCond(a, ExprInt32(8), ExprInt32(4)) >> ExprInt32(1),
-     ExprCond(a, ExprInt32(4), ExprInt32(2))),
+    (ExprCond(a, ExprInt(8, 32), ExprInt(4, 32)) >> ExprInt(1, 32),
+     ExprCond(a, ExprInt(4, 32), ExprInt(2, 32))),
 
     (ExprCond(a, b, c) >> ExprCond(a, d, e),
      ExprCond(a, b >> d, c >> e)),
@@ -160,52 +160,52 @@ to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
     (a & b & ExprInt(-1, a.size), a & b),
     (a | b | ExprInt(-1, a.size),
      ExprInt(-1, a.size)),
-    (ExprOp('-', ExprInt8(1), ExprInt8(0)),
-     ExprInt8(1)),
-
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x20),
-     ExprCompose(ExprInt32(0), a)),
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x10),
-     ExprCompose(ExprInt16(0), a, ExprInt16(0))),
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x30),
+    (ExprOp('-', ExprInt(1, 8), ExprInt(0, 8)),
+     ExprInt(1, 8)),
+
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x20, 64),
+     ExprCompose(ExprInt(0, 32), a)),
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x10, 64),
+     ExprCompose(ExprInt(0, 16), a, ExprInt(0, 16))),
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x30, 64),
      ExprCompose(ExprInt(0, 48), a[:0x10])),
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x11),
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x11, 64),
      ExprCompose(ExprInt(0, 0x11), a, ExprInt(0, 0xF))),
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x40),
-     ExprInt64(0)),
-    (ExprCompose(a, ExprInt32(0)) << ExprInt64(0x50),
-     ExprInt64(0)),
-
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x20),
-     ExprCompose(a, ExprInt32(0))),
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x10),
-     ExprCompose(ExprInt16(0), a, ExprInt16(0))),
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x30),
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x40, 64),
+     ExprInt(0, 64)),
+    (ExprCompose(a, ExprInt(0, 32)) << ExprInt(0x50, 64),
+     ExprInt(0, 64)),
+
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x20, 64),
+     ExprCompose(a, ExprInt(0, 32))),
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x10, 64),
+     ExprCompose(ExprInt(0, 16), a, ExprInt(0, 16))),
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x30, 64),
      ExprCompose(a[0x10:], ExprInt(0, 48))),
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x11),
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x11, 64),
      ExprCompose(ExprInt(0, 0xf), a, ExprInt(0, 0x11))),
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x40),
-     ExprInt64(0)),
-    (ExprCompose(ExprInt32(0), a) >> ExprInt64(0x50),
-     ExprInt64(0)),
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x40, 64),
+     ExprInt(0, 64)),
+    (ExprCompose(ExprInt(0, 32), a) >> ExprInt(0x50, 64),
+     ExprInt(0, 64)),
 
 
-    (ExprCompose(a, b) << ExprInt64(0x20),
-     ExprCompose(ExprInt32(0), a)),
-    (ExprCompose(a, b) << ExprInt64(0x10),
-     ExprCompose(ExprInt16(0), a, b[:16])),
+    (ExprCompose(a, b) << ExprInt(0x20, 64),
+     ExprCompose(ExprInt(0, 32), a)),
+    (ExprCompose(a, b) << ExprInt(0x10, 64),
+     ExprCompose(ExprInt(0, 16), a, b[:16])),
 
     (ExprCompose(a, b) | ExprCompose(c, d),
      ExprCompose(a|c, b|d)),
-    (ExprCompose(a, ExprInt32(0)) | ExprCompose(ExprInt32(0), d),
+    (ExprCompose(a, ExprInt(0, 32)) | ExprCompose(ExprInt(0, 32), d),
      ExprCompose(a, d)),
-    (ExprCompose(f[:32], ExprInt32(0)) | ExprCompose(ExprInt32(0), f[32:]),
+    (ExprCompose(f[:32], ExprInt(0, 32)) | ExprCompose(ExprInt(0, 32), f[32:]),
      f),
-    ((ExprCompose(a, ExprInt32(0)) * ExprInt64(0x123))[32:64],
-     (ExprCompose(a, ExprInt32(0)) * ExprInt64(0x123))[32:64]),
+    ((ExprCompose(a, ExprInt(0, 32)) * ExprInt(0x123, 64))[32:64],
+     (ExprCompose(a, ExprInt(0, 32)) * ExprInt(0x123, 64))[32:64]),
 
-    (ExprInt32(0x12),
-     ExprInt32(0x12L)),
+    (ExprInt(0x12, 32),
+     ExprInt(0x12L, 32)),
 
 
     (ExprCompose(a, b, c)[:16],
@@ -235,13 +235,13 @@ to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
                   &
                   ExprInt(0x1L, 24),
                   ExprInt(0x0L, 40)),
-     ExprInt64(0)),
+     ExprInt(0, 64)),
 
     (ExprCompose(ExprCompose(a[:8], ExprInt(0x0L, 56))[:8]
                  &
                  ExprInt(0x1L, 8),
                  (ExprInt(0x0L, 56))),
-     ExprCompose(a[:8]&ExprInt8(1), ExprInt(0, 56))),
+     ExprCompose(a[:8]&ExprInt(1, 8), ExprInt(0, 56))),
 
     (ExprCompose(ExprCompose(a[:8],
                              ExprInt(0x0L, 56))[:32]
@@ -256,63 +256,63 @@ to_test = [(ExprInt32(1) - ExprInt32(1), ExprInt32(0)),
        ),
     (ExprCompose(a[:16], b[:16])[8:32],
      ExprCompose(a[8:16], b[:16])),
-    ((a >> ExprInt32(16))[:16],
+    ((a >> ExprInt(16, 32))[:16],
      a[16:32]),
-    ((a >> ExprInt32(16))[8:16],
+    ((a >> ExprInt(16, 32))[8:16],
      a[24:32]),
-    ((a << ExprInt32(16))[16:32],
+    ((a << ExprInt(16, 32))[16:32],
      a[:16]),
-    ((a << ExprInt32(16))[24:32],
+    ((a << ExprInt(16, 32))[24:32],
      a[8:16]),
-    (expr_cmpu(ExprInt32(0), ExprInt32(0)),
-     ExprInt1(0)),
-    (expr_cmpu(ExprInt32(10), ExprInt32(0)),
-     ExprInt1(1)),
-    (expr_cmpu(ExprInt32(10), ExprInt32(5)),
-     ExprInt1(1)),
-    (expr_cmpu(ExprInt32(5), ExprInt32(10)),
-     ExprInt1(0)),
-    (expr_cmpu(ExprInt32(-1), ExprInt32(0)),
-     ExprInt1(1)),
-    (expr_cmpu(ExprInt32(-1), ExprInt32(-1)),
-     ExprInt1(0)),
-    (expr_cmpu(ExprInt32(0), ExprInt32(-1)),
-     ExprInt1(0)),
-    (expr_cmps(ExprInt32(0), ExprInt32(0)),
-     ExprInt1(0)),
-    (expr_cmps(ExprInt32(10), ExprInt32(0)),
-     ExprInt1(1)),
-    (expr_cmps(ExprInt32(10), ExprInt32(5)),
-     ExprInt1(1)),
-    (expr_cmps(ExprInt32(5), ExprInt32(10)),
-     ExprInt1(0)),
-    (expr_cmps(ExprInt32(-1), ExprInt32(0)),
-     ExprInt1(0)),
-    (expr_cmps(ExprInt32(-1), ExprInt32(-1)),
-     ExprInt1(0)),
-    (expr_cmps(ExprInt32(0), ExprInt32(-1)),
-     ExprInt1(1)),
-    (expr_cmps(ExprInt32(-5), ExprInt32(-10)),
-     ExprInt1(1)),
-    (expr_cmps(ExprInt32(-10), ExprInt32(-5)),
-     ExprInt1(0)),
+    (expr_cmpu(ExprInt(0, 32), ExprInt(0, 32)),
+     ExprInt(0, 1)),
+    (expr_cmpu(ExprInt(10, 32), ExprInt(0, 32)),
+     ExprInt(1, 1)),
+    (expr_cmpu(ExprInt(10, 32), ExprInt(5, 32)),
+     ExprInt(1, 1)),
+    (expr_cmpu(ExprInt(5, 32), ExprInt(10, 32)),
+     ExprInt(0, 1)),
+    (expr_cmpu(ExprInt(-1, 32), ExprInt(0, 32)),
+     ExprInt(1, 1)),
+    (expr_cmpu(ExprInt(-1, 32), ExprInt(-1, 32)),
+     ExprInt(0, 1)),
+    (expr_cmpu(ExprInt(0, 32), ExprInt(-1, 32)),
+     ExprInt(0, 1)),
+    (expr_cmps(ExprInt(0, 32), ExprInt(0, 32)),
+     ExprInt(0, 1)),
+    (expr_cmps(ExprInt(10, 32), ExprInt(0, 32)),
+     ExprInt(1, 1)),
+    (expr_cmps(ExprInt(10, 32), ExprInt(5, 32)),
+     ExprInt(1, 1)),
+    (expr_cmps(ExprInt(5, 32), ExprInt(10, 32)),
+     ExprInt(0, 1)),
+    (expr_cmps(ExprInt(-1, 32), ExprInt(0, 32)),
+     ExprInt(0, 1)),
+    (expr_cmps(ExprInt(-1, 32), ExprInt(-1, 32)),
+     ExprInt(0, 1)),
+    (expr_cmps(ExprInt(0, 32), ExprInt(-1, 32)),
+     ExprInt(1, 1)),
+    (expr_cmps(ExprInt(-5, 32), ExprInt(-10, 32)),
+     ExprInt(1, 1)),
+    (expr_cmps(ExprInt(-10, 32), ExprInt(-5, 32)),
+     ExprInt(0, 1)),
 
     (ExprOp("<<<c_rez", i1, i0, i0),
      i1),
     (ExprOp("<<<c_rez", i1, i1, i0),
-     ExprInt32(2)),
+     ExprInt(2, 32)),
     (ExprOp("<<<c_rez", i1, i1, i1),
-     ExprInt32(3)),
+     ExprInt(3, 32)),
     (ExprOp(">>>c_rez", icustom, i0, i0),
      icustom),
     (ExprOp(">>>c_rez", icustom, i1, i0),
-     ExprInt32(0x91A2B3C)),
+     ExprInt(0x91A2B3C, 32)),
     (ExprOp(">>>c_rez", icustom, i1, i1),
-     ExprInt32(0x891A2B3C)),
-    (ExprOp("idiv", ExprInt16(0x0123), ExprInt16(0xfffb))[:8],
-     ExprInt8(0xc6)),
-    (ExprOp("imod", ExprInt16(0x0123), ExprInt16(0xfffb))[:8],
-     ExprInt8(0x01)),
+     ExprInt(0x891A2B3C, 32)),
+    (ExprOp("idiv", ExprInt(0x0123, 16), ExprInt(0xfffb, 16))[:8],
+     ExprInt(0xc6, 8)),
+    (ExprOp("imod", ExprInt(0x0123, 16), ExprInt(0xfffb, 16))[:8],
+     ExprInt(0x01, 8)),
 
 ]
 
@@ -334,21 +334,21 @@ to_test = [
      ExprOp_inf_signed(a, b)),
     ((((a - b) ^ ((a ^ b) & ((a - b) ^ a))) ^ a ^ b).msb(),
      ExprOp_inf_unsigned(a, b)),
-    (ExprOp_inf_unsigned(ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
-    (ExprOp_inf_signed(ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
+    (ExprOp_inf_unsigned(ExprInt(-1, 32), ExprInt(3, 32)), ExprInt(0, 1)),
+    (ExprOp_inf_signed(ExprInt(-1, 32), ExprInt(3, 32)), ExprInt(1, 1)),
     (ExprOp_inf_unsigned(a, b) ^ (a ^ b).msb(), ExprOp_inf_signed(a, b)),
     (ExprOp_inf_signed(a, b) ^ (a ^ b).msb(), ExprOp_inf_unsigned(a, b)),
-    (ExprOp_equal(ExprInt32(12), ExprInt32(10)), ExprInt1(0)),
-    (ExprOp_equal(ExprInt32(12), ExprInt32(12)), ExprInt1(1)),
-    (ExprOp_equal(ExprInt32(12), ExprInt32(-12)), ExprInt1(0)),
-    (ExprCond(a - b, ExprInt1(0), ExprInt1(1)), ExprOp_equal(a, b)),
-    (ExprCond(a + b, ExprInt1(0), ExprInt1(1)), ExprOp_equal(a, -b)),
-    (ExprOp_inf_signed(ExprInt32(-2), ExprInt32(3)), ExprInt1(1)),
-    (ExprOp_inf_signed(ExprInt32(3), ExprInt32(-3)), ExprInt1(0)),
-    (ExprOp_inf_signed(ExprInt32(2), ExprInt32(3)), ExprInt1(1)),
-    (ExprOp_inf_signed(ExprInt32(-3), ExprInt32(-2)), ExprInt1(1)),
-    (ExprOp_inf_signed(ExprInt32(0), ExprInt32(2)), ExprInt1(1)),
-    (ExprOp_inf_signed(ExprInt32(-3), ExprInt32(0)), ExprInt1(1)),
+    (ExprOp_equal(ExprInt(12, 32), ExprInt(10, 32)), ExprInt(0, 1)),
+    (ExprOp_equal(ExprInt(12, 32), ExprInt(12, 32)), ExprInt(1, 1)),
+    (ExprOp_equal(ExprInt(12, 32), ExprInt(-12, 32)), ExprInt(0, 1)),
+    (ExprCond(a - b, ExprInt(0, 1), ExprInt(1, 1)), ExprOp_equal(a, b)),
+    (ExprCond(a + b, ExprInt(0, 1), ExprInt(1, 1)), ExprOp_equal(a, -b)),
+    (ExprOp_inf_signed(ExprInt(-2, 32), ExprInt(3, 32)), ExprInt(1, 1)),
+    (ExprOp_inf_signed(ExprInt(3, 32), ExprInt(-3, 32)), ExprInt(0, 1)),
+    (ExprOp_inf_signed(ExprInt(2, 32), ExprInt(3, 32)), ExprInt(1, 1)),
+    (ExprOp_inf_signed(ExprInt(-3, 32), ExprInt(-2, 32)), ExprInt(1, 1)),
+    (ExprOp_inf_signed(ExprInt(0, 32), ExprInt(2, 32)), ExprInt(1, 1)),
+    (ExprOp_inf_signed(ExprInt(-3, 32), ExprInt(0, 32)), ExprInt(1, 1)),
 ]
 
 expr_simp_cond = ExpressionSimplifier()
@@ -382,18 +382,18 @@ jrb = ExprId('jrb')
 jrint1 = ExprId('jrint1')
 
 
-e1 = ExprMem((a & ExprInt32(0xFFFFFFFC)) + ExprInt32(0x10), 32)
-e2 = ExprMem((a & ExprInt32(0xFFFFFFFC)) + b, 32)
+e1 = ExprMem((a & ExprInt(0xFFFFFFFC, 32)) + ExprInt(0x10, 32), 32)
+e2 = ExprMem((a & ExprInt(0xFFFFFFFC, 32)) + b, 32)
 e3 = (a ^ b ^ ((a ^ b) & (b ^ (b - a))) ^ (b - a)).canonize()
 
 match_tests = [
-    (MatchExpr(ExprInt32(12), a, [a]), {a: ExprInt32(12)}),
+    (MatchExpr(ExprInt(12, 32), a, [a]), {a: ExprInt(12, 32)}),
     (MatchExpr(x, a, [a]), {a: x}),
     (MatchExpr(x + y, a, [a]), {a: x + y}),
     (MatchExpr(x + y, a + y, [a]), {a: x}),
     (MatchExpr(x + y, x + a, [a]), {a: y}),
     (MatchExpr(x + y, a + b, [a, b]), {a: x, b: y}),
-    (MatchExpr(x + ExprInt32(12), a + b, [a, b]), {a: x, b: ExprInt32(12)}),
+    (MatchExpr(x + ExprInt(12, 32), a + b, [a, b]), {a: x, b: ExprInt(12, 32)}),
     (MatchExpr(ExprMem(x), a, [a]), {a: ExprMem(x)}),
     (MatchExpr(ExprMem(x), ExprMem(a), [a]), {a: x}),
     (MatchExpr(x[0:8], a, [a]), {a: x[0:8]}),
@@ -407,7 +407,7 @@ match_tests = [
     (MatchExpr(ExprCompose(x[:8], y[:8]),
                ExprCompose(a[:8], b[:8]), [a, b]),
      {a: x, b: y}),
-    (MatchExpr(e1, e2, [b]), {b: ExprInt32(0x10)}),
+    (MatchExpr(e1, e2, [b]), {b: ExprInt(0x10, 32)}),
     (MatchExpr(e3,
                (((jra ^ jrb) & (jrb ^ jrint1))
                 ^ jra ^ jrb ^ jrint1).canonize(),
diff --git a/test/expression/stp.py b/test/expression/stp.py
index b911a2a4..a4b037de 100755
--- a/test/expression/stp.py
+++ b/test/expression/stp.py
@@ -7,9 +7,9 @@ import unittest
 class TestIrIr2STP(unittest.TestCase):
 
     def test_ExprOp_strcst(self):
-        from miasm2.expression.expression import ExprInt32, ExprOp
+        from miasm2.expression.expression import ExprInt, ExprOp
         import miasm2.expression.stp   # /!\ REALLY DIRTY HACK
-        args = [ExprInt32(i) for i in xrange(9)]
+        args = [ExprInt(i, 32) for i in xrange(9)]
 
         self.assertEqual(
             ExprOp('|',  *args[:2]).strcst(), r'(0bin00000000000000000000000000000000 | 0bin00000000000000000000000000000001)')
@@ -20,9 +20,9 @@ class TestIrIr2STP(unittest.TestCase):
         self.assertRaises(ValueError, ExprOp('X', *args[:1]).strcst)
 
     def test_ExprSlice_strcst(self):
-        from miasm2.expression.expression import ExprInt32, ExprSlice
+        from miasm2.expression.expression import ExprInt, ExprSlice
         import miasm2.expression.stp   # /!\ REALLY DIRTY HACK
-        args = [ExprInt32(i) for i in xrange(9)]
+        args = [ExprInt(i, 32) for i in xrange(9)]
 
         self.assertEqual(
             args[0][1:2].strcst(), r'(0bin00000000000000000000000000000000)[1:1]')
diff --git a/test/ir/ir2C.py b/test/ir/ir2C.py
index 395703ed..a966938b 100755
--- a/test/ir/ir2C.py
+++ b/test/ir/ir2C.py
@@ -13,10 +13,10 @@ class TestIrIr2C(unittest.TestCase):
         self.assertEqual(translator.from_expr(expr), expected)
 
     def test_ExprOp_toC(self):
-        from miasm2.expression.expression import ExprInt32, ExprOp
+        from miasm2.expression.expression import ExprInt, ExprOp
         from miasm2.ir.translators.C import Translator
 
-        args = [ExprInt32(i) for i in xrange(9)]
+        args = [ExprInt(i, 32) for i in xrange(9)]
         translator = Translator.to_language("C")
 
         # Unary operators
diff --git a/test/ir/symbexec.py b/test/ir/symbexec.py
index 48de6573..bd28c4ee 100755
--- a/test/ir/symbexec.py
+++ b/test/ir/symbexec.py
@@ -7,20 +7,20 @@ import unittest
 class TestSymbExec(unittest.TestCase):
 
     def test_ClassDef(self):
-        from miasm2.expression.expression import ExprInt32, ExprId, ExprMem, \
+        from miasm2.expression.expression import ExprInt, ExprId, ExprMem, \
             ExprCompose, ExprAff
         from miasm2.arch.x86.sem import ir_x86_32
         from miasm2.ir.symbexec import SymbolicExecutionEngine
         from miasm2.ir.ir import AssignBlock
 
-        addrX = ExprInt32(-1)
-        addr0 = ExprInt32(0)
-        addr1 = ExprInt32(1)
-        addr8 = ExprInt32(8)
-        addr9 = ExprInt32(9)
-        addr20 = ExprInt32(20)
-        addr40 = ExprInt32(40)
-        addr50 = ExprInt32(50)
+        addrX = ExprInt(-1, 32)
+        addr0 = ExprInt(0, 32)
+        addr1 = ExprInt(1, 32)
+        addr8 = ExprInt(8, 32)
+        addr9 = ExprInt(9, 32)
+        addr20 = ExprInt(20, 32)
+        addr40 = ExprInt(40, 32)
+        addr50 = ExprInt(50, 32)
         mem0 = ExprMem(addr0)
         mem1 = ExprMem(addr1, 8)
         mem8 = ExprMem(addr8)
@@ -44,18 +44,18 @@ class TestSymbExec(unittest.TestCase):
         self.assertEqual(e.eval_expr(ExprMem(addr1 - addr1)), id_x)
         self.assertEqual(e.eval_expr(ExprMem(addr1, 8)), id_y)
         self.assertEqual(e.eval_expr(ExprMem(addr1 + addr1)), ExprCompose(
-            id_x[16:32], ExprMem(ExprInt32(4), 16)))
+            id_x[16:32], ExprMem(ExprInt(4, 32), 16)))
         self.assertEqual(e.eval_expr(mem8), ExprCompose(
-            id_x[0:24], ExprMem(ExprInt32(11), 8)))
+            id_x[0:24], ExprMem(ExprInt(11, 32), 8)))
         self.assertEqual(e.eval_expr(mem40v), id_x[:8])
         self.assertEqual(e.eval_expr(mem50w), ExprCompose(
-            id_y, ExprMem(ExprInt32(51), 8)))
+            id_y, ExprMem(ExprInt(51, 32), 8)))
         self.assertEqual(e.eval_expr(mem20), mem20)
         e.func_read = lambda x: x
         self.assertEqual(e.eval_expr(mem20), mem20)
         self.assertEqual(set(e.modified()), set(e.symbols))
         self.assertRaises(
-            KeyError, e.symbols.__getitem__, ExprMem(ExprInt32(100)))
+            KeyError, e.symbols.__getitem__, ExprMem(ExprInt(100, 32)))
         self.assertEqual(e.apply_expr(id_eax), addr0)
         self.assertEqual(e.apply_expr(ExprAff(id_eax, addr9)), addr9)
         self.assertEqual(e.apply_expr(id_eax), addr9)
diff --git a/test/ir/translators/smt2.py b/test/ir/translators/smt2.py
index 97877a3b..838b0bc5 100644
--- a/test/ir/translators/smt2.py
+++ b/test/ir/translators/smt2.py
@@ -14,10 +14,10 @@ left = ExprCond(e + ExprOp('parity', a),
                 ExprMem(a * a, 64),
                 ExprMem(a, 64))
 
-cond = ExprSlice(ExprSlice(ExprSlice(a, 0, 32) + b, 0, 16) * c, 0, 8) << ExprOp('>>>', d, ExprInt(uint8(0x5L)))
+cond = ExprSlice(ExprSlice(ExprSlice(a, 0, 32) + b, 0, 16) * c, 0, 8) << ExprOp('>>>', d, ExprInt(0x5L, 8))
 right = ExprCond(cond,
-                 a + ExprInt(uint64(0x64L)),
-                 ExprInt(uint64(0x16L)))
+                 a + ExprInt(0x64L, 64),
+                 ExprInt(0x16L, 64))
 
 e = ExprAff(left, right)
 
diff --git a/test/ir/translators/z3_ir.py b/test/ir/translators/z3_ir.py
index 0251c2fe..83744786 100644
--- a/test/ir/translators/z3_ir.py
+++ b/test/ir/translators/z3_ir.py
@@ -60,8 +60,8 @@ z3_e = z3.BitVec('x', 32)
 assert equiv(ez3, z3_e)
 
 # --------------------------------------------------------------------------
-four = ExprInt32(4)
-five = ExprInt32(5)
+four = ExprInt(4, 32)
+five = ExprInt(5, 32)
 e2 = (e + five + four) * five
 ez3 = Translator.to_language('z3').from_expr(e2)
 
@@ -71,9 +71,9 @@ z3_e2 = (z3_e + z3_five + z3_four) * z3_five
 assert equiv(ez3, z3_e2)
 
 # --------------------------------------------------------------------------
-emem = ExprMem(ExprInt32(0xdeadbeef), size=32)
-emem2 = ExprMem(ExprInt32(0xfee1dead), size=32)
-e3 = (emem + e) * ExprInt32(2) * emem2
+emem = ExprMem(ExprInt(0xdeadbeef, 32), size=32)
+emem2 = ExprMem(ExprInt(0xfee1dead, 32), size=32)
+e3 = (emem + e) * ExprInt(2, 32) * emem2
 ez3 = Translator.to_language('z3').from_expr(e3)
 
 mem = Z3Mem()
@@ -122,8 +122,8 @@ assert equiv(ez3, z3_e5)
 
 # --------------------------------------------------------------------------
 # Parity
-seven = ExprInt32(7)
-one0seven = ExprInt32(0x107)
+seven = ExprInt(7, 32)
+one0seven = ExprInt(0x107, 32)
 for miasm_int, res in [(five, 1), (four, 0), (seven, 0), (one0seven, 0)]:
     e6 = ExprOp('parity', miasm_int)
     ez3 = Translator.to_language('z3').from_expr(e6)
diff --git a/test/jitter/jitload.py b/test/jitter/jitload.py
index 544e9d18..dff1f0d6 100644
--- a/test/jitter/jitload.py
+++ b/test/jitter/jitload.py
@@ -3,8 +3,7 @@ from pdb import pm
 
 from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
 from miasm2.analysis.machine import Machine
-from miasm2.expression.expression import ExprId, ExprInt32, ExprInt64, ExprAff, \
-    ExprMem
+from miasm2.expression.expression import ExprId, ExprAff, ExprInt, ExprMem
 
 # Initial data: from 'example/samples/x86_32_sc.bin'
 data = "8d49048d5b0180f90174058d5bffeb038d5b0189d8c3".decode("hex")
@@ -38,8 +37,8 @@ assert myjit.cpu.ECX == 4
 
 # Check eval_expr
 eax = ExprId("RAX", 64)[:32]
-imm0, imm4, imm4_64 = ExprInt32(0), ExprInt32(4), ExprInt64(4)
-memdata = ExprMem(ExprInt32(run_addr), len(data) * 8)
+imm0, imm4, imm4_64 = ExprInt(0, 32), ExprInt(4, 32), ExprInt(4, 64)
+memdata = ExprMem(ExprInt(run_addr, 32), len(data) * 8)
 assert myjit.eval_expr(eax) == imm0
 ## Due to ExprAff construction, imm4 is "promoted" to imm4_64
 assert myjit.eval_expr(ExprAff(eax, imm4)) == imm4_64