297 files changed, 1058 insertions, 1055 deletions

diff --git a/README.md b/README.md
index bee55db3..010f75d6 100644
--- a/README.md
+++ b/README.md
@@ -47,8 +47,8 @@ Assembling / Disassembling
 
 Import Miasm x86 architecture:
 ```pycon
->>> from miasm2.arch.x86.arch import mn_x86
->>> from miasm2.core.locationdb import LocationDB
+>>> from miasm.arch.x86.arch import mn_x86
+>>> from miasm.core.locationdb import LocationDB
 ```
 Get a location db:
 
@@ -80,7 +80,7 @@ XOR        EAX, ECX
 Using `Machine` abstraction:
 
 ```pycon
->>> from miasm2.analysis.machine import Machine
+>>> from miasm.analysis.machine import Machine
 >>> mn = Machine('x86_32').mn
 >>> print(mn.dis('\x33\x30', 32))
 XOR        ESI, DWORD PTR [EAX]
@@ -164,16 +164,16 @@ Giving a shellcode:
 Import the shellcode thanks to the `Container` abstraction:
 
 ```pycon
->>> from miasm2.analysis.binary import Container
+>>> from miasm.analysis.binary import Container
 >>> c = Container.from_string(s)
 >>> c
-<miasm2.analysis.binary.ContainerUnknown object at 0x7f34cefe6090>
+<miasm.analysis.binary.ContainerUnknown object at 0x7f34cefe6090>
 ```
 
 Disassembling the shellcode at address `0`:
 
 ```pycon
->>> from miasm2.analysis.machine import Machine
+>>> from miasm.analysis.machine import Machine
 >>> machine = Machine('x86_32')
 >>> mdis = machine.dis_engine(c.bin_stream)
 >>> asmcfg = mdis.dis_multiblock(0)
@@ -208,7 +208,7 @@ Initializing the Jit engine with a stack:
 Add the shellcode in an arbitrary memory location:
 ```pycon
 >>> run_addr = 0x40000000
->>> from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+>>> from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 >>> jitter.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, s)
 ```
 
@@ -284,7 +284,7 @@ Initializing the IR pool:
 Initializing the engine with default symbolic values:
 
 ```pycon
->>> from miasm2.ir.symbexec import SymbolicExecutionEngine
+>>> from miasm.ir.symbexec import SymbolicExecutionEngine
 >>> sb = SymbolicExecutionEngine(ira)
 ```
 
@@ -355,7 +355,7 @@ ________________________________________________________________________________
 Retry execution with a concrete ECX. Here, the symbolic / concolic execution reach the shellcode's end:
 
 ```pycon
->>> from miasm2.expression.expression import ExprInt
+>>> from miasm.expression.expression import ExprInt
 >>> sb.symbols[machine.mn.regs.ECX] = ExprInt(-3, 32)
 >>> symbolic_pc = sb.run_at(ircfg, 0, step=True)
 Instr LEA        ECX, DWORD PTR [ECX + 0x4]
@@ -571,7 +571,7 @@ Windows & IDA
 Most of Miasm's IDA plugins use a subset of Miasm functionality.
 A quick way to have them working is to add:
 * `elfesteem` directory and `pyparsing.py` to `C:\...\IDA\python\` or `pip install pyparsing elfesteem`
-* `miasm2/miasm2` directory to `C:\...\IDA\python\`
+* `miasm/miasm` directory to `C:\...\IDA\python\`
 
 All features excepting JITter related ones will be available. For a more complete installation, please refer to above paragraphs.
 
@@ -598,7 +598,7 @@ Tools
 -----
 
 * [Sibyl](https://github.com/cea-sec/Sibyl): A function divination too
-* [R2M2](https://github.com/guedou/r2m2): Use miasm2 as a radare2 plugin
+* [R2M2](https://github.com/guedou/r2m2): Use miasm as a radare2 plugin
 * [CGrex](https://github.com/mechaphish/cgrex) : Targeted patcher for CGC binaries
 * [ethRE](https://github.com/jbcayrou/ethRE) Reversing tool for Ethereum EVM (with corresponding Miasm2 architecture)
 
diff --git a/example/asm/shellcode.py b/example/asm/shellcode.py
index b14b7441..ed489bbd 100755
--- a/example/asm/shellcode.py
+++ b/example/asm/shellcode.py
@@ -7,11 +7,11 @@ from future.utils import viewitems
 from elfesteem import pe_init
 from elfesteem.strpatchwork import StrPatchwork
 
-from miasm2.core import parse_asm, asmblock
-from miasm2.analysis.machine import Machine
-from miasm2.core.interval import interval
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import iterbytes, int_to_byte
+from miasm.core import parse_asm, asmblock
+from miasm.analysis.machine import Machine
+from miasm.core.interval import interval
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import iterbytes, int_to_byte
 
 parser = ArgumentParser("Multi-arch (32 bits) assembler")
 parser.add_argument('architecture', help="architecture: " +
diff --git a/example/asm/simple.py b/example/asm/simple.py
index e46faa48..8f6aac92 100644
--- a/example/asm/simple.py
+++ b/example/asm/simple.py
@@ -2,8 +2,8 @@ from __future__ import print_function
 from pdb import pm
 from pprint import pprint
 
-from miasm2.arch.x86.arch import mn_x86
-from miasm2.core import parse_asm, asmblock
+from miasm.arch.x86.arch import mn_x86
+from miasm.core import parse_asm, asmblock
 
 
 # Assemble code
diff --git a/example/disasm/callback.py b/example/disasm/callback.py
index 95c165d4..7219462f 100644
--- a/example/disasm/callback.py
+++ b/example/disasm/callback.py
@@ -1,7 +1,7 @@
 from __future__ import print_function
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
-from miasm2.core.asmblock import AsmConstraint
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
+from miasm.core.asmblock import AsmConstraint
 
 
 def cb_x86_callpop(cur_bloc, loc_db, *args, **kwargs):
diff --git a/example/disasm/dis_binary.py b/example/disasm/dis_binary.py
index 4ac5ef26..37eabb14 100644
--- a/example/disasm/dis_binary.py
+++ b/example/disasm/dis_binary.py
@@ -1,7 +1,7 @@
 from __future__ import print_function
 import sys
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
 
 fdesc = open(sys.argv[1], 'rb')
 
diff --git a/example/disasm/dis_binary_ir.py b/example/disasm/dis_binary_ir.py
index ac642a36..ff7a0d36 100644
--- a/example/disasm/dis_binary_ir.py
+++ b/example/disasm/dis_binary_ir.py
@@ -1,8 +1,8 @@
 from __future__ import print_function
 import sys
 from future.utils import viewvalues
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
 
 #####################################
 # Common section from dis_binary.py #
diff --git a/example/disasm/dis_binary_ira.py b/example/disasm/dis_binary_ira.py
index 04bddbbb..3ecd5349 100644
--- a/example/disasm/dis_binary_ira.py
+++ b/example/disasm/dis_binary_ira.py
@@ -1,8 +1,9 @@
 from __future__ import print_function
 import sys
+
 from future.utils import viewvalues
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
 
 #####################################
 # Common section from dis_binary.py #
diff --git a/example/disasm/dis_x86_string.py b/example/disasm/dis_x86_string.py
index 175e9264..6d4e2c84 100644
--- a/example/disasm/dis_x86_string.py
+++ b/example/disasm/dis_x86_string.py
@@ -1,6 +1,6 @@
 from __future__ import print_function
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
 
 # The Container will provide a *bin_stream*, bytes source for the disasm engine
 cont = Container.from_string(b"\x83\xf8\x10\x74\x07\x89\xc6\x0f\x47\xc3\xeb\x08\x89\xc8\xe8\x31\x33\x22\x11\x40\xc3")
diff --git a/example/disasm/full.py b/example/disasm/full.py
index de3f82ac..f7268ad0 100644
--- a/example/disasm/full.py
+++ b/example/disasm/full.py
@@ -5,17 +5,17 @@ from pdb import pm
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.analysis.binary import Container
-from miasm2.core.asmblock import log_asmblock, AsmCFG
-from miasm2.core.interval import interval
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.data_flow import dead_simp, \
+from miasm.analysis.binary import Container
+from miasm.core.asmblock import log_asmblock, AsmCFG
+from miasm.core.interval import interval
+from miasm.analysis.machine import Machine
+from miasm.analysis.data_flow import dead_simp, \
     DiGraphDefUse, ReachingDefinitions, \
     replace_stack_vars, load_from_int, del_unused_edges
-from miasm2.expression.simplifications import expr_simp
-from miasm2.analysis.ssa import SSADiGraph
-from miasm2.ir.ir import AssignBlock, IRBlock
-from miasm2.analysis.simplifier import IRCFGSimplifierCommon, IRCFGSimplifierSSA
+from miasm.expression.simplifications import expr_simp
+from miasm.analysis.ssa import SSADiGraph
+from miasm.ir.ir import AssignBlock, IRBlock
+from miasm.analysis.simplifier import IRCFGSimplifierCommon, IRCFGSimplifierSSA
 
 log = logging.getLogger("dis")
 console_handler = logging.StreamHandler()
diff --git a/example/disasm/single_instr.py b/example/disasm/single_instr.py
index 70b37220..eee527b1 100644
--- a/example/disasm/single_instr.py
+++ b/example/disasm/single_instr.py
@@ -1,7 +1,7 @@
 from __future__ import print_function
-from miasm2.arch.x86.arch import mn_x86
-from miasm2.arch.x86.regs import EDX
-from miasm2.core.locationdb import LocationDB
+from miasm.arch.x86.arch import mn_x86
+from miasm.arch.x86.regs import EDX
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 l = mn_x86.fromstring('MOV EAX, EBX', loc_db, 32)
diff --git a/example/expression/access_c.py b/example/expression/access_c.py
index c6f26a10..c604a0bd 100644
--- a/example/expression/access_c.py
+++ b/example/expression/access_c.py
@@ -45,16 +45,16 @@ import sys
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
-from miasm2.expression.expression import ExprOp, ExprCompose, ExprId, ExprInt
-from miasm2.analysis.depgraph import DependencyGraph
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.expression.expression import ExprOp, ExprCompose, ExprId, ExprInt
+from miasm.analysis.depgraph import DependencyGraph
 
-from miasm2.arch.x86.ctype import CTypeAMD64_unk
+from miasm.arch.x86.ctype import CTypeAMD64_unk
 
-from miasm2.core.objc import ExprToAccessC, CHandler
-from miasm2.core.objc import CTypesManagerNotPacked
-from miasm2.core.ctypesmngr import CAstTypes, CTypePtr, CTypeStruct
+from miasm.core.objc import ExprToAccessC, CHandler
+from miasm.core.objc import CTypesManagerNotPacked
+from miasm.core.ctypesmngr import CAstTypes, CTypePtr, CTypeStruct
 
 def find_call(ircfg):
     """Returns (irb, index) which call"""
diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py
index 16f766e1..4bcbb05d 100644
--- a/example/expression/asm_to_ir.py
+++ b/example/expression/asm_to_ir.py
@@ -3,12 +3,12 @@ from pdb import pm
 
 from future.utils import viewitems
 
-from miasm2.arch.x86.arch import mn_x86
-from miasm2.core import parse_asm
-from miasm2.expression.expression import *
-from miasm2.core import asmblock
-from miasm2.arch.x86.ira import ir_a_x86_32
-from miasm2.analysis.data_flow import dead_simp
+from miasm.arch.x86.arch import mn_x86
+from miasm.core import parse_asm
+from miasm.expression.expression import *
+from miasm.core import asmblock
+from miasm.arch.x86.ira import ir_a_x86_32
+from miasm.analysis.data_flow import dead_simp
 
 
 # First, asm code
diff --git a/example/expression/basic_op.py b/example/expression/basic_op.py
index 8b5d7e2b..afeb4081 100644
--- a/example/expression/basic_op.py
+++ b/example/expression/basic_op.py
@@ -1,5 +1,5 @@
 from __future__ import print_function
-from miasm2.expression.expression import *
+from miasm.expression.expression import *
 
 print("""
 Simple expression manipulation demo
diff --git a/example/expression/basic_simplification.py b/example/expression/basic_simplification.py
index 5ecf21db..05ebefc6 100644
--- a/example/expression/basic_simplification.py
+++ b/example/expression/basic_simplification.py
@@ -1,6 +1,6 @@
 from __future__ import print_function
-from miasm2.expression.expression import *
-from miasm2.expression.simplifications import expr_simp
+from miasm.expression.expression import *
+from miasm.expression.simplifications import expr_simp
 
 print("""
 Simple expression simplification demo
diff --git a/example/expression/constant_propagation.py b/example/expression/constant_propagation.py
index 1259758b..a6efbb46 100644
--- a/example/expression/constant_propagation.py
+++ b/example/expression/constant_propagation.py
@@ -6,12 +6,12 @@ A "constant expression" is an expression based on constants or init regs.
 
 from argparse import ArgumentParser
 
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
-from miasm2.analysis.cst_propag import propagate_cst_expr
-from miasm2.analysis.data_flow import dead_simp, \
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.cst_propag import propagate_cst_expr
+from miasm.analysis.data_flow import dead_simp, \
     merge_blocks, remove_empty_assignblks
-from miasm2.expression.simplifications import expr_simp
+from miasm.expression.simplifications import expr_simp
 
 
 parser = ArgumentParser("Constant expression propagation")
diff --git a/example/expression/export_llvm.py b/example/expression/export_llvm.py
index c8ee14a5..241a907d 100644
--- a/example/expression/export_llvm.py
+++ b/example/expression/export_llvm.py
@@ -1,11 +1,11 @@
 from future.utils import viewitems, viewvalues
 
 from argparse import ArgumentParser
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.llvmconvert import LLVMType, LLVMContext_IRCompilation, LLVMFunction_IRCompilation
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
+from miasm.jitter.llvmconvert import LLVMType, LLVMContext_IRCompilation, LLVMFunction_IRCompilation
 from llvmlite import ir as llvm_ir
-from miasm2.expression.simplifications import expr_simp_high_to_explicit
+from miasm.expression.simplifications import expr_simp_high_to_explicit
 
 parser = ArgumentParser("LLVM export example")
 parser.add_argument("target", help="Target binary")
diff --git a/example/expression/expr_c.py b/example/expression/expr_c.py
index 83cc727b..cdfdf4ca 100644
--- a/example/expression/expr_c.py
+++ b/example/expression/expr_c.py
@@ -5,10 +5,10 @@ Parse C expression to access variables and retrieve information:
 """
 from __future__ import print_function
 
-from miasm2.core.ctypesmngr import CTypeStruct, CAstTypes, CTypePtr
-from miasm2.arch.x86.ctype import CTypeAMD64_unk
-from miasm2.core.objc import CTypesManagerNotPacked, CHandler
-from miasm2.expression.expression import ExprId
+from miasm.core.ctypesmngr import CTypeStruct, CAstTypes, CTypePtr
+from miasm.arch.x86.ctype import CTypeAMD64_unk
+from miasm.core.objc import CTypesManagerNotPacked, CHandler
+from miasm.expression.expression import ExprId
 
 
 """
diff --git a/example/expression/expr_grapher.py b/example/expression/expr_grapher.py
index e1643b03..2550c5d3 100644
--- a/example/expression/expr_grapher.py
+++ b/example/expression/expr_grapher.py
@@ -1,6 +1,6 @@
 from __future__ import print_function
 
-from miasm2.expression.expression import *
+from miasm.expression.expression import *
 
 print("Simple Expression grapher demo")
 
diff --git a/example/expression/expr_random.py b/example/expression/expr_random.py
index 5ac3be06..e1164f6f 100644
--- a/example/expression/expr_random.py
+++ b/example/expression/expr_random.py
@@ -3,7 +3,7 @@ from builtins import range
 import string
 import random
 
-from miasm2.expression.expression_helper import ExprRandom
+from miasm.expression.expression_helper import ExprRandom
 
 print("Simple expression generator\n")
 
diff --git a/example/expression/expr_reduce.py b/example/expression/expr_reduce.py
index 0f575e57..4c8b6c83 100644
--- a/example/expression/expr_reduce.py
+++ b/example/expression/expr_reduce.py
@@ -1,5 +1,5 @@
-from miasm2.expression.expression import ExprId, ExprInt, ExprMem
-from miasm2.expression.expression_reduce import ExprReducer
+from miasm.expression.expression import ExprId, ExprInt, ExprMem
+from miasm.expression.expression_reduce import ExprReducer
 
 
 class StructLookup(ExprReducer):
diff --git a/example/expression/expr_translate.py b/example/expression/expr_translate.py
index 1a36a64c..8562975f 100644
--- a/example/expression/expr_translate.py
+++ b/example/expression/expr_translate.py
@@ -3,9 +3,9 @@ import random
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import *
-from miasm2.expression.expression_helper import ExprRandom
-from miasm2.ir.translators import Translator
+from miasm.expression.expression import *
+from miasm.expression.expression_helper import ExprRandom
+from miasm.ir.translators import Translator
 
 random.seed(0)
 
diff --git a/example/expression/get_read_write.py b/example/expression/get_read_write.py
index 0c8bb3dd..cf333d0c 100644
--- a/example/expression/get_read_write.py
+++ b/example/expression/get_read_write.py
@@ -2,10 +2,10 @@ from __future__ import print_function
 
 from future.utils import viewitems
 
-from miasm2.arch.x86.arch import mn_x86
-from miasm2.expression.expression import get_rw
-from miasm2.arch.x86.ira import ir_a_x86_32
-from miasm2.core.locationdb import LocationDB
+from miasm.arch.x86.arch import mn_x86
+from miasm.expression.expression import get_rw
+from miasm.arch.x86.ira import ir_a_x86_32
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 
diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py
index 55159598..c320fba0 100644
--- a/example/expression/graph_dataflow.py
+++ b/example/expression/graph_dataflow.py
@@ -3,13 +3,13 @@ from argparse import ArgumentParser
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
-from miasm2.expression.expression import get_expr_mem
-from miasm2.analysis.data_analysis import intra_block_flow_raw, inter_block_flow
-from miasm2.core.graph import DiGraph
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.analysis.data_flow import dead_simp
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
+from miasm.expression.expression import get_expr_mem
+from miasm.analysis.data_analysis import intra_block_flow_raw, inter_block_flow
+from miasm.core.graph import DiGraph
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.analysis.data_flow import dead_simp
 
 
 parser = ArgumentParser("Simple expression use for generating dataflow graph")
diff --git a/example/expression/simplification_add.py b/example/expression/simplification_add.py
index 6ac36a17..ff28d56e 100644
--- a/example/expression/simplification_add.py
+++ b/example/expression/simplification_add.py
@@ -1,13 +1,13 @@
 from __future__ import print_function
-import miasm2.expression.expression as m2_expr
-from miasm2.expression.simplifications import expr_simp
+import miasm.expression.expression as m2_expr
+from miasm.expression.simplifications import expr_simp
 from pdb import pm
 
 print("""
 Expression simplification demo: Adding a simplification:
 a + a + a == a * 3
 
-More detailed examples can be found in miasm2/expression/simplification*.
+More detailed examples can be found in miasm/expression/simplification*.
 """)
 
 # Define the simplification method
diff --git a/example/expression/simplification_tools.py b/example/expression/simplification_tools.py
index a9bcc429..b5fafba2 100644
--- a/example/expression/simplification_tools.py
+++ b/example/expression/simplification_tools.py
@@ -1,5 +1,5 @@
 from __future__ import print_function
-from miasm2.expression.expression import *
+from miasm.expression.expression import *
 from pdb import pm
 
 print("""
diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py
index e0ab09da..2c654b77 100644
--- a/example/expression/solve_condition_stp.py
+++ b/example/expression/solve_condition_stp.py
@@ -6,15 +6,15 @@ from pdb import pm
 
 from future.utils import viewitems
 
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
-from miasm2.expression.expression import ExprInt, ExprCond, ExprId, \
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.expression.expression import ExprInt, ExprCond, ExprId, \
     get_expr_ids, ExprAssign, ExprLoc
-from miasm2.core.bin_stream import bin_stream_str
-from miasm2.ir.symbexec import SymbolicExecutionEngine, get_block
-from miasm2.expression.simplifications import expr_simp
-from miasm2.core import parse_asm
-from miasm2.ir.translators.translator  import Translator
+from miasm.core.bin_stream import bin_stream_str
+from miasm.ir.symbexec import SymbolicExecutionEngine, get_block
+from miasm.expression.simplifications import expr_simp
+from miasm.core import parse_asm
+from miasm.ir.translators.translator  import Translator
 
 machine = Machine("x86_32")
 
diff --git a/example/ida/ctype_propagation.py b/example/ida/ctype_propagation.py
index a043b9c9..f333d69a 100644
--- a/example/ida/ctype_propagation.py
+++ b/example/ida/ctype_propagation.py
@@ -5,18 +5,18 @@ import ida_funcs
 
 from future.utils import viewitems
 
-from miasm2.core.bin_stream_ida import bin_stream_ida
-from miasm2.expression import expression as m2_expr
-from miasm2.expression.simplifications import expr_simp
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.arch.x86.ctype import CTypeAMD64_unk, CTypeX86_unk
-from miasm2.arch.msp430.ctype import CTypeMSP430_unk
-from miasm2.core.objc import CTypesManagerNotPacked, ExprToAccessC, CHandler
-from miasm2.core.ctypesmngr import CAstTypes
-from miasm2.expression.expression import ExprLoc, ExprInt, ExprOp, ExprAssign
-from miasm2.ir.symbexec_types import SymbExecCType
-from miasm2.expression.parser import str_to_expr
-from miasm2.analysis.cst_propag import add_state, propagate_cst_expr
+from miasm.core.bin_stream_ida import bin_stream_ida
+from miasm.expression import expression as m2_expr
+from miasm.expression.simplifications import expr_simp
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.arch.x86.ctype import CTypeAMD64_unk, CTypeX86_unk
+from miasm.arch.msp430.ctype import CTypeMSP430_unk
+from miasm.core.objc import CTypesManagerNotPacked, ExprToAccessC, CHandler
+from miasm.core.ctypesmngr import CAstTypes
+from miasm.expression.expression import ExprLoc, ExprInt, ExprOp, ExprAssign
+from miasm.ir.symbexec_types import SymbExecCType
+from miasm.expression.parser import str_to_expr
+from miasm.analysis.cst_propag import add_state, propagate_cst_expr
 
 from utils import guess_machine
 
diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py
index 3de19cbc..73fc0f87 100644
--- a/example/ida/depgraph.py
+++ b/example/ida/depgraph.py
@@ -12,13 +12,13 @@ import ida_funcs
 import ida_kernwin
 
 
-from miasm2.core.bin_stream_ida import bin_stream_ida
-from miasm2.core.asmblock import *
-from miasm2.expression import expression as m2_expr
+from miasm.core.bin_stream_ida import bin_stream_ida
+from miasm.core.asmblock import *
+from miasm.expression import expression as m2_expr
 
-from miasm2.expression.simplifications import expr_simp
-from miasm2.analysis.depgraph import DependencyGraph
-from miasm2.ir.ir import AssignBlock, IRBlock
+from miasm.expression.simplifications import expr_simp
+from miasm.analysis.depgraph import DependencyGraph
+from miasm.ir.ir import AssignBlock, IRBlock
 
 from utils import guess_machine
 
diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py
index de46c22d..c011b4c3 100644
--- a/example/ida/graph_ir.py
+++ b/example/ida/graph_ir.py
@@ -11,13 +11,13 @@ import idc
 import ida_funcs
 import idautils
 
-from miasm2.core.asmblock import is_int
-from miasm2.core.bin_stream_ida import bin_stream_ida
-from miasm2.expression.simplifications import expr_simp
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.analysis.data_flow import load_from_int
+from miasm.core.asmblock import is_int
+from miasm.core.bin_stream_ida import bin_stream_ida
+from miasm.expression.simplifications import expr_simp
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.analysis.data_flow import load_from_int
 from utils import guess_machine, expr2colorstr
-from miasm2.analysis.simplifier import IRCFGSimplifierCommon, IRCFGSimplifierSSA
+from miasm.analysis.simplifier import IRCFGSimplifierCommon, IRCFGSimplifierSSA
 
 
 
diff --git a/example/ida/symbol_exec.py b/example/ida/symbol_exec.py
index aa1d57fe..c0ed89f3 100644
--- a/example/ida/symbol_exec.py
+++ b/example/ida/symbol_exec.py
@@ -7,8 +7,8 @@ import idaapi
 import idc
 
 
-from miasm2.expression.expression_helper import Variables_Identifier
-from miasm2.expression.expression import ExprAssign
+from miasm.expression.expression_helper import Variables_Identifier
+from miasm.expression.expression import ExprAssign
 
 from utils import expr2colorstr, translatorForm
 
@@ -130,8 +130,8 @@ class Hooks(idaapi.UI_Hooks):
 
 
 def symbolic_exec():
-    from miasm2.ir.symbexec import SymbolicExecutionEngine
-    from miasm2.core.bin_stream_ida import bin_stream_ida
+    from miasm.ir.symbexec import SymbolicExecutionEngine
+    from miasm.core.bin_stream_ida import bin_stream_ida
 
     from utils import guess_machine
 
diff --git a/example/ida/utils.py b/example/ida/utils.py
index b6d5dac4..cb4ef4d8 100644
--- a/example/ida/utils.py
+++ b/example/ida/utils.py
@@ -3,9 +3,9 @@ from builtins import map
 import idaapi
 from idc import *
 
-from miasm2.analysis.machine import Machine
-from miasm2.ir.translators import Translator
-import miasm2.expression.expression as m2_expr
+from miasm.analysis.machine import Machine
+from miasm.ir.translators import Translator
+import miasm.expression.expression as m2_expr
 
 def guess_machine(addr=None):
     "Return an instance of Machine corresponding to the IDA guessed processor"
@@ -55,8 +55,8 @@ def guess_machine(addr=None):
             raise NotImplementedError('not fully functional')
         machine = Machine(info2machine[infos])
 
-        from miasm2.analysis.disasm_cb import guess_funcs, guess_multi_cb
-        from miasm2.analysis.disasm_cb import arm_guess_subcall, arm_guess_jump_table
+        from miasm.analysis.disasm_cb import guess_funcs, guess_multi_cb
+        from miasm.analysis.disasm_cb import arm_guess_subcall, arm_guess_jump_table
         guess_funcs.append(arm_guess_subcall)
         guess_funcs.append(arm_guess_jump_table)
 
diff --git a/example/jitter/arm.py b/example/jitter/arm.py
index 86772874..daea2428 100755
--- a/example/jitter/arm.py
+++ b/example/jitter/arm.py
@@ -4,7 +4,7 @@ from __future__ import print_function
 import logging
 from pdb import pm
 
-from miasm2.analysis.sandbox import Sandbox_Linux_arml
+from miasm.analysis.sandbox import Sandbox_Linux_arml
 
 # Get arguments
 parser = Sandbox_Linux_arml.parser(description="""Sandbox an elf binary with arm
diff --git a/example/jitter/arm_sc.py b/example/jitter/arm_sc.py
index b81d3784..8d5b5677 100755
--- a/example/jitter/arm_sc.py
+++ b/example/jitter/arm_sc.py
@@ -1,8 +1,8 @@
 #! /usr/bin/env python2
 #-*- coding:utf-8 -*-
-from miasm2.core.utils import int_to_byte
-from miasm2.analysis.sandbox import Sandbox_Linux_armb_str
-from miasm2.analysis.sandbox import Sandbox_Linux_arml_str
+from miasm.core.utils import int_to_byte
+from miasm.analysis.sandbox import Sandbox_Linux_armb_str
+from miasm.analysis.sandbox import Sandbox_Linux_arml_str
 from elfesteem.strpatchwork import StrPatchwork
 
 from pdb import pm
diff --git a/example/jitter/example_types.py b/example/jitter/example_types.py
index d0751bbd..653adaf9 100755
--- a/example/jitter/example_types.py
+++ b/example/jitter/example_types.py
@@ -1,16 +1,16 @@
 #! /usr/bin/env python2
-"""This script is just a short example of common usages for miasm2.core.types.
+"""This script is just a short example of common usages for miasm.core.types.
 For a more complete view of what is possible, tests/core/types.py covers
 most of the module possibilities, and the module doc gives useful information
 as well.
 """
 from __future__ import print_function
 
-from miasm2.core.utils import iterbytes
-from miasm2.analysis.machine import Machine
-from miasm2.core.types import MemStruct, Self, Void, Str, Array, Ptr, \
+from miasm.core.utils import iterbytes
+from miasm.analysis.machine import Machine
+from miasm.core.types import MemStruct, Self, Void, Str, Array, Ptr, \
                               Num, Array, set_allocator
-from miasm2.os_dep.common import heap
+from miasm.os_dep.common import heap
 
 # Instantiate a heap
 my_heap = heap()
@@ -152,7 +152,7 @@ print("module in the first part, and how to play with some casts in the second."
 print()
 
 # A random jitter
-# You can also use miasm2.jitter.VmMngr.Vm(), but it does not happen in real
+# You can also use miasm.jitter.VmMngr.Vm(), but it does not happen in real
 # life scripts, so here is the usual way:
 jitter = Machine("x86_32").jitter("python")
 vm = jitter.vm
@@ -255,6 +255,6 @@ print("An argv instance:", repr(argv))
 print("argv values:", repr([val.deref.val for val in argv[:-1]]))
 print()
 
-print("See test/core/types.py and the miasm2.core.types module doc for ")
+print("See test/core/types.py and the miasm.core.types module doc for ")
 print("more information.")
 
diff --git a/example/jitter/mips32.py b/example/jitter/mips32.py
index 2eb06c87..4aeb576f 100755
--- a/example/jitter/mips32.py
+++ b/example/jitter/mips32.py
@@ -2,9 +2,9 @@
 #-*- coding:utf-8 -*-
 from __future__ import print_function
 from argparse import ArgumentParser
-from miasm2.analysis import debugging
-from miasm2.jitter.csts import *
-from miasm2.analysis.machine import Machine
+from miasm.analysis import debugging
+from miasm.jitter.csts import *
+from miasm.analysis.machine import Machine
 
 parser = ArgumentParser(
     description="""Sandbox raw binary with mips32 engine
diff --git a/example/jitter/msp430.py b/example/jitter/msp430.py
index 1ecb4cef..972a1fdc 100755
--- a/example/jitter/msp430.py
+++ b/example/jitter/msp430.py
@@ -2,9 +2,9 @@
 #-*- coding:utf-8 -*-
 from __future__ import print_function
 from argparse import ArgumentParser
-from miasm2.analysis import debugging
-from miasm2.jitter.csts import *
-from miasm2.analysis.machine import Machine
+from miasm.analysis import debugging
+from miasm.jitter.csts import *
+from miasm.analysis.machine import Machine
 
 parser = ArgumentParser(
     description="""Sandbox raw binary with msp430 engine
diff --git a/example/jitter/run_with_linuxenv.py b/example/jitter/run_with_linuxenv.py
index fda76f9a..e2869699 100644
--- a/example/jitter/run_with_linuxenv.py
+++ b/example/jitter/run_with_linuxenv.py
@@ -4,9 +4,9 @@ import re
 
 from elfesteem import elf as elf_csts
 
-from miasm2.os_dep.linux import environment, syscall
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
+from miasm.os_dep.linux import environment, syscall
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
 
 parser = ArgumentParser("Run an ELF in a Linux-like environment")
 parser.add_argument("target", help="Target ELF")
diff --git a/example/jitter/sandbox_call.py b/example/jitter/sandbox_call.py
index 3eb0b86e..7d400b7d 100644
--- a/example/jitter/sandbox_call.py
+++ b/example/jitter/sandbox_call.py
@@ -1,10 +1,10 @@
 """This example illustrate the Sandbox.call API, for direct call of a given
 function"""
 
-from miasm2.analysis.sandbox import Sandbox_Linux_arml
-from miasm2.analysis.binary import Container
-from miasm2.os_dep.linux_stdlib import linobjs
-from miasm2.core.utils import hexdump
+from miasm.analysis.sandbox import Sandbox_Linux_arml
+from miasm.analysis.binary import Container
+from miasm.os_dep.linux_stdlib import linobjs
+from miasm.core.utils import hexdump
 
 # Parse arguments
 parser = Sandbox_Linux_arml.parser(description="ELF sandboxer")
diff --git a/example/jitter/sandbox_elf_aarch64l.py b/example/jitter/sandbox_elf_aarch64l.py
index 0f028876..472b2354 100644
--- a/example/jitter/sandbox_elf_aarch64l.py
+++ b/example/jitter/sandbox_elf_aarch64l.py
@@ -1,7 +1,7 @@
 import logging
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Linux_aarch64l
-from miasm2.jitter.jitload import log_func
+from miasm.analysis.sandbox import Sandbox_Linux_aarch64l
+from miasm.jitter.jitload import log_func
 
 # Insert here user defined methods
 
diff --git a/example/jitter/sandbox_elf_ppc32.py b/example/jitter/sandbox_elf_ppc32.py
index 04ecfd9e..829381fc 100644
--- a/example/jitter/sandbox_elf_ppc32.py
+++ b/example/jitter/sandbox_elf_ppc32.py
@@ -1,8 +1,8 @@
 import os
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Linux_ppc32b
-from miasm2.jitter.csts import *
-from miasm2.jitter.jitload import log_func
+from miasm.analysis.sandbox import Sandbox_Linux_ppc32b
+from miasm.jitter.csts import *
+from miasm.jitter.jitload import log_func
 import logging
 
 # Insert here user defined methods
diff --git a/example/jitter/sandbox_pe_x86_32.py b/example/jitter/sandbox_pe_x86_32.py
index 3a627b19..263fad94 100644
--- a/example/jitter/sandbox_pe_x86_32.py
+++ b/example/jitter/sandbox_pe_x86_32.py
@@ -1,5 +1,5 @@
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Win_x86_32
+from miasm.analysis.sandbox import Sandbox_Win_x86_32
 
 # Insert here user defined methods
 
diff --git a/example/jitter/sandbox_pe_x86_64.py b/example/jitter/sandbox_pe_x86_64.py
index 773c54b9..4d8f00ce 100644
--- a/example/jitter/sandbox_pe_x86_64.py
+++ b/example/jitter/sandbox_pe_x86_64.py
@@ -1,5 +1,5 @@
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Win_x86_64
+from miasm.analysis.sandbox import Sandbox_Win_x86_64
 
 # Insert here user defined methods
 
diff --git a/example/jitter/test_x86_32_seh.py b/example/jitter/test_x86_32_seh.py
index e7f8cff4..595b9586 100644
--- a/example/jitter/test_x86_32_seh.py
+++ b/example/jitter/test_x86_32_seh.py
@@ -1,8 +1,8 @@
 import os
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Win_x86_32
-from miasm2.os_dep import win_api_x86_32_seh
-from miasm2.jitter.csts import *
+from miasm.analysis.sandbox import Sandbox_Win_x86_32
+from miasm.os_dep import win_api_x86_32_seh
+from miasm.jitter.csts import *
 
 def deal_exception_access_violation(jitter):
     jitter.pc = win_api_x86_32_seh.fake_seh_handler(jitter, win_api_x86_32_seh.EXCEPTION_ACCESS_VIOLATION)
diff --git a/example/jitter/trace.py b/example/jitter/trace.py
index 9f025bfd..46b313c1 100644
--- a/example/jitter/trace.py
+++ b/example/jitter/trace.py
@@ -11,9 +11,9 @@ from __future__ import print_function
 import os
 import time
 from pdb import pm
-from miasm2.analysis.sandbox import Sandbox_Linux_arml
-from miasm2.jitter.emulatedsymbexec import EmulatedSymbExec
-from miasm2.jitter.jitcore_python import JitCore_Python
+from miasm.analysis.sandbox import Sandbox_Linux_arml
+from miasm.jitter.emulatedsymbexec import EmulatedSymbExec
+from miasm.jitter.jitcore_python import JitCore_Python
 
 # Function called at each instruction
 instr_count = 0
diff --git a/example/jitter/unpack_upx.py b/example/jitter/unpack_upx.py
index 5d862dd1..0a41d038 100644
--- a/example/jitter/unpack_upx.py
+++ b/example/jitter/unpack_upx.py
@@ -3,7 +3,7 @@ import os
 import logging
 from pdb import pm
 from elfesteem import pe
-from miasm2.analysis.sandbox import Sandbox_Win_x86_32
+from miasm.analysis.sandbox import Sandbox_Win_x86_32
 
 # User defined methods
 
@@ -93,7 +93,7 @@ sb.jitter.add_breakpoint(end_offset, update_binary)
 sb.run()
 
 # Rebuild PE
-# Alternative solution: miasm2.jitter.loader.pe.vm2pe(sb.jitter, out_fname,
+# Alternative solution: miasm.jitter.loader.pe.vm2pe(sb.jitter, out_fname,
 # libs=sb.libs, e_orig=sb.pe)
 new_dll = []
 
diff --git a/example/jitter/x86_32.py b/example/jitter/x86_32.py
index 2a73a2ad..c2273b69 100644
--- a/example/jitter/x86_32.py
+++ b/example/jitter/x86_32.py
@@ -1,6 +1,6 @@
 from argparse import ArgumentParser
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
 
 from pdb import pm
 
diff --git a/example/symbol_exec/depgraph.py b/example/symbol_exec/depgraph.py
index c1dbd422..c7b9017f 100644
--- a/example/symbol_exec/depgraph.py
+++ b/example/symbol_exec/depgraph.py
@@ -6,10 +6,10 @@ import json
 
 from future.utils import viewitems
 
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
-from miasm2.analysis.depgraph import DependencyGraph
-from miasm2.expression.expression import ExprMem, ExprId, ExprInt
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.analysis.depgraph import DependencyGraph
+from miasm.expression.expression import ExprMem, ExprId, ExprInt
 
 parser = ArgumentParser("Dependency grapher")
 parser.add_argument("filename", help="Binary to analyse")
diff --git a/example/symbol_exec/dse_crackme.py b/example/symbol_exec/dse_crackme.py
index 33ec3b72..90774dc3 100644
--- a/example/symbol_exec/dse_crackme.py
+++ b/example/symbol_exec/dse_crackme.py
@@ -16,10 +16,10 @@ from pdb import pm
 from tempfile import NamedTemporaryFile
 from future.utils import viewitems
 
-from miasm2.core.utils import int_to_byte
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.sandbox import Sandbox_Linux_x86_64
-from miasm2.expression.expression import *
+from miasm.core.utils import int_to_byte
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.sandbox import Sandbox_Linux_x86_64
+from miasm.expression.expression import *
 
 is_win = platform.system() == "Windows"
 
@@ -96,8 +96,8 @@ sb.jitter.init_run(sb.entry_point)
 
 
 #### This part handle the DSE ####
-from miasm2.analysis.dse import DSEPathConstraint
-from miasm2.analysis.machine import Machine
+from miasm.analysis.dse import DSEPathConstraint
+from miasm.analysis.machine import Machine
 
 
 # File "management"
diff --git a/example/symbol_exec/dse_strategies.py b/example/symbol_exec/dse_strategies.py
index 8e479d61..3f968215 100644
--- a/example/symbol_exec/dse_strategies.py
+++ b/example/symbol_exec/dse_strategies.py
@@ -22,10 +22,10 @@ from argparse import ArgumentParser
 
 from future.utils import viewitems
 
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.dse import DSEPathConstraint
-from miasm2.expression.expression import ExprMem, ExprId, ExprInt, ExprAssign
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.dse import DSEPathConstraint
+from miasm.expression.expression import ExprMem, ExprId, ExprInt, ExprAssign
 
 # Argument handling
 parser = ArgumentParser("DSE Example")
diff --git a/example/symbol_exec/single_instr.py b/example/symbol_exec/single_instr.py
index bdc65360..789252df 100644
--- a/example/symbol_exec/single_instr.py
+++ b/example/symbol_exec/single_instr.py
@@ -1,9 +1,9 @@
 from __future__ import print_function
 # Minimalist Symbol Exec example
-from miasm2.analysis.binary import Container
-from miasm2.analysis.machine import Machine
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.core.locationdb import LocationDB
+from miasm.analysis.binary import Container
+from miasm.analysis.machine import Machine
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.core.locationdb import LocationDB
 
 START_ADDR = 0
 machine = Machine("x86_32")
diff --git a/miasm2/__init__.py b/miasm/__init__.py
index b7dbe3b4..b7dbe3b4 100644
--- a/miasm2/__init__.py
+++ b/miasm/__init__.py
diff --git a/miasm2/analysis/__init__.py b/miasm/analysis/__init__.py
index 5abdd3a3..5abdd3a3 100644
--- a/miasm2/analysis/__init__.py
+++ b/miasm/analysis/__init__.py
diff --git a/miasm2/analysis/binary.py b/miasm/analysis/binary.py
index ee733d79..82f83112 100644
--- a/miasm2/analysis/binary.py
+++ b/miasm/analysis/binary.py
@@ -1,9 +1,9 @@
 import logging
 import warnings
 
-from miasm2.core.bin_stream import bin_stream_str, bin_stream_elf, bin_stream_pe
-from miasm2.jitter.csts import PAGE_READ
-from miasm2.core.locationdb import LocationDB
+from miasm.core.bin_stream import bin_stream_str, bin_stream_elf, bin_stream_pe
+from miasm.jitter.csts import PAGE_READ
+from miasm.core.locationdb import LocationDB
 
 
 log = logging.getLogger("binary")
@@ -130,7 +130,7 @@ class ContainerPE(Container):
     "Container abstraction for PE"
 
     def parse(self, data, vm=None, **kwargs):
-        from miasm2.jitter.loader.pe import vm_load_pe, guess_arch
+        from miasm.jitter.loader.pe import vm_load_pe, guess_arch
         from elfesteem import pe_init
 
         # Parse signature
@@ -176,7 +176,7 @@ class ContainerELF(Container):
         @addr and @apply_reloc are only meaningful in the context of a
         non-empty @vm
         """
-        from miasm2.jitter.loader.elf import vm_load_elf, guess_arch, \
+        from miasm.jitter.loader.elf import vm_load_elf, guess_arch, \
             fill_loc_db_with_symbols
         from elfesteem import elf_init
 
diff --git a/miasm2/analysis/cst_propag.py b/miasm/analysis/cst_propag.py
index 25d66318..d83c0458 100644
--- a/miasm2/analysis/cst_propag.py
+++ b/miasm/analysis/cst_propag.py
@@ -2,11 +2,11 @@ import logging
 
 from future.utils import viewitems
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.expression.expression import ExprMem
-from miasm2.expression.expression_helper import possible_values
-from miasm2.expression.simplifications import expr_simp
-from miasm2.ir.ir import IRBlock, AssignBlock
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.expression.expression import ExprMem
+from miasm.expression.expression_helper import possible_values
+from miasm.expression.simplifications import expr_simp
+from miasm.ir.ir import IRBlock, AssignBlock
 
 LOG_CST_PROPAG = logging.getLogger("cst_propag")
 CONSOLE_HANDLER = logging.StreamHandler()
diff --git a/miasm2/analysis/data_analysis.py b/miasm/analysis/data_analysis.py
index bd073fcb..54876487 100644
--- a/miasm2/analysis/data_analysis.py
+++ b/miasm/analysis/data_analysis.py
@@ -4,10 +4,10 @@ from future.utils import viewitems
 
 from builtins import object
 from functools import cmp_to_key
-from miasm2.expression.expression \
+from miasm.expression.expression \
     import get_expr_mem, get_list_rw, ExprId, ExprInt, \
     compare_exprs
-from miasm2.ir.symbexec import SymbolicExecutionEngine
+from miasm.ir.symbexec import SymbolicExecutionEngine
 
 
 def get_node_name(label, i, n):
diff --git a/miasm2/analysis/data_flow.py b/miasm/analysis/data_flow.py
index 3874b21b..541e6d24 100644
--- a/miasm2/analysis/data_flow.py
+++ b/miasm/analysis/data_flow.py
@@ -1,16 +1,17 @@
 """Data flow analysis based on miasm intermediate representation"""
 from builtins import range
 from collections import namedtuple
+
 from future.utils import viewitems, viewvalues
-from miasm2.core.utils import encode_hex
-from miasm2.core.graph import DiGraph
-from miasm2.ir.ir import AssignBlock, IRBlock
-from miasm2.expression.expression import ExprLoc, ExprMem, ExprId, ExprInt,\
+from miasm.core.utils import encode_hex
+from miasm.core.graph import DiGraph
+from miasm.ir.ir import AssignBlock, IRBlock
+from miasm.expression.expression import ExprLoc, ExprMem, ExprId, ExprInt,\
     ExprAssign, ExprOp
-from miasm2.expression.simplifications import expr_simp
-from miasm2.core.interval import interval
-from miasm2.expression.expression_helper import possible_values
-from miasm2.analysis.ssa import get_phi_sources_parent_block, \
+from miasm.expression.simplifications import expr_simp
+from miasm.core.interval import interval
+from miasm.expression.expression_helper import possible_values
+from miasm.analysis.ssa import get_phi_sources_parent_block, \
     irblock_has_phi
 
 
diff --git a/miasm2/analysis/debugging.py b/miasm/analysis/debugging.py
index 824b62ce..3cbbf482 100644
--- a/miasm2/analysis/debugging.py
+++ b/miasm/analysis/debugging.py
@@ -4,10 +4,10 @@ from builtins import range
 import cmd
 from future.utils import viewitems
 
-from miasm2.core.utils import hexdump
-from miasm2.core.interval import interval
-import miasm2.jitter.csts as csts
-from miasm2.jitter.jitload import ExceptionHandle
+from miasm.core.utils import hexdump
+from miasm.core.interval import interval
+import miasm.jitter.csts as csts
+from miasm.jitter.jitload import ExceptionHandle
 
 
 class DebugBreakpoint(object):
diff --git a/miasm2/analysis/depgraph.py b/miasm/analysis/depgraph.py
index 4bfae67f..219a32ee 100644
--- a/miasm2/analysis/depgraph.py
+++ b/miasm/analysis/depgraph.py
@@ -4,14 +4,14 @@ from functools import total_ordering
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprInt, ExprLoc, ExprAssign
-from miasm2.core.graph import DiGraph
-from miasm2.core.locationdb import LocationDB
-from miasm2.expression.simplifications import expr_simp_explicit
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.ir.translators import Translator
-from miasm2.expression.expression_helper import possible_values
+from miasm.expression.expression import ExprInt, ExprLoc, ExprAssign
+from miasm.core.graph import DiGraph
+from miasm.core.locationdb import LocationDB
+from miasm.expression.simplifications import expr_simp_explicit
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.ir.translators import Translator
+from miasm.expression.expression_helper import possible_values
 
 try:
     import z3
diff --git a/miasm2/analysis/disasm_cb.py b/miasm/analysis/disasm_cb.py
index 36e120b6..f3480598 100644
--- a/miasm2/analysis/disasm_cb.py
+++ b/miasm/analysis/disasm_cb.py
@@ -4,21 +4,21 @@ from __future__ import print_function
 
 from future.utils import viewvalues
 
-from miasm2.expression.expression import ExprInt, ExprId, ExprMem, match_expr
-from miasm2.expression.simplifications import expr_simp
-from miasm2.core.asmblock import AsmConstraintNext, AsmConstraintTo
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import upck32
+from miasm.expression.expression import ExprInt, ExprId, ExprMem, match_expr
+from miasm.expression.simplifications import expr_simp
+from miasm.core.asmblock import AsmConstraintNext, AsmConstraintTo
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import upck32
 
 
 def get_ira(mnemo, attrib):
     arch = mnemo.name, attrib
     if arch == ("arm", "arm"):
-        from miasm2.arch.arm.ira import ir_a_arm_base as ira
+        from miasm.arch.arm.ira import ir_a_arm_base as ira
     elif arch == ("x86", 32):
-        from miasm2.arch.x86.ira import ir_a_x86_32 as ira
+        from miasm.arch.x86.ira import ir_a_x86_32 as ira
     elif arch == ("x86", 64):
-        from miasm2.arch.x86.ira import ir_a_x86_64 as ira
+        from miasm.arch.x86.ira import ir_a_x86_64 as ira
     else:
         raise ValueError('unknown architecture: %s' % mnemo.name)
     return ira
diff --git a/miasm2/analysis/dse.py b/miasm/analysis/dse.py
index fee85984..3f31f344 100644
--- a/miasm2/analysis/dse.py
+++ b/miasm/analysis/dse.py
@@ -57,16 +57,16 @@ except ImportError:
 
 from future.utils import viewitems
 
-from miasm2.core.utils import encode_hex, force_bytes
-from miasm2.expression.expression import ExprMem, ExprInt, ExprCompose, \
+from miasm.core.utils import encode_hex, force_bytes
+from miasm.expression.expression import ExprMem, ExprInt, ExprCompose, \
     ExprAssign, ExprId, ExprLoc, LocKey
-from miasm2.core.bin_stream import bin_stream_vm
-from miasm2.jitter.emulatedsymbexec import EmulatedSymbExec
-from miasm2.expression.expression_helper import possible_values
-from miasm2.ir.translators import Translator
-from miasm2.analysis.expression_range import expr_range
-from miasm2.analysis.modularintervals import ModularIntervals
-from miasm2.core.locationdb import LocationDB
+from miasm.core.bin_stream import bin_stream_vm
+from miasm.jitter.emulatedsymbexec import EmulatedSymbExec
+from miasm.expression.expression_helper import possible_values
+from miasm.ir.translators import Translator
+from miasm.analysis.expression_range import expr_range
+from miasm.analysis.modularintervals import ModularIntervals
+from miasm.core.locationdb import LocationDB
 
 DriftInfo = namedtuple("DriftInfo", ["symbol", "computed", "expected"])
 
diff --git a/miasm2/analysis/expression_range.py b/miasm/analysis/expression_range.py
index 8f498549..5a31873a 100644
--- a/miasm2/analysis/expression_range.py
+++ b/miasm/analysis/expression_range.py
@@ -3,7 +3,7 @@
 from future.builtins import zip
 from functools import reduce
 
-from miasm2.analysis.modularintervals import ModularIntervals
+from miasm.analysis.modularintervals import ModularIntervals
 
 _op_range_handler = {
     "+": lambda x, y: x + y,
diff --git a/miasm2/analysis/gdbserver.py b/miasm/analysis/gdbserver.py
index 61ee8955..ac58cdad 100644
--- a/miasm2/analysis/gdbserver.py
+++ b/miasm/analysis/gdbserver.py
@@ -3,15 +3,15 @@
 from __future__ import print_function
 from future.builtins import map, range
 
-from miasm2.core.utils import decode_hex, encode_hex, int_to_byte
+from miasm.core.utils import decode_hex, encode_hex, int_to_byte
 
 import socket
 import struct
 import time
 import logging
 from io import BytesIO
-import miasm2.analysis.debugging as debugging
-from miasm2.jitter.jitload import ExceptionHandle
+import miasm.analysis.debugging as debugging
+from miasm.jitter.jitload import ExceptionHandle
 
 
 class GdbServer(object):
diff --git a/miasm2/analysis/machine.py b/miasm/analysis/machine.py
index f12b7e57..ba076d8c 100644
--- a/miasm2/analysis/machine.py
+++ b/miasm/analysis/machine.py
@@ -30,176 +30,176 @@ class Machine(object):
 
         # Import on runtime for performance issue
         if machine_name == "arml":
-            from miasm2.arch.arm.disasm import dis_arml as dis_engine
-            from miasm2.arch.arm import arch
+            from miasm.arch.arm.disasm import dis_arml as dis_engine
+            from miasm.arch.arm import arch
             try:
-                from miasm2.arch.arm import jit
+                from miasm.arch.arm import jit
                 jitter = jit.jitter_arml
             except ImportError:
                 pass
             mn = arch.mn_arm
-            from miasm2.arch.arm.ira import ir_a_arml as ira
-            from miasm2.arch.arm.sem import ir_arml as ir
+            from miasm.arch.arm.ira import ir_a_arml as ira
+            from miasm.arch.arm.sem import ir_arml as ir
         elif machine_name == "armb":
-            from miasm2.arch.arm.disasm import dis_armb as dis_engine
-            from miasm2.arch.arm import arch
+            from miasm.arch.arm.disasm import dis_armb as dis_engine
+            from miasm.arch.arm import arch
             try:
-                from miasm2.arch.arm import jit
+                from miasm.arch.arm import jit
                 jitter = jit.jitter_armb
             except ImportError:
                 pass
             mn = arch.mn_arm
-            from miasm2.arch.arm.ira import ir_a_armb as ira
-            from miasm2.arch.arm.sem import ir_armb as ir
+            from miasm.arch.arm.ira import ir_a_armb as ira
+            from miasm.arch.arm.sem import ir_armb as ir
         elif machine_name == "aarch64l":
-            from miasm2.arch.aarch64.disasm import dis_aarch64l as dis_engine
-            from miasm2.arch.aarch64 import arch
+            from miasm.arch.aarch64.disasm import dis_aarch64l as dis_engine
+            from miasm.arch.aarch64 import arch
             try:
-                from miasm2.arch.aarch64 import jit
+                from miasm.arch.aarch64 import jit
                 jitter = jit.jitter_aarch64l
             except ImportError:
                 pass
             mn = arch.mn_aarch64
-            from miasm2.arch.aarch64.ira import ir_a_aarch64l as ira
-            from miasm2.arch.aarch64.sem import ir_aarch64l as ir
+            from miasm.arch.aarch64.ira import ir_a_aarch64l as ira
+            from miasm.arch.aarch64.sem import ir_aarch64l as ir
         elif machine_name == "aarch64b":
-            from miasm2.arch.aarch64.disasm import dis_aarch64b as dis_engine
-            from miasm2.arch.aarch64 import arch
+            from miasm.arch.aarch64.disasm import dis_aarch64b as dis_engine
+            from miasm.arch.aarch64 import arch
             try:
-                from miasm2.arch.aarch64 import jit
+                from miasm.arch.aarch64 import jit
                 jitter = jit.jitter_aarch64b
             except ImportError:
                 pass
             mn = arch.mn_aarch64
-            from miasm2.arch.aarch64.ira import ir_a_aarch64b as ira
-            from miasm2.arch.aarch64.sem import ir_aarch64b as ir
+            from miasm.arch.aarch64.ira import ir_a_aarch64b as ira
+            from miasm.arch.aarch64.sem import ir_aarch64b as ir
         elif machine_name == "armtl":
-            from miasm2.arch.arm.disasm import dis_armtl as dis_engine
-            from miasm2.arch.arm import arch
+            from miasm.arch.arm.disasm import dis_armtl as dis_engine
+            from miasm.arch.arm import arch
             mn = arch.mn_armt
-            from miasm2.arch.arm.ira import ir_a_armtl as ira
-            from miasm2.arch.arm.sem import ir_armtl as ir
+            from miasm.arch.arm.ira import ir_a_armtl as ira
+            from miasm.arch.arm.sem import ir_armtl as ir
             try:
-                from miasm2.arch.arm import jit
+                from miasm.arch.arm import jit
                 jitter = jit.jitter_armtl
             except ImportError:
                 pass
         elif machine_name == "armtb":
-            from miasm2.arch.arm.disasm import dis_armtb as dis_engine
-            from miasm2.arch.arm import arch
+            from miasm.arch.arm.disasm import dis_armtb as dis_engine
+            from miasm.arch.arm import arch
             mn = arch.mn_armt
-            from miasm2.arch.arm.ira import ir_a_armtb as ira
-            from miasm2.arch.arm.sem import ir_armtb as ir
+            from miasm.arch.arm.ira import ir_a_armtb as ira
+            from miasm.arch.arm.sem import ir_armtb as ir
         elif machine_name == "sh4":
-            from miasm2.arch.sh4 import arch
+            from miasm.arch.sh4 import arch
             mn = arch.mn_sh4
         elif machine_name == "x86_16":
-            from miasm2.arch.x86.disasm import dis_x86_16 as dis_engine
-            from miasm2.arch.x86 import arch
+            from miasm.arch.x86.disasm import dis_x86_16 as dis_engine
+            from miasm.arch.x86 import arch
             try:
-                from miasm2.arch.x86 import jit
+                from miasm.arch.x86 import jit
                 jitter = jit.jitter_x86_16
             except ImportError:
                 pass
             mn = arch.mn_x86
-            from miasm2.arch.x86.ira import ir_a_x86_16 as ira
-            from miasm2.arch.x86.sem import ir_x86_16 as ir
+            from miasm.arch.x86.ira import ir_a_x86_16 as ira
+            from miasm.arch.x86.sem import ir_x86_16 as ir
         elif machine_name == "x86_32":
-            from miasm2.arch.x86.disasm import dis_x86_32 as dis_engine
-            from miasm2.arch.x86 import arch
+            from miasm.arch.x86.disasm import dis_x86_32 as dis_engine
+            from miasm.arch.x86 import arch
             try:
-                from miasm2.arch.x86 import jit
+                from miasm.arch.x86 import jit
                 jitter = jit.jitter_x86_32
             except ImportError:
                 pass
             mn = arch.mn_x86
-            from miasm2.arch.x86.ira import ir_a_x86_32 as ira
-            from miasm2.arch.x86.sem import ir_x86_32 as ir
+            from miasm.arch.x86.ira import ir_a_x86_32 as ira
+            from miasm.arch.x86.sem import ir_x86_32 as ir
             try:
-                from miasm2.analysis.gdbserver import GdbServer_x86_32 as gdbserver
+                from miasm.analysis.gdbserver import GdbServer_x86_32 as gdbserver
             except ImportError:
                 pass
         elif machine_name == "x86_64":
-            from miasm2.arch.x86.disasm import dis_x86_64 as dis_engine
-            from miasm2.arch.x86 import arch
+            from miasm.arch.x86.disasm import dis_x86_64 as dis_engine
+            from miasm.arch.x86 import arch
             try:
-                from miasm2.arch.x86 import jit
+                from miasm.arch.x86 import jit
                 jitter = jit.jitter_x86_64
             except ImportError:
                 pass
             mn = arch.mn_x86
-            from miasm2.arch.x86.ira import ir_a_x86_64 as ira
-            from miasm2.arch.x86.sem import ir_x86_64 as ir
+            from miasm.arch.x86.ira import ir_a_x86_64 as ira
+            from miasm.arch.x86.sem import ir_x86_64 as ir
         elif machine_name == "msp430":
-            from miasm2.arch.msp430.disasm import dis_msp430 as dis_engine
-            from miasm2.arch.msp430 import arch
+            from miasm.arch.msp430.disasm import dis_msp430 as dis_engine
+            from miasm.arch.msp430 import arch
             try:
-                from miasm2.arch.msp430 import jit
+                from miasm.arch.msp430 import jit
                 jitter = jit.jitter_msp430
             except ImportError:
                 pass
             mn = arch.mn_msp430
-            from miasm2.arch.msp430.ira import ir_a_msp430 as ira
-            from miasm2.arch.msp430.sem import ir_msp430 as ir
+            from miasm.arch.msp430.ira import ir_a_msp430 as ira
+            from miasm.arch.msp430.sem import ir_msp430 as ir
             try:
-                from miasm2.analysis.gdbserver import GdbServer_msp430 as gdbserver
+                from miasm.analysis.gdbserver import GdbServer_msp430 as gdbserver
             except ImportError:
                 pass
         elif machine_name == "mips32b":
-            from miasm2.arch.mips32.disasm import dis_mips32b as dis_engine
-            from miasm2.arch.mips32 import arch
+            from miasm.arch.mips32.disasm import dis_mips32b as dis_engine
+            from miasm.arch.mips32 import arch
             try:
-                from miasm2.arch.mips32 import jit
+                from miasm.arch.mips32 import jit
                 jitter = jit.jitter_mips32b
             except ImportError:
                 pass
             mn = arch.mn_mips32
-            from miasm2.arch.mips32.ira import ir_a_mips32b as ira
-            from miasm2.arch.mips32.sem import ir_mips32b as ir
+            from miasm.arch.mips32.ira import ir_a_mips32b as ira
+            from miasm.arch.mips32.sem import ir_mips32b as ir
         elif machine_name == "mips32l":
-            from miasm2.arch.mips32.disasm import dis_mips32l as dis_engine
-            from miasm2.arch.mips32 import arch
+            from miasm.arch.mips32.disasm import dis_mips32l as dis_engine
+            from miasm.arch.mips32 import arch
             try:
-                from miasm2.arch.mips32 import jit
+                from miasm.arch.mips32 import jit
                 jitter = jit.jitter_mips32l
             except ImportError:
                 pass
             mn = arch.mn_mips32
-            from miasm2.arch.mips32.ira import ir_a_mips32l as ira
-            from miasm2.arch.mips32.sem import ir_mips32l as ir
+            from miasm.arch.mips32.ira import ir_a_mips32l as ira
+            from miasm.arch.mips32.sem import ir_mips32l as ir
         elif machine_name == "ppc32b":
-            from miasm2.arch.ppc.disasm import dis_ppc32b as dis_engine
-            from miasm2.arch.ppc import arch
+            from miasm.arch.ppc.disasm import dis_ppc32b as dis_engine
+            from miasm.arch.ppc import arch
             try:
-                from miasm2.arch.ppc import jit
+                from miasm.arch.ppc import jit
                 jitter = jit.jitter_ppc32b
             except ImportError:
                 pass
             mn = arch.mn_ppc
-            from miasm2.arch.ppc.ira import ir_a_ppc32b as ira
-            from miasm2.arch.ppc.sem import ir_ppc32b as ir
+            from miasm.arch.ppc.ira import ir_a_ppc32b as ira
+            from miasm.arch.ppc.sem import ir_ppc32b as ir
         elif machine_name == "mepb":
-            from miasm2.arch.mep.disasm import dis_mepb as dis_engine
-            from miasm2.arch.mep import arch
+            from miasm.arch.mep.disasm import dis_mepb as dis_engine
+            from miasm.arch.mep import arch
             try:
-                from miasm2.arch.mep import jit
+                from miasm.arch.mep import jit
                 jitter = jit.jitter_mepb
             except ImportError:
                 pass
             mn = arch.mn_mep
-            from miasm2.arch.mep.ira import ir_a_mepb as ira
-            from miasm2.arch.mep.sem import ir_mepb as ir
+            from miasm.arch.mep.ira import ir_a_mepb as ira
+            from miasm.arch.mep.sem import ir_mepb as ir
         elif machine_name == "mepl":
-            from miasm2.arch.mep.disasm import dis_mepl as dis_engine
-            from miasm2.arch.mep import arch
+            from miasm.arch.mep.disasm import dis_mepl as dis_engine
+            from miasm.arch.mep import arch
             try:
-                from miasm2.arch.mep import jit
+                from miasm.arch.mep import jit
                 jitter = jit.jitter_mepl
             except ImportError:
                 pass
             mn = arch.mn_mep
-            from miasm2.arch.mep.ira import ir_a_mepl as ira
-            from miasm2.arch.mep.sem import ir_mepl as ir
+            from miasm.arch.mep.ira import ir_a_mepl as ira
+            from miasm.arch.mep.sem import ir_mepl as ir
         else:
             raise ValueError('Unknown machine: %s' % machine_name)
 
diff --git a/miasm2/analysis/modularintervals.py b/miasm/analysis/modularintervals.py
index 2195598b..0df01911 100644
--- a/miasm2/analysis/modularintervals.py
+++ b/miasm/analysis/modularintervals.py
@@ -4,7 +4,7 @@ from future.builtins import range
 from builtins import int as int_types
 from itertools import product
 
-from miasm2.core.interval import interval
+from miasm.core.interval import interval
 
 class ModularIntervals(object):
     """Intervals with a maximum size, supporting modular arithmetic"""
diff --git a/miasm2/analysis/outofssa.py b/miasm/analysis/outofssa.py
index 41c665af..497956be 100644
--- a/miasm2/analysis/outofssa.py
+++ b/miasm/analysis/outofssa.py
@@ -1,8 +1,8 @@
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import ExprId
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.analysis.ssa import get_phi_sources_parent_block, \
+from miasm.expression.expression import ExprId
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.analysis.ssa import get_phi_sources_parent_block, \
     irblock_has_phi
 
 
diff --git a/miasm2/analysis/sandbox.py b/miasm/analysis/sandbox.py
index d3e8fce1..e5595071 100644
--- a/miasm2/analysis/sandbox.py
+++ b/miasm/analysis/sandbox.py
@@ -7,11 +7,11 @@ from argparse import ArgumentParser
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.core.utils import force_bytes
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis import debugging
-from miasm2.jitter.jitload import log_func
+from miasm.core.utils import force_bytes
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis import debugging
+from miasm.jitter.jitload import log_func
 
 
 
@@ -188,9 +188,9 @@ class OS_Win(OS):
     modules_path = "win_dll"
 
     def __init__(self, custom_methods, *args, **kwargs):
-        from miasm2.jitter.loader.pe import vm_load_pe, vm_load_pe_libs,\
+        from miasm.jitter.loader.pe import vm_load_pe, vm_load_pe_libs,\
             preload_pe, libimp_pe, vm_load_pe_and_dependencies
-        from miasm2.os_dep import win_api_x86_32, win_api_x86_32_seh
+        from miasm.os_dep import win_api_x86_32, win_api_x86_32_seh
         methods = dict((name.encode(),func) for name, func in viewitems(win_api_x86_32.__dict__))
         methods.update(custom_methods)
 
@@ -280,8 +280,8 @@ class OS_Linux(OS):
     PROGRAM_PATH = "./program"
 
     def __init__(self, custom_methods, *args, **kwargs):
-        from miasm2.jitter.loader.elf import vm_load_elf, preload_elf, libimp_elf
-        from miasm2.os_dep import linux_stdlib
+        from miasm.jitter.loader.elf import vm_load_elf, preload_elf, libimp_elf
+        from miasm.os_dep import linux_stdlib
         methods = linux_stdlib.__dict__
         methods.update(custom_methods)
 
@@ -330,8 +330,8 @@ class OS_Linux_str(OS):
     PROGRAM_PATH = "./program"
 
     def __init__(self, custom_methods, *args, **kwargs):
-        from miasm2.jitter.loader.elf import libimp_elf
-        from miasm2.os_dep import linux_stdlib
+        from miasm.jitter.loader.elf import libimp_elf
+        from miasm.os_dep import linux_stdlib
         methods = linux_stdlib.__dict__
         methods.update(custom_methods)
 
diff --git a/miasm2/analysis/simplifier.py b/miasm/analysis/simplifier.py
index 10d5e092..870071c8 100644
--- a/miasm2/analysis/simplifier.py
+++ b/miasm/analysis/simplifier.py
@@ -4,11 +4,11 @@ Apply simplification passes to an IR cfg
 
 import logging
 from functools import wraps
-from miasm2.analysis.ssa import SSADiGraph
-from miasm2.analysis.outofssa import UnSSADiGraph
-from miasm2.analysis.data_flow import DiGraphLivenessSSA
-from miasm2.expression.simplifications import expr_simp
-from miasm2.analysis.data_flow import dead_simp, \
+from miasm.analysis.ssa import SSADiGraph
+from miasm.analysis.outofssa import UnSSADiGraph
+from miasm.analysis.data_flow import DiGraphLivenessSSA
+from miasm.expression.simplifications import expr_simp
+from miasm.analysis.data_flow import dead_simp, \
     merge_blocks, remove_empty_assignblks, \
     PropagateExprIntThroughExprId, PropagateThroughExprId, \
     PropagateThroughExprMem, del_unused_edges
diff --git a/miasm2/analysis/ssa.py b/miasm/analysis/ssa.py
index 54d17dc1..0aa24286 100644
--- a/miasm2/analysis/ssa.py
+++ b/miasm/analysis/ssa.py
@@ -1,9 +1,9 @@
 from collections import deque
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import ExprId, ExprAssign, ExprOp, \
+from miasm.expression.expression import ExprId, ExprAssign, ExprOp, \
     ExprLoc, get_expr_ids
-from miasm2.ir.ir import AssignBlock, IRBlock
+from miasm.ir.ir import AssignBlock, IRBlock
 
 
 def sanitize_graph_head(ircfg, head):
diff --git a/miasm2/arch/__init__.py b/miasm/arch/__init__.py
index 78e2dd3c..78e2dd3c 100644
--- a/miasm2/arch/__init__.py
+++ b/miasm/arch/__init__.py
diff --git a/miasm2/arch/aarch64/__init__.py b/miasm/arch/aarch64/__init__.py
index bbad893b..bbad893b 100644
--- a/miasm2/arch/aarch64/__init__.py
+++ b/miasm/arch/aarch64/__init__.py
diff --git a/miasm2/arch/aarch64/arch.py b/miasm/arch/aarch64/arch.py
index 3a4f6446..d12fbe72 100644
--- a/miasm2/arch/aarch64/arch.py
+++ b/miasm/arch/aarch64/arch.py
@@ -5,15 +5,15 @@ from future.utils import viewitems, viewvalues
 
 import logging
 from pyparsing import *
-from miasm2.expression import expression as m2_expr
-from miasm2.core.cpu import *
+from miasm.expression import expression as m2_expr
+from miasm.core.cpu import *
 from collections import defaultdict
-from miasm2.core.bin_stream import bin_stream
-from miasm2.arch.aarch64 import regs as regs_module
-from miasm2.arch.aarch64.regs import *
-from miasm2.core.cpu import log as log_cpu
-from miasm2.expression.modint import uint32, uint64, mod_size2int
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.bin_stream import bin_stream
+from miasm.arch.aarch64 import regs as regs_module
+from miasm.arch.aarch64.regs import *
+from miasm.core.cpu import log as log_cpu
+from miasm.expression.modint import uint32, uint64, mod_size2int
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 log = logging.getLogger("aarch64dis")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/arch/aarch64/disasm.py b/miasm/arch/aarch64/disasm.py
index 17eec414..c4ad9181 100644
--- a/miasm2/arch/aarch64/disasm.py
+++ b/miasm/arch/aarch64/disasm.py
@@ -1,5 +1,5 @@
-from miasm2.core.asmblock import disasmEngine
-from miasm2.arch.aarch64.arch import mn_aarch64
+from miasm.core.asmblock import disasmEngine
+from miasm.arch.aarch64.arch import mn_aarch64
 
 cb_aarch64_funcs = []
 
diff --git a/miasm2/arch/aarch64/ira.py b/miasm/arch/aarch64/ira.py
index a895b549..e20a0943 100644
--- a/miasm2/arch/aarch64/ira.py
+++ b/miasm/arch/aarch64/ira.py
@@ -1,7 +1,7 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.ir.analysis import ira
-from miasm2.arch.aarch64.sem import ir_aarch64l, ir_aarch64b
+from miasm.ir.analysis import ira
+from miasm.arch.aarch64.sem import ir_aarch64l, ir_aarch64b
 
 
 class ir_a_aarch64l_base(ir_aarch64l, ira):
diff --git a/miasm2/arch/aarch64/jit.py b/miasm/arch/aarch64/jit.py
index 57b896d3..0754f5be 100644
--- a/miasm2/arch/aarch64/jit.py
+++ b/miasm/arch/aarch64/jit.py
@@ -1,10 +1,10 @@
 from builtins import range
 import logging
 
-from miasm2.jitter.jitload import Jitter, named_arguments
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import pck64, upck64
-from miasm2.arch.aarch64.sem import ir_aarch64b, ir_aarch64l
+from miasm.jitter.jitload import Jitter, named_arguments
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import pck64, upck64
+from miasm.arch.aarch64.sem import ir_aarch64b, ir_aarch64l
 
 log = logging.getLogger('jit_aarch64')
 hnd = logging.StreamHandler()
diff --git a/miasm2/arch/aarch64/regs.py b/miasm/arch/aarch64/regs.py
index 7ddcc0b8..2732323f 100644
--- a/miasm2/arch/aarch64/regs.py
+++ b/miasm/arch/aarch64/regs.py
@@ -1,8 +1,8 @@
 #-*- coding:utf-8 -*-
 
 from builtins import range
-from miasm2.expression.expression import ExprId
-from miasm2.core.cpu import gen_reg, gen_regs
+from miasm.expression.expression import ExprId
+from miasm.core.cpu import gen_reg, gen_regs
 
 exception_flags = ExprId('exception_flags', 32)
 interrupt_num = ExprId('interrupt_num', 32)
diff --git a/miasm2/arch/aarch64/sem.py b/miasm/arch/aarch64/sem.py
index a840f6b6..ce77aa2c 100644
--- a/miasm2/arch/aarch64/sem.py
+++ b/miasm/arch/aarch64/sem.py
@@ -1,13 +1,13 @@
 from builtins import range
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprLoc, ExprMem, \
+from miasm.expression.expression import ExprId, ExprInt, ExprLoc, ExprMem, \
     ExprCond, ExprCompose, ExprOp, ExprAssign
-from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
-from miasm2.arch.aarch64.arch import mn_aarch64, conds_expr, replace_regs
-from miasm2.arch.aarch64.regs import *
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX
+from miasm.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
+from miasm.arch.aarch64.arch import mn_aarch64, conds_expr, replace_regs
+from miasm.arch.aarch64.regs import *
+from miasm.core.sembuilder import SemBuilder
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX
 
 
 # CPSR: N Z C V
diff --git a/miasm2/arch/arm/__init__.py b/miasm/arch/arm/__init__.py
index bbad893b..bbad893b 100644
--- a/miasm2/arch/arm/__init__.py
+++ b/miasm/arch/arm/__init__.py
diff --git a/miasm2/arch/arm/arch.py b/miasm/arch/arm/arch.py
index 3cafad59..7668cf0a 100644
--- a/miasm2/arch/arm/arch.py
+++ b/miasm/arch/arm/arch.py
@@ -5,13 +5,13 @@ from future.utils import viewitems
 
 import logging
 from pyparsing import *
-from miasm2.expression.expression import *
-from miasm2.core.cpu import *
+from miasm.expression.expression import *
+from miasm.core.cpu import *
 from collections import defaultdict
-from miasm2.core.bin_stream import bin_stream
-import miasm2.arch.arm.regs as regs_module
-from miasm2.arch.arm.regs import *
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.bin_stream import bin_stream
+import miasm.arch.arm.regs as regs_module
+from miasm.arch.arm.regs import *
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 # A1 encoding
 
diff --git a/miasm2/arch/arm/disasm.py b/miasm/arch/arm/disasm.py
index 2a443cc2..4c92bf6a 100644
--- a/miasm2/arch/arm/disasm.py
+++ b/miasm/arch/arm/disasm.py
@@ -1,7 +1,7 @@
 from future.utils import viewvalues
 
-from miasm2.core.asmblock import AsmConstraint, disasmEngine
-from miasm2.arch.arm.arch import mn_arm, mn_armt
+from miasm.core.asmblock import AsmConstraint, disasmEngine
+from miasm.arch.arm.arch import mn_arm, mn_armt
 
 
 def cb_arm_fix_call(mn, cur_bloc, loc_db, offsets_to_dis, *args, **kwargs):
diff --git a/miasm2/arch/arm/ira.py b/miasm/arch/arm/ira.py
index 2214c626..178e8abc 100644
--- a/miasm2/arch/arm/ira.py
+++ b/miasm/arch/arm/ira.py
@@ -1,10 +1,10 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.ir.analysis import ira
-from miasm2.ir.ir import IRBlock
-from miasm2.arch.arm.sem import ir_arml, ir_armtl, ir_armb, ir_armtb, tab_cond
-from miasm2.expression.expression import ExprAssign, ExprOp, ExprLoc, ExprCond
-from miasm2.ir.ir import AssignBlock
+from miasm.ir.analysis import ira
+from miasm.ir.ir import IRBlock
+from miasm.arch.arm.sem import ir_arml, ir_armtl, ir_armb, ir_armtb, tab_cond
+from miasm.expression.expression import ExprAssign, ExprOp, ExprLoc, ExprCond
+from miasm.ir.ir import AssignBlock
 
 class ir_a_arml_base(ir_arml, ira):
     def __init__(self, loc_db=None):
diff --git a/miasm2/arch/arm/jit.py b/miasm/arch/arm/jit.py
index 128baffb..6252862a 100644
--- a/miasm2/arch/arm/jit.py
+++ b/miasm/arch/arm/jit.py
@@ -1,15 +1,15 @@
 from builtins import range
 import logging
 
-from miasm2.jitter.jitload import Jitter, named_arguments
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import pck32, upck32
-from miasm2.arch.arm.sem import ir_armb, ir_arml, ir_armtl, ir_armtb, cond_dct_inv, tab_cond
-from miasm2.jitter.codegen import CGen
-from miasm2.expression.expression import ExprId, ExprAssign, ExprCond
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.ir.translators.C import TranslatorC
-from miasm2.expression.simplifications import expr_simp_high_to_explicit
+from miasm.jitter.jitload import Jitter, named_arguments
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import pck32, upck32
+from miasm.arch.arm.sem import ir_armb, ir_arml, ir_armtl, ir_armtb, cond_dct_inv, tab_cond
+from miasm.jitter.codegen import CGen
+from miasm.expression.expression import ExprId, ExprAssign, ExprCond
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.ir.translators.C import TranslatorC
+from miasm.expression.simplifications import expr_simp_high_to_explicit
 
 log = logging.getLogger('jit_arm')
 hnd = logging.StreamHandler()
diff --git a/miasm2/arch/arm/regs.py b/miasm/arch/arm/regs.py
index f39f2161..63caada3 100644
--- a/miasm2/arch/arm/regs.py
+++ b/miasm/arch/arm/regs.py
@@ -1,7 +1,7 @@
 #-*- coding:utf-8 -*-
 
 from builtins import range
-from miasm2.expression.expression import *
+from miasm.expression.expression import *
 
 
 # GP
diff --git a/miasm2/arch/arm/sem.py b/miasm/arch/arm/sem.py
index 6622a42a..bbffc05b 100644
--- a/miasm2/arch/arm/sem.py
+++ b/miasm/arch/arm/sem.py
@@ -1,12 +1,12 @@
 from builtins import range
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import *
-from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
-from miasm2.arch.arm.arch import mn_arm, mn_armt
-from miasm2.arch.arm.regs import *
+from miasm.expression.expression import *
+from miasm.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
+from miasm.arch.arm.arch import mn_arm, mn_armt
+from miasm.arch.arm.regs import *
 
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX
 
 # liris.cnrs.fr/~mmrissa/lib/exe/fetch.php?media=armv7-a-r-manual.pdf
 EXCEPT_SOFT_BP = (1 << 1)
diff --git a/miasm2/arch/mep/__init__.py b/miasm/arch/mep/__init__.py
index e69de29b..e69de29b 100644
--- a/miasm2/arch/mep/__init__.py
+++ b/miasm/arch/mep/__init__.py
diff --git a/miasm2/arch/mep/arch.py b/miasm/arch/mep/arch.py
index 2266b596..171f5fab 100644
--- a/miasm2/arch/mep/arch.py
+++ b/miasm/arch/mep/arch.py
@@ -2,14 +2,14 @@
 # Guillaume Valadon <guillaume@valadon.net>
 
 from builtins import range
-from miasm2.core.cpu import *
-from miasm2.core.utils import Disasm_Exception
-from miasm2.expression.expression import Expr, ExprId, ExprInt, ExprLoc, \
+from miasm.core.cpu import *
+from miasm.core.utils import Disasm_Exception
+from miasm.expression.expression import Expr, ExprId, ExprInt, ExprLoc, \
     ExprMem, ExprOp
-from miasm2.core.asm_ast import AstId, AstMem
+from miasm.core.asm_ast import AstId, AstMem
 
-from miasm2.arch.mep.regs import *
-import miasm2.arch.mep.regs as mep_regs_module  # will be used to set mn_mep.regs
+from miasm.arch.mep.regs import *
+import miasm.arch.mep.regs as mep_regs_module  # will be used to set mn_mep.regs
 
 
 # Note: pyparsing is used to alter the way special operands are parsed
@@ -59,7 +59,7 @@ class instruction_mep(instruction):
 
     # Default delay slot
     # Note:
-    #   - mandatory for the miasm2 Machine
+    #   - mandatory for the miasm Machine
     delayslot = 0
 
     @staticmethod
@@ -73,7 +73,7 @@ class instruction_mep(instruction):
             - it is used to mimic objdump output
 
         Args:
-            expr: argument as a miasm2 expression
+            expr: argument as a miasm expression
             pos: position index in the arguments list
         """
 
@@ -104,7 +104,7 @@ class instruction_mep(instruction):
             - it is not mandatory as the instruction class already implement
               it. It used to get rid of the padding between the opcode and the
               arguments.
-            - most of this code is copied from miasm2/core/cpu.py
+            - most of this code is copied from miasm/core/cpu.py
         """
 
         o = "%s" % self.name
@@ -255,7 +255,7 @@ class instruction_mep(instruction):
         """Fix/correct the instruction immediate according to the current offset
 
            Note: - it is used at assembly
-                 - code inspired by miasm2/arch/mips32/arch.py"""
+                 - code inspired by miasm/arch/mips32/arch.py"""
 
         if self.name == "JMP" and isinstance(self.args[0], ExprInt):
             # 'JMP IMMEDIATE' does not need to be fixed
@@ -327,7 +327,7 @@ class mn_mep(cls_mn):
 
     # Default delay slot
     # Note:
-    #   - mandatory for the miasm2 Machine
+    #   - mandatory for the miasm Machine
     delayslot = 0
 
     # Architecture name
@@ -423,7 +423,7 @@ class mn_mep(cls_mn):
     def getbits(cls, bitstream, attrib, start, n):
         """Return an integer of n bits at the 'start' offset
 
-           Note: code from miasm2/arch/mips32/arch.py
+           Note: code from miasm/arch/mips32/arch.py
         """
 
         # Return zero if zero bits are requested
@@ -471,7 +471,7 @@ class mn_mep(cls_mn):
     def value(self, mode):
         """Adjust the assembled instruction based on the endianness
 
-           Note: code inspired by miasm2/arch/mips32/arch.py
+           Note: code inspired by miasm/arch/mips32/arch.py
         """
 
         # Get the candidated
@@ -546,7 +546,7 @@ class mep_arg(m_arg):
     def asm_ast_to_expr(self, arg, loc_db):
         """Convert AST to expressions
 
-           Note: - code inspired by miasm2/arch/mips32/arch.py"""
+           Note: - code inspired by miasm/arch/mips32/arch.py"""
 
         if isinstance(arg, AstId):
             if isinstance(arg.name, ExprId):
diff --git a/miasm2/arch/mep/disasm.py b/miasm/arch/mep/disasm.py
index 2ad73036..0260c01d 100644
--- a/miasm2/arch/mep/disasm.py
+++ b/miasm/arch/mep/disasm.py
@@ -1,8 +1,8 @@
 # Toshiba MeP-c4 - miasm disassembly engine
 # Guillaume Valadon <guillaume@valadon.net>
 
-from miasm2.core.asmblock import disasmEngine
-from miasm2.arch.mep.arch import mn_mep
+from miasm.core.asmblock import disasmEngine
+from miasm.arch.mep.arch import mn_mep
 
 
 class dis_mepb(disasmEngine):
diff --git a/miasm2/arch/mep/ira.py b/miasm/arch/mep/ira.py
index 34808656..2de4b5ae 100644
--- a/miasm2/arch/mep/ira.py
+++ b/miasm/arch/mep/ira.py
@@ -1,8 +1,8 @@
 # Toshiba MeP-c4 - miasm IR analysis
 # Guillaume Valadon <guillaume@valadon.net>
 
-from miasm2.arch.mep.sem import ir_mepb, ir_mepl
-from miasm2.ir.analysis import ira
+from miasm.arch.mep.sem import ir_mepb, ir_mepl
+from miasm.ir.analysis import ira
 
 
 class ir_a_mepb(ir_mepb, ira):
diff --git a/miasm2/arch/mep/jit.py b/miasm/arch/mep/jit.py
index 6c0e6ff5..98cc1805 100644
--- a/miasm2/arch/mep/jit.py
+++ b/miasm/arch/mep/jit.py
@@ -2,12 +2,12 @@
 # Guillaume Valadon <guillaume@valadon.net>
 # Note: inspiration from msp430/jit.py
 
-from miasm2.jitter.jitload import Jitter
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import *
-from miasm2.jitter.codegen import CGen
-from miasm2.ir.translators.C import TranslatorC
-from miasm2.arch.mep.sem import ir_mepl, ir_mepb
+from miasm.jitter.jitload import Jitter
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import *
+from miasm.jitter.codegen import CGen
+from miasm.ir.translators.C import TranslatorC
+from miasm.arch.mep.sem import ir_mepl, ir_mepb
 
 import logging
 
diff --git a/miasm2/arch/mep/regs.py b/miasm/arch/mep/regs.py
index 88248823..b7fa2a78 100644
--- a/miasm2/arch/mep/regs.py
+++ b/miasm/arch/mep/regs.py
@@ -2,8 +2,8 @@
 # Guillaume Valadon <guillaume@valadon.net>
 
 from builtins import range
-from miasm2.expression.expression import ExprId
-from miasm2.core.cpu import reg_info, gen_reg, gen_regs
+from miasm.expression.expression import ExprId
+from miasm.core.cpu import reg_info, gen_reg, gen_regs
 
 # Used by internal miasm exceptions
 exception_flags = ExprId("exception_flags", 32)
diff --git a/miasm2/arch/mep/sem.py b/miasm/arch/mep/sem.py
index c346c535..13a4d6ca 100644
--- a/miasm2/arch/mep/sem.py
+++ b/miasm/arch/mep/sem.py
@@ -1,18 +1,18 @@
 # Toshiba MeP-c4 - miasm instructions side effects
 # Guillaume Valadon <guillaume@valadon.net>
 
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.ir.ir import IntermediateRepresentation
-from miasm2.arch.mep.arch import mn_mep
-from miasm2.arch.mep.regs import PC, SP, LP, SAR, TP, RPB, RPE, RPC, EPC, NPC, \
+from miasm.core.sembuilder import SemBuilder
+from miasm.ir.ir import IntermediateRepresentation
+from miasm.arch.mep.arch import mn_mep
+from miasm.arch.mep.regs import PC, SP, LP, SAR, TP, RPB, RPE, RPC, EPC, NPC, \
     take_jmp, in_erepeat
-from miasm2.arch.mep.regs import EXC, HI, LO, PSW, DEPC, DBG
-from miasm2.expression.expression import ExprId, ExprInt, ExprOp, TOK_EQUAL
-from miasm2.expression.expression import ExprAssign, ExprCond, ExprMem
-from miasm2.core.cpu import sign_ext
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO
+from miasm.arch.mep.regs import EXC, HI, LO, PSW, DEPC, DBG
+from miasm.expression.expression import ExprId, ExprInt, ExprOp, TOK_EQUAL
+from miasm.expression.expression import ExprAssign, ExprCond, ExprMem
+from miasm.core.cpu import sign_ext
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO
 
-from miasm2.arch.mep.regs import exception_flags
+from miasm.arch.mep.regs import exception_flags
 
 
 def compute_s_inf(arg1, arg2):
diff --git a/miasm2/arch/mips32/__init__.py b/miasm/arch/mips32/__init__.py
index e69de29b..e69de29b 100644
--- a/miasm2/arch/mips32/__init__.py
+++ b/miasm/arch/mips32/__init__.py
diff --git a/miasm2/arch/mips32/arch.py b/miasm/arch/mips32/arch.py
index 6046b12c..68841e1e 100644
--- a/miasm2/arch/mips32/arch.py
+++ b/miasm/arch/mips32/arch.py
@@ -5,12 +5,12 @@ from collections import defaultdict
 
 from pyparsing import Literal, Optional
 
-from miasm2.expression.expression import ExprMem, ExprInt, ExprId, ExprOp, ExprLoc
-from miasm2.core.bin_stream import bin_stream
-import miasm2.arch.mips32.regs as regs
-import miasm2.core.cpu as cpu
+from miasm.expression.expression import ExprMem, ExprInt, ExprId, ExprOp, ExprLoc
+from miasm.core.bin_stream import bin_stream
+import miasm.arch.mips32.regs as regs
+import miasm.core.cpu as cpu
 
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 log = logging.getLogger("mips32dis")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/arch/mips32/disasm.py b/miasm/arch/mips32/disasm.py
index bdd800d5..b6c05cb7 100644
--- a/miasm2/arch/mips32/disasm.py
+++ b/miasm/arch/mips32/disasm.py
@@ -1,5 +1,5 @@
-from miasm2.core.asmblock import disasmEngine
-from miasm2.arch.mips32.arch import mn_mips32
+from miasm.core.asmblock import disasmEngine
+from miasm.arch.mips32.arch import mn_mips32
 
 
 
diff --git a/miasm2/arch/mips32/ira.py b/miasm/arch/mips32/ira.py
index 90558708..04a51c6c 100644
--- a/miasm2/arch/mips32/ira.py
+++ b/miasm/arch/mips32/ira.py
@@ -1,9 +1,9 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.expression.expression import ExprAssign, ExprOp
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.ir.analysis import ira
-from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b
+from miasm.expression.expression import ExprAssign, ExprOp
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.ir.analysis import ira
+from miasm.arch.mips32.sem import ir_mips32l, ir_mips32b
 
 class ir_a_mips32l(ir_mips32l, ira):
     def __init__(self, loc_db=None):
diff --git a/miasm2/arch/mips32/jit.py b/miasm/arch/mips32/jit.py
index 04690a3e..5e8d13f6 100644
--- a/miasm2/arch/mips32/jit.py
+++ b/miasm/arch/mips32/jit.py
@@ -1,13 +1,13 @@
 from builtins import range
 import logging
 
-from miasm2.jitter.jitload import Jitter, named_arguments
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import pck32, upck32
-from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b
-from miasm2.jitter.codegen import CGen
-from miasm2.ir.ir import AssignBlock, IRBlock
-import miasm2.expression.expression as m2_expr
+from miasm.jitter.jitload import Jitter, named_arguments
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import pck32, upck32
+from miasm.arch.mips32.sem import ir_mips32l, ir_mips32b
+from miasm.jitter.codegen import CGen
+from miasm.ir.ir import AssignBlock, IRBlock
+import miasm.expression.expression as m2_expr
 
 log = logging.getLogger('jit_mips32')
 hnd = logging.StreamHandler()
diff --git a/miasm2/arch/mips32/regs.py b/miasm/arch/mips32/regs.py
index d1d14bdc..1513e989 100644
--- a/miasm2/arch/mips32/regs.py
+++ b/miasm/arch/mips32/regs.py
@@ -1,8 +1,8 @@
 #-*- coding:utf-8 -*-
 
 from builtins import range
-from miasm2.expression.expression import ExprId
-from miasm2.core.cpu import gen_reg, gen_regs
+from miasm.expression.expression import ExprId
+from miasm.core.cpu import gen_reg, gen_regs
 
 
 PC, _ = gen_reg('PC')
diff --git a/miasm2/arch/mips32/sem.py b/miasm/arch/mips32/sem.py
index 62a85355..5fc491a7 100644
--- a/miasm2/arch/mips32/sem.py
+++ b/miasm/arch/mips32/sem.py
@@ -1,9 +1,9 @@
-import miasm2.expression.expression as m2_expr
-from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
-from miasm2.arch.mips32.arch import mn_mips32
-from miasm2.arch.mips32.regs import R_LO, R_HI, PC, RA, ZERO, exception_flags
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO
+import miasm.expression.expression as m2_expr
+from miasm.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
+from miasm.arch.mips32.arch import mn_mips32
+from miasm.arch.mips32.regs import R_LO, R_HI, PC, RA, ZERO, exception_flags
+from miasm.core.sembuilder import SemBuilder
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO
 
 
 # SemBuilder context
diff --git a/miasm2/arch/msp430/__init__.py b/miasm/arch/msp430/__init__.py
index bbad893b..bbad893b 100644
--- a/miasm2/arch/msp430/__init__.py
+++ b/miasm/arch/msp430/__init__.py
diff --git a/miasm2/arch/msp430/arch.py b/miasm/arch/msp430/arch.py
index fd31f6c4..65dd435e 100644
--- a/miasm2/arch/msp430/arch.py
+++ b/miasm/arch/msp430/arch.py
@@ -4,13 +4,13 @@ from builtins import range
 
 import logging
 from pyparsing import *
-from miasm2.expression.expression import *
-from miasm2.core.cpu import *
+from miasm.expression.expression import *
+from miasm.core.cpu import *
 from collections import defaultdict
-from miasm2.core.bin_stream import bin_stream
-import miasm2.arch.msp430.regs as regs_module
-from miasm2.arch.msp430.regs import *
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.bin_stream import bin_stream
+import miasm.arch.msp430.regs as regs_module
+from miasm.arch.msp430.regs import *
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 log = logging.getLogger("msp430dis")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/arch/msp430/ctype.py b/miasm/arch/msp430/ctype.py
index 464adaf8..0e6562e8 100644
--- a/miasm2/arch/msp430/ctype.py
+++ b/miasm/arch/msp430/ctype.py
@@ -1,5 +1,5 @@
-from miasm2.core.objc import CLeafTypes, ObjCDecl, PADDING_TYPE_NAME
-from miasm2.core.ctypesmngr import CTypeId, CTypePtr
+from miasm.core.objc import CLeafTypes, ObjCDecl, PADDING_TYPE_NAME
+from miasm.core.ctypesmngr import CTypeId, CTypePtr
 
 
 class CTypeMSP430_unk(CLeafTypes):
diff --git a/miasm2/arch/msp430/disasm.py b/miasm/arch/msp430/disasm.py
index 849cd675..eff77d2d 100644
--- a/miasm2/arch/msp430/disasm.py
+++ b/miasm/arch/msp430/disasm.py
@@ -1,5 +1,5 @@
-from miasm2.core.asmblock import disasmEngine
-from miasm2.arch.msp430.arch import mn_msp430
+from miasm.core.asmblock import disasmEngine
+from miasm.arch.msp430.arch import mn_msp430
 
 
 class dis_msp430(disasmEngine):
diff --git a/miasm2/arch/msp430/ira.py b/miasm/arch/msp430/ira.py
index 5b19956e..72889149 100644
--- a/miasm2/arch/msp430/ira.py
+++ b/miasm/arch/msp430/ira.py
@@ -1,9 +1,9 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.ir.analysis import ira
-from miasm2.arch.msp430.sem import ir_msp430
-from miasm2.ir.ir import AssignBlock
-from miasm2.expression.expression import *
+from miasm.ir.analysis import ira
+from miasm.arch.msp430.sem import ir_msp430
+from miasm.ir.ir import AssignBlock
+from miasm.expression.expression import *
 
 class ir_a_msp430_base(ir_msp430, ira):
 
diff --git a/miasm2/arch/msp430/jit.py b/miasm/arch/msp430/jit.py
index e4d04f9f..ea30922c 100644
--- a/miasm2/arch/msp430/jit.py
+++ b/miasm/arch/msp430/jit.py
@@ -1,7 +1,7 @@
-from miasm2.jitter.jitload import Jitter
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import pck16, upck16
-from miasm2.arch.msp430.sem import ir_msp430
+from miasm.jitter.jitload import Jitter
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import pck16, upck16
+from miasm.arch.msp430.sem import ir_msp430
 
 import logging
 
diff --git a/miasm2/arch/msp430/regs.py b/miasm/arch/msp430/regs.py
index a3e714b2..2bcaa055 100644
--- a/miasm2/arch/msp430/regs.py
+++ b/miasm/arch/msp430/regs.py
@@ -1,6 +1,6 @@
 from builtins import range
-from miasm2.expression.expression import *
-from miasm2.core.cpu import reg_info
+from miasm.expression.expression import *
+from miasm.core.cpu import reg_info
 
 
 # GP
diff --git a/miasm2/arch/msp430/sem.py b/miasm/arch/msp430/sem.py
index b939c224..52056e5a 100644
--- a/miasm2/arch/msp430/sem.py
+++ b/miasm/arch/msp430/sem.py
@@ -1,9 +1,9 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.expression.expression import *
-from miasm2.arch.msp430.regs import *
-from miasm2.arch.msp430.arch import mn_msp430
-from miasm2.ir.ir import IntermediateRepresentation
+from miasm.expression.expression import *
+from miasm.arch.msp430.regs import *
+from miasm.arch.msp430.arch import mn_msp430
+from miasm.ir.ir import IntermediateRepresentation
 
 
 # Utils
diff --git a/miasm2/arch/ppc/__init__.py b/miasm/arch/ppc/__init__.py
index bbad893b..bbad893b 100644
--- a/miasm2/arch/ppc/__init__.py
+++ b/miasm/arch/ppc/__init__.py
diff --git a/miasm2/arch/ppc/arch.py b/miasm/arch/ppc/arch.py
index e7661371..8f700bff 100644
--- a/miasm2/arch/ppc/arch.py
+++ b/miasm/arch/ppc/arch.py
@@ -2,13 +2,13 @@ from builtins import range
 
 import logging
 from pyparsing import *
-from miasm2.expression.expression import *
-from miasm2.core.cpu import *
+from miasm.expression.expression import *
+from miasm.core.cpu import *
 from collections import defaultdict
-from miasm2.core.bin_stream import bin_stream
-import miasm2.arch.ppc.regs as regs_module
-from miasm2.arch.ppc.regs import *
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.bin_stream import bin_stream
+import miasm.arch.ppc.regs as regs_module
+from miasm.arch.ppc.regs import *
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 log = logging.getLogger("ppcdis")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/arch/ppc/disasm.py b/miasm/arch/ppc/disasm.py
index 9fe3d886..b91d96bf 100644
--- a/miasm2/arch/ppc/disasm.py
+++ b/miasm/arch/ppc/disasm.py
@@ -1,5 +1,5 @@
-from miasm2.arch.ppc.arch import mn_ppc
-from miasm2.core.asmblock import disasmEngine
+from miasm.arch.ppc.arch import mn_ppc
+from miasm.core.asmblock import disasmEngine
 
 class dis_ppc32b(disasmEngine):
     def __init__(self, bs=None, **kwargs):
diff --git a/miasm2/arch/ppc/ira.py b/miasm/arch/ppc/ira.py
index cde57dd3..953c5a86 100644
--- a/miasm2/arch/ppc/ira.py
+++ b/miasm/arch/ppc/ira.py
@@ -1,7 +1,7 @@
-from miasm2.expression.expression import ExprAssign, ExprOp
-from miasm2.ir.ir import AssignBlock
-from miasm2.ir.analysis import ira
-from miasm2.arch.ppc.sem import ir_ppc32b
+from miasm.expression.expression import ExprAssign, ExprOp
+from miasm.ir.ir import AssignBlock
+from miasm.ir.analysis import ira
+from miasm.arch.ppc.sem import ir_ppc32b
 
 
 class ir_a_ppc32b(ir_ppc32b, ira):
diff --git a/miasm2/arch/ppc/jit.py b/miasm/arch/ppc/jit.py
index 8dc4aa99..1d7ae70c 100644
--- a/miasm2/arch/ppc/jit.py
+++ b/miasm/arch/ppc/jit.py
@@ -1,7 +1,7 @@
 from builtins import range
-from miasm2.jitter.jitload import Jitter, named_arguments
-from miasm2.core.locationdb import LocationDB
-from miasm2.arch.ppc.sem import ir_ppc32b
+from miasm.jitter.jitload import Jitter, named_arguments
+from miasm.core.locationdb import LocationDB
+from miasm.arch.ppc.sem import ir_ppc32b
 import struct
 
 import logging
diff --git a/miasm2/arch/ppc/regs.py b/miasm/arch/ppc/regs.py
index e70afce2..97556931 100644
--- a/miasm2/arch/ppc/regs.py
+++ b/miasm/arch/ppc/regs.py
@@ -1,7 +1,7 @@
 
 from builtins import range
-from miasm2.expression.expression import *
-from miasm2.core.cpu import gen_reg, gen_regs
+from miasm.expression.expression import *
+from miasm.core.cpu import gen_reg, gen_regs
 
 exception_flags = ExprId('exception_flags', 32)
 spr_access = ExprId('spr_access', 32)
diff --git a/miasm2/arch/ppc/sem.py b/miasm/arch/ppc/sem.py
index ef44ffe3..5e8e394c 100644
--- a/miasm2/arch/ppc/sem.py
+++ b/miasm/arch/ppc/sem.py
@@ -1,12 +1,12 @@
 from __future__ import print_function
 from builtins import range
 
-import miasm2.expression.expression as expr
-from miasm2.ir.ir import AssignBlock, IntermediateRepresentation, IRBlock
-from miasm2.arch.ppc.arch import mn_ppc
-from miasm2.arch.ppc.regs import *
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.jitter.csts import *
+import miasm.expression.expression as expr
+from miasm.ir.ir import AssignBlock, IntermediateRepresentation, IRBlock
+from miasm.arch.ppc.arch import mn_ppc
+from miasm.arch.ppc.regs import *
+from miasm.core.sembuilder import SemBuilder
+from miasm.jitter.csts import *
 
 spr_dict = {
     8: LR, 9: CTR, 18: DSISR, 19: DAR,
diff --git a/miasm2/arch/sh4/__init__.py b/miasm/arch/sh4/__init__.py
index e69de29b..e69de29b 100644
--- a/miasm2/arch/sh4/__init__.py
+++ b/miasm/arch/sh4/__init__.py
diff --git a/miasm2/arch/sh4/arch.py b/miasm/arch/sh4/arch.py
index c7ff6ab0..9310d3c3 100644
--- a/miasm2/arch/sh4/arch.py
+++ b/miasm/arch/sh4/arch.py
@@ -4,14 +4,14 @@ from __future__ import print_function
 from builtins import range
 
 from pyparsing import *
-from miasm2.core.cpu import *
-from miasm2.expression.expression import *
+from miasm.core.cpu import *
+from miasm.expression.expression import *
 from collections import defaultdict
-import miasm2.arch.sh4.regs as regs_module
-from miasm2.arch.sh4.regs import *
+import miasm.arch.sh4.regs as regs_module
+from miasm.arch.sh4.regs import *
 
 
-from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp
+from miasm.core.asm_ast import AstInt, AstId, AstMem, AstOp
 
 jra = ExprId('jra', 32)
 jrb = ExprId('jrb', 32)
diff --git a/miasm2/arch/sh4/regs.py b/miasm/arch/sh4/regs.py
index c294eb8c..8a7e1881 100644
--- a/miasm2/arch/sh4/regs.py
+++ b/miasm/arch/sh4/regs.py
@@ -1,6 +1,6 @@
 from builtins import range
-from miasm2.expression.expression import *
-from miasm2.core.cpu import reg_info, gen_reg
+from miasm.expression.expression import *
+from miasm.core.cpu import reg_info, gen_reg
 
 # GP
 gpregs_str = ['R%d' % r for r in range(0x10)]
diff --git a/miasm2/arch/x86/__init__.py b/miasm/arch/x86/__init__.py
index bbad893b..bbad893b 100644
--- a/miasm2/arch/x86/__init__.py
+++ b/miasm/arch/x86/__init__.py
diff --git a/miasm2/arch/x86/arch.py b/miasm/arch/x86/arch.py
index 7a2c371c..a82fac02 100644
--- a/miasm2/arch/x86/arch.py
+++ b/miasm/arch/x86/arch.py
@@ -6,14 +6,14 @@ import re
 
 from future.utils import viewitems
 
-from miasm2.core.utils import int_to_byte
-from miasm2.expression.expression import *
+from miasm.core.utils import int_to_byte
+from miasm.expression.expression import *
 from pyparsing import *
-from miasm2.core.cpu import *
+from miasm.core.cpu import *
 from collections import defaultdict
-import miasm2.arch.x86.regs as regs_module
-from miasm2.arch.x86.regs import *
-from miasm2.core.asm_ast import AstNode, AstInt, AstId, AstMem, AstOp
+import miasm.arch.x86.regs as regs_module
+from miasm.arch.x86.regs import *
+from miasm.core.asm_ast import AstNode, AstInt, AstId, AstMem, AstOp
 
 
 log = logging.getLogger("x86_arch")
diff --git a/miasm2/arch/x86/ctype.py b/miasm/arch/x86/ctype.py
index 5d1be0de..2a61689a 100644
--- a/miasm2/arch/x86/ctype.py
+++ b/miasm/arch/x86/ctype.py
@@ -1,5 +1,5 @@
-from miasm2.core.objc import CLeafTypes, ObjCDecl, PADDING_TYPE_NAME
-from miasm2.core.ctypesmngr import CTypeId, CTypePtr
+from miasm.core.objc import CLeafTypes, ObjCDecl, PADDING_TYPE_NAME
+from miasm.core.ctypesmngr import CTypeId, CTypePtr
 
 
 class CTypeAMD64_unk(CLeafTypes):
diff --git a/miasm2/arch/x86/disasm.py b/miasm/arch/x86/disasm.py
index ecb1b8da..01147970 100644
--- a/miasm2/arch/x86/disasm.py
+++ b/miasm/arch/x86/disasm.py
@@ -1,5 +1,5 @@
-from miasm2.core.asmblock import disasmEngine
-from miasm2.arch.x86.arch import mn_x86
+from miasm.core.asmblock import disasmEngine
+from miasm.arch.x86.arch import mn_x86
 
 
 cb_x86_funcs = []
diff --git a/miasm2/arch/x86/ira.py b/miasm/arch/x86/ira.py
index 749069f6..dc6db273 100644
--- a/miasm2/arch/x86/ira.py
+++ b/miasm/arch/x86/ira.py
@@ -1,9 +1,9 @@
 #-*- coding:utf-8 -*-
 
-from miasm2.expression.expression import ExprAssign, ExprOp
-from miasm2.ir.ir import AssignBlock
-from miasm2.ir.analysis import ira
-from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
+from miasm.expression.expression import ExprAssign, ExprOp
+from miasm.ir.ir import AssignBlock
+from miasm.ir.analysis import ira
+from miasm.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
 
 
 class ir_a_x86_16(ir_x86_16, ira):
diff --git a/miasm2/arch/x86/jit.py b/miasm/arch/x86/jit.py
index 14418902..2d1e45c3 100644
--- a/miasm2/arch/x86/jit.py
+++ b/miasm/arch/x86/jit.py
@@ -1,11 +1,11 @@
 from builtins import range
 import logging
 
-from miasm2.jitter.jitload import Jitter, named_arguments
-from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
-from miasm2.jitter.codegen import CGen
-from miasm2.core.locationdb import LocationDB
-from miasm2.ir.translators.C import TranslatorC
+from miasm.jitter.jitload import Jitter, named_arguments
+from miasm.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
+from miasm.jitter.codegen import CGen
+from miasm.core.locationdb import LocationDB
+from miasm.ir.translators.C import TranslatorC
 
 log = logging.getLogger('jit_x86')
 hnd = logging.StreamHandler()
diff --git a/miasm2/arch/x86/regs.py b/miasm/arch/x86/regs.py
index b3f6534b..1fc2009c 100644
--- a/miasm2/arch/x86/regs.py
+++ b/miasm/arch/x86/regs.py
@@ -1,6 +1,6 @@
 from builtins import range
-from miasm2.expression.expression import ExprId
-from miasm2.core.cpu import reg_info
+from miasm.expression.expression import ExprId
+from miasm.core.cpu import reg_info
 
 
 IP = ExprId('IP', 16)
diff --git a/miasm2/arch/x86/sem.py b/miasm/arch/x86/sem.py
index bec09249..52858ad2 100644
--- a/miasm2/arch/x86/sem.py
+++ b/miasm/arch/x86/sem.py
@@ -21,13 +21,13 @@ from builtins import range
 from future.utils import viewitems
 
 import logging
-import miasm2.expression.expression as m2_expr
-from miasm2.expression.simplifications import expr_simp
-from miasm2.arch.x86.regs import *
-from miasm2.arch.x86.arch import mn_x86, repeat_mn, replace_regs
-from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_ILLEGAL_INSN, \
+import miasm.expression.expression as m2_expr
+from miasm.expression.simplifications import expr_simp
+from miasm.arch.x86.regs import *
+from miasm.arch.x86.arch import mn_x86, repeat_mn, replace_regs
+from miasm.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
+from miasm.core.sembuilder import SemBuilder
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_ILLEGAL_INSN, \
     EXCEPT_PRIV_INSN, EXCEPT_SOFT_BP, EXCEPT_INT_XX
 import math
 import struct
diff --git a/miasm2/core/__init__.py b/miasm/core/__init__.py
index d154134b..d154134b 100644
--- a/miasm2/core/__init__.py
+++ b/miasm/core/__init__.py
diff --git a/miasm2/core/asm_ast.py b/miasm/core/asm_ast.py
index 69ff1f9c..69ff1f9c 100644
--- a/miasm2/core/asm_ast.py
+++ b/miasm/core/asm_ast.py
diff --git a/miasm2/core/asmblock.py b/miasm/core/asmblock.py
index 811cc824..0e715f41 100644
--- a/miasm2/core/asmblock.py
+++ b/miasm/core/asmblock.py
@@ -9,14 +9,14 @@ from builtins import int as int_types
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import ExprId, ExprInt, get_expr_locs
-from miasm2.expression.expression import LocKey
-from miasm2.expression.simplifications import expr_simp
-from miasm2.expression.modint import moduint, modint
-from miasm2.core.utils import Disasm_Exception, pck
-from miasm2.core.graph import DiGraph, DiGraphSimplifier, MatchGraphJoker
-from miasm2.core.interval import interval
-from miasm2.core.locationdb import LocationDB
+from miasm.expression.expression import ExprId, ExprInt, get_expr_locs
+from miasm.expression.expression import LocKey
+from miasm.expression.simplifications import expr_simp
+from miasm.expression.modint import moduint, modint
+from miasm.core.utils import Disasm_Exception, pck
+from miasm.core.graph import DiGraph, DiGraphSimplifier, MatchGraphJoker
+from miasm.core.interval import interval
+from miasm.core.locationdb import LocationDB
 
 
 log_asmblock = logging.getLogger("asmblock")
@@ -814,7 +814,7 @@ class AsmCFG(DiGraph):
                 if not (off > range_start and off < range_stop):
                     continue
 
-                # `cur_block` must be split at offset `off`from miasm2.core.locationdb import LocationDB
+                # `cur_block` must be split at offset `off`from miasm.core.locationdb import LocationDB
 
                 new_b = cur_block.split(loc_db, off)
                 log_asmblock.debug("Split block %x", off)
diff --git a/miasm2/core/bin_stream.py b/miasm/core/bin_stream.py
index 4977e2ae..727a853d 100644
--- a/miasm2/core/bin_stream.py
+++ b/miasm/core/bin_stream.py
@@ -19,9 +19,9 @@
 from builtins import str
 from future.utils import PY3
 
-from miasm2.core.utils import BIG_ENDIAN, LITTLE_ENDIAN
-from miasm2.core.utils import upck8le, upck16le, upck32le, upck64le
-from miasm2.core.utils import upck8be, upck16be, upck32be, upck64be
+from miasm.core.utils import BIG_ENDIAN, LITTLE_ENDIAN
+from miasm.core.utils import upck8le, upck16le, upck32le, upck64le
+from miasm.core.utils import upck8be, upck16be, upck32be, upck64be
 
 
 class bin_stream(object):
diff --git a/miasm2/core/bin_stream_ida.py b/miasm/core/bin_stream_ida.py
index 44cf9367..e0fab297 100644
--- a/miasm2/core/bin_stream_ida.py
+++ b/miasm/core/bin_stream_ida.py
@@ -3,8 +3,8 @@ from idc import Byte, SegEnd
 from idautils import Segments
 from idaapi import is_mapped
 
-from miasm2.core.utils import int_to_byte
-from miasm2.core.bin_stream import bin_stream_str
+from miasm.core.utils import int_to_byte
+from miasm.core.bin_stream import bin_stream_str
 
 
 class bin_stream_ida(bin_stream_str):
diff --git a/miasm2/core/cpu.py b/miasm/core/cpu.py
index c24b693d..425f3aff 100644
--- a/miasm2/core/cpu.py
+++ b/miasm/core/cpu.py
@@ -11,15 +11,15 @@ from future.utils import viewitems, viewvalues
 
 import pyparsing
 
-from miasm2.core.utils import decode_hex
-import miasm2.expression.expression as m2_expr
-from miasm2.core.bin_stream import bin_stream, bin_stream_str
-from miasm2.core.utils import Disasm_Exception
-from miasm2.expression.simplifications import expr_simp
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex
+import miasm.expression.expression as m2_expr
+from miasm.core.bin_stream import bin_stream, bin_stream_str
+from miasm.core.utils import Disasm_Exception
+from miasm.expression.simplifications import expr_simp
+from miasm.core.locationdb import LocationDB
 
 
-from miasm2.core.asm_ast import AstNode, AstInt, AstId, AstOp
+from miasm.core.asm_ast import AstNode, AstInt, AstId, AstOp
 from future.utils import with_metaclass
 
 log = logging.getLogger("cpuhelper")
diff --git a/miasm2/core/ctypesmngr.py b/miasm/core/ctypesmngr.py
index 94c96f7e..94c96f7e 100644
--- a/miasm2/core/ctypesmngr.py
+++ b/miasm/core/ctypesmngr.py
diff --git a/miasm2/core/graph.py b/miasm/core/graph.py
index f585379b..f585379b 100644
--- a/miasm2/core/graph.py
+++ b/miasm/core/graph.py
diff --git a/miasm2/core/interval.py b/miasm/core/interval.py
index 06dc546f..06dc546f 100644
--- a/miasm2/core/interval.py
+++ b/miasm/core/interval.py
diff --git a/miasm2/core/locationdb.py b/miasm/core/locationdb.py
index 906a247a..dd336752 100644
--- a/miasm2/core/locationdb.py
+++ b/miasm/core/locationdb.py
@@ -4,9 +4,9 @@ from builtins import int as int_types
 from functools import reduce
 from future.utils import viewitems, viewvalues
 
-from miasm2.core.utils import printable, force_bytes
-from miasm2.expression.expression import LocKey, ExprLoc
-from miasm2.expression.modint import moduint, modint
+from miasm.core.utils import printable, force_bytes
+from miasm.expression.expression import LocKey, ExprLoc
+from miasm.expression.modint import moduint, modint
 
 
 def is_int(a):
diff --git a/miasm2/core/objc.py b/miasm/core/objc.py
index 30b00682..f7765b96 100644
--- a/miasm2/core/objc.py
+++ b/miasm/core/objc.py
@@ -12,11 +12,11 @@ import warnings
 from pycparser import c_parser, c_ast
 from functools import total_ordering
 
-from miasm2.core.utils import cmp_elts
-from miasm2.expression.expression_reduce import ExprReducer
-from miasm2.expression.expression import ExprInt, ExprId, ExprOp, ExprMem
+from miasm.core.utils import cmp_elts
+from miasm.expression.expression_reduce import ExprReducer
+from miasm.expression.expression import ExprInt, ExprId, ExprOp, ExprMem
 
-from miasm2.core.ctypesmngr import CTypeUnion, CTypeStruct, CTypeId, CTypePtr,\
+from miasm.core.ctypesmngr import CTypeUnion, CTypeStruct, CTypeId, CTypePtr,\
     CTypeArray, CTypeOp, CTypeSizeof, CTypeEnum, CTypeFunc, CTypeEllipsis
 
 
diff --git a/miasm2/core/parse_asm.py b/miasm/core/parse_asm.py
index e9982503..2e843474 100644
--- a/miasm2/core/parse_asm.py
+++ b/miasm/core/parse_asm.py
@@ -3,10 +3,10 @@ import re
 import codecs
 from builtins import range
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprOp, LocKey
-import miasm2.core.asmblock as asmblock
-from miasm2.core.cpu import instruction, base_expr
-from miasm2.core.asm_ast import AstInt, AstId, AstOp
+from miasm.expression.expression import ExprId, ExprInt, ExprOp, LocKey
+import miasm.core.asmblock as asmblock
+from miasm.core.cpu import instruction, base_expr
+from miasm.core.asm_ast import AstInt, AstId, AstOp
 
 declarator = {'byte': 8,
               'word': 16,
diff --git a/miasm2/core/sembuilder.py b/miasm/core/sembuilder.py
index 8ea4c4ac..c51ce608 100644
--- a/miasm2/core/sembuilder.py
+++ b/miasm/core/sembuilder.py
@@ -6,8 +6,8 @@ import re
 
 from future.utils import PY3
 
-import miasm2.expression.expression as m2_expr
-from miasm2.ir.ir import IRBlock, AssignBlock
+import miasm.expression.expression as m2_expr
+from miasm.ir.ir import IRBlock, AssignBlock
 
 
 class MiasmTransformer(ast.NodeTransformer):
diff --git a/miasm2/core/types.py b/miasm/core/types.py
index b915c27f..971b1f98 100644
--- a/miasm2/core/types.py
+++ b/miasm/core/types.py
@@ -94,7 +94,7 @@ in the format expected by, respectively, Union and BitField.
 The `addr` argument can be omitted if an allocator is set, in which case the
 structure will be automatically allocated in memory:
 
-    my_heap = miasm2.os_dep.common.heap()
+    my_heap = miasm.os_dep.common.heap()
     # the allocator is a func(VmMngr) -> integer_address
     set_allocator(my_heap)
 
@@ -157,7 +157,7 @@ def indent(s, size=4):
 
 
 # String generic getter/setter/len-er
-# TODO: make miasm2.os_dep.common and jitter ones use these ones
+# TODO: make miasm.os_dep.common and jitter ones use these ones
 
 def get_str(vm, addr, enc, max_char=None, end=u'\x00'):
     """Get a @end (by default '\\x00') terminated @enc encoded string from a
diff --git a/miasm2/core/utils.py b/miasm/core/utils.py
index 9856d4f2..9856d4f2 100644
--- a/miasm2/core/utils.py
+++ b/miasm/core/utils.py
diff --git a/miasm2/expression/__init__.py b/miasm/expression/__init__.py
index 67f567f7..67f567f7 100644
--- a/miasm2/expression/__init__.py
+++ b/miasm/expression/__init__.py
diff --git a/miasm2/expression/expression.py b/miasm/expression/expression.py
index 03febbfd..f0151e98 100644
--- a/miasm2/expression/expression.py
+++ b/miasm/expression/expression.py
@@ -37,10 +37,10 @@ from builtins import int as int_types
 from functools import cmp_to_key, total_ordering
 from future.utils import viewitems
 
-from miasm2.core.utils import force_bytes, cmp_elts
-from miasm2.expression.modint import mod_size2uint, is_modint, size2mask, \
+from miasm.core.utils import force_bytes, cmp_elts
+from miasm.expression.modint import mod_size2uint, is_modint, size2mask, \
     define_uint
-from miasm2.core.graph import DiGraph
+from miasm.core.graph import DiGraph
 from functools import reduce
 
 # Define tokens
@@ -387,7 +387,7 @@ class Expr(object):
 
     def graph_recursive(self, graph):
         """Recursive method used by graph
-        @graph: miasm2.core.graph.DiGraph instance
+        @graph: miasm.core.graph.DiGraph instance
         Update @graph instance to include sons
         This is an Abstract method"""
 
diff --git a/miasm2/expression/expression_helper.py b/miasm/expression/expression_helper.py
index a50e0d5b..299e52e6 100644
--- a/miasm2/expression/expression_helper.py
+++ b/miasm/expression/expression_helper.py
@@ -26,7 +26,7 @@ import warnings
 
 from future.utils import viewitems, viewvalues
 
-import miasm2.expression.expression as m2_expr
+import miasm.expression.expression as m2_expr
 
 
 def parity(a):
diff --git a/miasm2/expression/expression_reduce.py b/miasm/expression/expression_reduce.py
index adad552e..64d90956 100644
--- a/miasm2/expression/expression_reduce.py
+++ b/miasm/expression/expression_reduce.py
@@ -4,7 +4,7 @@ Apply reduction rules to an Expression ast
 """
 
 import logging
-from miasm2.expression.expression import ExprInt, ExprId, ExprLoc, ExprOp, \
+from miasm.expression.expression import ExprInt, ExprId, ExprLoc, ExprOp, \
     ExprSlice, ExprCompose, ExprMem, ExprCond
 
 log_reduce = logging.getLogger("expr_reduce")
diff --git a/miasm2/expression/modint.py b/miasm/expression/modint.py
index 22d17b9b..22d17b9b 100644
--- a/miasm2/expression/modint.py
+++ b/miasm/expression/modint.py
diff --git a/miasm2/expression/parser.py b/miasm/expression/parser.py
index 71efc849..20113eab 100644
--- a/miasm2/expression/parser.py
+++ b/miasm/expression/parser.py
@@ -1,5 +1,5 @@
 import pyparsing
-from miasm2.expression.expression import ExprInt, ExprId, ExprLoc, ExprSlice, \
+from miasm.expression.expression import ExprInt, ExprId, ExprLoc, ExprSlice, \
     ExprMem, ExprCond, ExprCompose, ExprOp, ExprAssign, LocKey
 
 integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda t:
diff --git a/miasm2/expression/simplifications.py b/miasm/expression/simplifications.py
index 331018ae..585a9c6b 100644
--- a/miasm2/expression/simplifications.py
+++ b/miasm/expression/simplifications.py
@@ -6,11 +6,11 @@ import logging
 
 from future.utils import viewitems
 
-from miasm2.expression import simplifications_common
-from miasm2.expression import simplifications_cond
-from miasm2.expression import simplifications_explicit
-from miasm2.expression.expression_helper import fast_unify
-import miasm2.expression.expression as m2_expr
+from miasm.expression import simplifications_common
+from miasm.expression import simplifications_cond
+from miasm.expression import simplifications_explicit
+from miasm.expression.expression_helper import fast_unify
+import miasm.expression.expression as m2_expr
 
 # Expression Simplifier
 # ---------------------
diff --git a/miasm2/expression/simplifications_common.py b/miasm/expression/simplifications_common.py
index ddcfc668..9737278b 100644
--- a/miasm2/expression/simplifications_common.py
+++ b/miasm/expression/simplifications_common.py
@@ -4,11 +4,11 @@
 
 from future.utils import viewitems
 
-from miasm2.expression.modint import mod_size2int, mod_size2uint
-from miasm2.expression.expression import ExprInt, ExprSlice, ExprMem, \
+from miasm.expression.modint import mod_size2int, mod_size2uint
+from miasm.expression.expression import ExprInt, ExprSlice, ExprMem, \
     ExprCond, ExprOp, ExprCompose, TOK_INF_SIGNED, TOK_INF_UNSIGNED, \
     TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED, TOK_EQUAL
-from miasm2.expression.expression_helper import parity, op_propag_cst, \
+from miasm.expression.expression_helper import parity, op_propag_cst, \
     merge_sliceto_slice
 
 
diff --git a/miasm2/expression/simplifications_cond.py b/miasm/expression/simplifications_cond.py
index f1c224b7..6167cb4d 100644
--- a/miasm2/expression/simplifications_cond.py
+++ b/miasm/expression/simplifications_cond.py
@@ -14,7 +14,7 @@
 #
 ################################################################################
 
-import miasm2.expression.expression as m2_expr
+import miasm.expression.expression as m2_expr
 
 
 # Jokers for expression matching
diff --git a/miasm2/expression/simplifications_explicit.py b/miasm/expression/simplifications_explicit.py
index 00892201..727db9c1 100644
--- a/miasm2/expression/simplifications_explicit.py
+++ b/miasm/expression/simplifications_explicit.py
@@ -1,5 +1,5 @@
-from miasm2.expression.modint import size2mask
-from miasm2.expression.expression import ExprInt, ExprCond, ExprCompose, \
+from miasm.expression.modint import size2mask
+from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
     TOK_EQUAL
 
 
diff --git a/miasm2/expression/smt2_helper.py b/miasm/expression/smt2_helper.py
index 53d323e8..53d323e8 100644
--- a/miasm2/expression/smt2_helper.py
+++ b/miasm/expression/smt2_helper.py
diff --git a/miasm2/ir/__init__.py b/miasm/ir/__init__.py
index 0627b488..0627b488 100644
--- a/miasm2/ir/__init__.py
+++ b/miasm/ir/__init__.py
diff --git a/miasm2/ir/analysis.py b/miasm/ir/analysis.py
index 9158aceb..67df793e 100644
--- a/miasm2/ir/analysis.py
+++ b/miasm/ir/analysis.py
@@ -3,9 +3,9 @@
 import warnings
 import logging
 
-from miasm2.ir.ir import IntermediateRepresentation, AssignBlock
-from miasm2.expression.expression import ExprOp, ExprAssign
-from miasm2.analysis.data_flow import dead_simp as new_dead_simp_imp
+from miasm.ir.ir import IntermediateRepresentation, AssignBlock
+from miasm.expression.expression import ExprOp, ExprAssign
+from miasm.analysis.data_flow import dead_simp as new_dead_simp_imp
 
 
 log = logging.getLogger("analysis")
@@ -21,7 +21,7 @@ class ira(IntermediateRepresentation):
     instruction removals.
 
     This class can be used as a common parent with
-    `miasm2.ir.ir::IntermediateRepresentation` class.
+    `miasm.ir.ir::IntermediateRepresentation` class.
 
     For instance:
         class ira_x86_16(ir_x86_16, ira)
@@ -108,6 +108,6 @@ class ira(IntermediateRepresentation):
         raise NotImplementedError("Abstract method")
 
     def dead_simp(self, ircfg):
-        """Deprecated: See miasm2.analysis.data_flow.dead_simp()"""
-        warnings.warn('DEPRECATION WARNING: Please use miasm2.analysis.data_flow.dead_simp(ira) instead of ira.dead_simp()')
+        """Deprecated: See miasm.analysis.data_flow.dead_simp()"""
+        warnings.warn('DEPRECATION WARNING: Please use miasm.analysis.data_flow.dead_simp(ira) instead of ira.dead_simp()')
         new_dead_simp_imp(self, ircfg)
diff --git a/miasm2/ir/ir.py b/miasm/ir/ir.py
index 82b12dcd..eb9857b1 100644
--- a/miasm2/ir/ir.py
+++ b/miasm/ir/ir.py
@@ -23,10 +23,10 @@ import warnings
 from itertools import chain
 from future.utils import viewvalues, viewitems
 
-import miasm2.expression.expression as m2_expr
-from miasm2.expression.expression_helper import get_missing_interval
-from miasm2.core.asmblock import AsmBlock, AsmConstraint
-from miasm2.core.graph import DiGraph
+import miasm.expression.expression as m2_expr
+from miasm.expression.expression_helper import get_missing_interval
+from miasm.core.asmblock import AsmBlock, AsmConstraint
+from miasm.core.graph import DiGraph
 from functools import reduce
 
 
diff --git a/miasm2/ir/symbexec.py b/miasm/ir/symbexec.py
index b945e85c..23df0ffb 100644
--- a/miasm2/ir/symbexec.py
+++ b/miasm/ir/symbexec.py
@@ -5,10 +5,10 @@ from collections import MutableMapping
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprOp, ExprId, ExprLoc, ExprInt, \
+from miasm.expression.expression import ExprOp, ExprId, ExprLoc, ExprInt, \
     ExprMem, ExprCompose, ExprSlice, ExprCond
-from miasm2.expression.simplifications import expr_simp_explicit
-from miasm2.ir.ir import AssignBlock
+from miasm.expression.simplifications import expr_simp_explicit
+from miasm.ir.ir import AssignBlock
 
 log = logging.getLogger("symbexec")
 console_handler = logging.StreamHandler()
@@ -761,8 +761,8 @@ class SymbolicExecutionEngine(object):
 
 
     Examples:
-        from miasm2.ir.symbexec import SymbolicExecutionEngine
-        from miasm2.ir.ir import AssignBlock
+        from miasm.ir.symbexec import SymbolicExecutionEngine
+        from miasm.ir.ir import AssignBlock
 
         ir_arch = ir_x86_32()
 
diff --git a/miasm2/ir/symbexec_top.py b/miasm/ir/symbexec_top.py
index a1a255f8..d37293b5 100644
--- a/miasm2/ir/symbexec_top.py
+++ b/miasm/ir/symbexec_top.py
@@ -1,8 +1,8 @@
 from future.utils import viewitems
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine, StateEngine
-from miasm2.expression.simplifications import expr_simp
-from miasm2.expression.expression import ExprId, ExprInt, ExprSlice,\
+from miasm.ir.symbexec import SymbolicExecutionEngine, StateEngine
+from miasm.expression.simplifications import expr_simp
+from miasm.expression.expression import ExprId, ExprInt, ExprSlice,\
     ExprMem, ExprCond, ExprCompose, ExprOp
 
 
diff --git a/miasm2/ir/symbexec_types.py b/miasm/ir/symbexec_types.py
index 57b7580a..c969a2f5 100644
--- a/miasm2/ir/symbexec_types.py
+++ b/miasm/ir/symbexec_types.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 
 from future.utils import viewitems
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine, StateEngine
-from miasm2.expression.simplifications import expr_simp
-from miasm2.expression.expression import ExprId, ExprMem
+from miasm.ir.symbexec import SymbolicExecutionEngine, StateEngine
+from miasm.expression.simplifications import expr_simp
+from miasm.expression.expression import ExprId, ExprMem
 
 
 class SymbolicStateCTypes(StateEngine):
diff --git a/miasm2/ir/translators/C.py b/miasm/ir/translators/C.py
index e44e859f..9a96487a 100644
--- a/miasm2/ir/translators/C.py
+++ b/miasm/ir/translators/C.py
@@ -1,6 +1,6 @@
-from miasm2.ir.translators.translator import Translator
-from miasm2.expression.modint import size2mask
-from miasm2.expression.expression import ExprInt, ExprCond, ExprCompose, \
+from miasm.ir.translators.translator import Translator
+from miasm.expression.modint import size2mask
+from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
     TOK_EQUAL, \
     TOK_INF_SIGNED, TOK_INF_UNSIGNED, \
     TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED
diff --git a/miasm/ir/translators/__init__.py b/miasm/ir/translators/__init__.py
new file mode 100644
index 00000000..45e19803
--- /dev/null
+++ b/miasm/ir/translators/__init__.py
@@ -0,0 +1,13 @@
+"""IR Translators"""
+from miasm.ir.translators.translator import Translator
+import miasm.ir.translators.C
+import miasm.ir.translators.python
+import miasm.ir.translators.miasm_ir
+import miasm.ir.translators.smt2
+try:
+    import miasm.ir.translators.z3_ir
+except ImportError:
+    # Nothing to do, z3 not available
+    pass
+
+__all__ = ["Translator"]
diff --git a/miasm2/ir/translators/miasm.py b/miasm/ir/translators/miasm_ir.py
index e93e9499..a460d446 100644
--- a/miasm2/ir/translators/miasm.py
+++ b/miasm/ir/translators/miasm_ir.py
@@ -1,5 +1,5 @@
 from builtins import map
-from miasm2.ir.translators.translator import Translator
+from miasm.ir.translators.translator import Translator
 
 
 class TranslatorMiasm(Translator):
diff --git a/miasm2/ir/translators/python.py b/miasm/ir/translators/python.py
index 4b1b4b52..0da2318d 100644
--- a/miasm2/ir/translators/python.py
+++ b/miasm/ir/translators/python.py
@@ -1,6 +1,6 @@
 from builtins import map
-from miasm2.expression.expression import ExprInt
-from miasm2.ir.translators.translator import Translator
+from miasm.expression.expression import ExprInt
+from miasm.ir.translators.translator import Translator
 
 
 class TranslatorPython(Translator):
diff --git a/miasm2/ir/translators/smt2.py b/miasm/ir/translators/smt2.py
index 7b619457..61a4962f 100644
--- a/miasm2/ir/translators/smt2.py
+++ b/miasm/ir/translators/smt2.py
@@ -2,8 +2,8 @@ from builtins import map
 from builtins import range
 import logging
 
-from miasm2.ir.translators.translator import Translator
-from miasm2.expression.smt2_helper import *
+from miasm.ir.translators.translator import Translator
+from miasm.expression.smt2_helper import *
 
 log = logging.getLogger("translator_smt2")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/ir/translators/translator.py b/miasm/ir/translators/translator.py
index 65875072..c9368f09 100644
--- a/miasm2/ir/translators/translator.py
+++ b/miasm/ir/translators/translator.py
@@ -1,7 +1,7 @@
 from future.utils import viewitems
 
-import miasm2.expression.expression as m2_expr
-from miasm2.core.utils import BoundedDict
+import miasm.expression.expression as m2_expr
+from miasm.core.utils import BoundedDict
 
 
 class Translator(object):
diff --git a/miasm2/ir/translators/z3_ir.py b/miasm/ir/translators/z3_ir.py
index 902e72bd..7dc77cfc 100644
--- a/miasm2/ir/translators/z3_ir.py
+++ b/miasm/ir/translators/z3_ir.py
@@ -6,7 +6,7 @@ import logging
 # Raise an ImportError if z3 is not available WITHOUT actually importing it
 imp.find_module("z3")
 
-from miasm2.ir.translators.translator import Translator
+from miasm.ir.translators.translator import Translator
 
 log = logging.getLogger("translator_z3")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/jitter/JitCore.c b/miasm/jitter/JitCore.c
index ae5af293..ae5af293 100644
--- a/miasm2/jitter/JitCore.c
+++ b/miasm/jitter/JitCore.c
diff --git a/miasm2/jitter/JitCore.h b/miasm/jitter/JitCore.h
index 15efc7d2..15efc7d2 100644
--- a/miasm2/jitter/JitCore.h
+++ b/miasm/jitter/JitCore.h
diff --git a/miasm2/jitter/Jitgcc.c b/miasm/jitter/Jitgcc.c
index 0a39c998..0a39c998 100644
--- a/miasm2/jitter/Jitgcc.c
+++ b/miasm/jitter/Jitgcc.c
diff --git a/miasm2/jitter/Jitllvm.c b/miasm/jitter/Jitllvm.c
index efe5250f..efe5250f 100644
--- a/miasm2/jitter/Jitllvm.c
+++ b/miasm/jitter/Jitllvm.c
diff --git a/miasm2/jitter/__init__.py b/miasm/jitter/__init__.py
index 460e327d..460e327d 100644
--- a/miasm2/jitter/__init__.py
+++ b/miasm/jitter/__init__.py
diff --git a/miasm2/jitter/arch/JitCore_aarch64.c b/miasm/jitter/arch/JitCore_aarch64.c
index 9e1a870e..9e1a870e 100644
--- a/miasm2/jitter/arch/JitCore_aarch64.c
+++ b/miasm/jitter/arch/JitCore_aarch64.c
diff --git a/miasm2/jitter/arch/JitCore_aarch64.h b/miasm/jitter/arch/JitCore_aarch64.h
index fa958244..fa958244 100644
--- a/miasm2/jitter/arch/JitCore_aarch64.h
+++ b/miasm/jitter/arch/JitCore_aarch64.h
diff --git a/miasm2/jitter/arch/JitCore_arm.c b/miasm/jitter/arch/JitCore_arm.c
index 64f30cf4..64f30cf4 100644
--- a/miasm2/jitter/arch/JitCore_arm.c
+++ b/miasm/jitter/arch/JitCore_arm.c
diff --git a/miasm2/jitter/arch/JitCore_arm.h b/miasm/jitter/arch/JitCore_arm.h
index 67a1096a..67a1096a 100644
--- a/miasm2/jitter/arch/JitCore_arm.h
+++ b/miasm/jitter/arch/JitCore_arm.h
diff --git a/miasm2/jitter/arch/JitCore_mep.c b/miasm/jitter/arch/JitCore_mep.c
index 6e7f1767..6e7f1767 100644
--- a/miasm2/jitter/arch/JitCore_mep.c
+++ b/miasm/jitter/arch/JitCore_mep.c
diff --git a/miasm2/jitter/arch/JitCore_mep.h b/miasm/jitter/arch/JitCore_mep.h
index 0148cd13..bcf2283e 100644
--- a/miasm2/jitter/arch/JitCore_mep.h
+++ b/miasm/jitter/arch/JitCore_mep.h
@@ -1,7 +1,7 @@
 // Inspired from JitCore_msp430.h
 
 typedef struct {
-	/* miasm2 flags */
+	/* miasm flags */
 	uint32_t exception_flags;
 
 	/* gpregs */
@@ -57,7 +57,7 @@ typedef struct {
 	uint32_t S31;
 	uint32_t S32;
 
-	/* miasm2 specific regs */
+	/* miasm specific regs */
 	uint32_t PC_end;
 	uint32_t RPE_instr_count;
 	uint32_t RPC_current;
diff --git a/miasm2/jitter/arch/JitCore_mips32.c b/miasm/jitter/arch/JitCore_mips32.c
index 1455fec9..1455fec9 100644
--- a/miasm2/jitter/arch/JitCore_mips32.c
+++ b/miasm/jitter/arch/JitCore_mips32.c
diff --git a/miasm2/jitter/arch/JitCore_mips32.h b/miasm/jitter/arch/JitCore_mips32.h
index e20d5133..e20d5133 100644
--- a/miasm2/jitter/arch/JitCore_mips32.h
+++ b/miasm/jitter/arch/JitCore_mips32.h
diff --git a/miasm2/jitter/arch/JitCore_msp430.c b/miasm/jitter/arch/JitCore_msp430.c
index c21296c7..c21296c7 100644
--- a/miasm2/jitter/arch/JitCore_msp430.c
+++ b/miasm/jitter/arch/JitCore_msp430.c
diff --git a/miasm2/jitter/arch/JitCore_msp430.h b/miasm/jitter/arch/JitCore_msp430.h
index 1c802e9e..1c802e9e 100644
--- a/miasm2/jitter/arch/JitCore_msp430.h
+++ b/miasm/jitter/arch/JitCore_msp430.h
diff --git a/miasm2/jitter/arch/JitCore_ppc32.c b/miasm/jitter/arch/JitCore_ppc32.c
index 8a1bb79e..8a1bb79e 100644
--- a/miasm2/jitter/arch/JitCore_ppc32.c
+++ b/miasm/jitter/arch/JitCore_ppc32.c
diff --git a/miasm2/jitter/arch/JitCore_ppc32.h b/miasm/jitter/arch/JitCore_ppc32.h
index f2a5200e..f2a5200e 100644
--- a/miasm2/jitter/arch/JitCore_ppc32.h
+++ b/miasm/jitter/arch/JitCore_ppc32.h
diff --git a/miasm2/jitter/arch/JitCore_ppc32_regs.h b/miasm/jitter/arch/JitCore_ppc32_regs.h
index d15b5e51..d15b5e51 100644
--- a/miasm2/jitter/arch/JitCore_ppc32_regs.h
+++ b/miasm/jitter/arch/JitCore_ppc32_regs.h
diff --git a/miasm2/jitter/arch/JitCore_x86.c b/miasm/jitter/arch/JitCore_x86.c
index 50ce6bd5..50ce6bd5 100644
--- a/miasm2/jitter/arch/JitCore_x86.c
+++ b/miasm/jitter/arch/JitCore_x86.c
diff --git a/miasm2/jitter/arch/JitCore_x86.h b/miasm/jitter/arch/JitCore_x86.h
index 27d94d7c..27d94d7c 100644
--- a/miasm2/jitter/arch/JitCore_x86.h
+++ b/miasm/jitter/arch/JitCore_x86.h
diff --git a/miasm2/jitter/arch/__init__.py b/miasm/jitter/arch/__init__.py
index e69de29b..e69de29b 100644
--- a/miasm2/jitter/arch/__init__.py
+++ b/miasm/jitter/arch/__init__.py
diff --git a/miasm2/jitter/bn.c b/miasm/jitter/bn.c
index dd4f34ef..dd4f34ef 100644
--- a/miasm2/jitter/bn.c
+++ b/miasm/jitter/bn.c
diff --git a/miasm2/jitter/bn.h b/miasm/jitter/bn.h
index 1aa6b432..1aa6b432 100644
--- a/miasm2/jitter/bn.h
+++ b/miasm/jitter/bn.h
diff --git a/miasm2/jitter/codegen.py b/miasm/jitter/codegen.py
index bdd9e570..0f40fb6e 100644
--- a/miasm2/jitter/codegen.py
+++ b/miasm/jitter/codegen.py
@@ -6,13 +6,13 @@ from builtins import zip
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import Expr, ExprId, ExprLoc, ExprInt, \
+from miasm.expression.expression import Expr, ExprId, ExprLoc, ExprInt, \
     ExprMem, ExprCond, LocKey
-from miasm2.ir.ir import IRBlock, AssignBlock
+from miasm.ir.ir import IRBlock, AssignBlock
 
-from miasm2.ir.translators.C import TranslatorC
-from miasm2.core.asmblock import AsmBlockBad
-from miasm2.expression.simplifications import expr_simp_high_to_explicit
+from miasm.ir.translators.C import TranslatorC
+from miasm.core.asmblock import AsmBlockBad
+from miasm.expression.simplifications import expr_simp_high_to_explicit
 
 TRANSLATOR_NO_SYMBOL = TranslatorC(loc_db=None)
 
diff --git a/miasm2/jitter/compat_py23.h b/miasm/jitter/compat_py23.h
index bc66d80b..bc66d80b 100644
--- a/miasm2/jitter/compat_py23.h
+++ b/miasm/jitter/compat_py23.h
diff --git a/miasm2/jitter/csts.py b/miasm/jitter/csts.py
index 9c9919fc..9c9919fc 100644
--- a/miasm2/jitter/csts.py
+++ b/miasm/jitter/csts.py
diff --git a/miasm2/jitter/emulatedsymbexec.py b/miasm/jitter/emulatedsymbexec.py
index 3ccce522..4355c0b9 100644
--- a/miasm2/jitter/emulatedsymbexec.py
+++ b/miasm/jitter/emulatedsymbexec.py
@@ -1,6 +1,6 @@
-from miasm2.core.utils import decode_hex, encode_hex
-import miasm2.expression.expression as m2_expr
-from miasm2.ir.symbexec import SymbolicExecutionEngine
+from miasm.core.utils import decode_hex, encode_hex
+import miasm.expression.expression as m2_expr
+from miasm.ir.symbexec import SymbolicExecutionEngine
 
 
 class EmulatedSymbExec(SymbolicExecutionEngine):
@@ -120,7 +120,7 @@ class EmulatedSymbExec(SymbolicExecutionEngine):
         return e_s(m2_expr.ExprInt(segmaddr, expr.size) + expr.args[1])
 
     def _simp_handle_x86_cpuid(self, e_s, expr):
-        """From miasm2/jitter/op_semantics.h: x86_cpuid"""
+        """From miasm/jitter/op_semantics.h: x86_cpuid"""
         if expr.op != "x86_cpuid":
             return expr
 
diff --git a/miasm2/jitter/jitcore.py b/miasm/jitter/jitcore.py
index 33efdfd9..ebda656f 100644
--- a/miasm2/jitter/jitcore.py
+++ b/miasm/jitter/jitcore.py
@@ -21,11 +21,11 @@ import warnings
 
 from future.utils import viewvalues
 
-from miasm2.core.asmblock import disasmEngine, AsmBlockBad
-from miasm2.core.interval import interval
-from miasm2.core.utils import BoundedDict
-from miasm2.expression.expression import LocKey
-from miasm2.jitter.csts import *
+from miasm.core.asmblock import disasmEngine, AsmBlockBad
+from miasm.core.interval import interval
+from miasm.core.utils import BoundedDict
+from miasm.expression.expression import LocKey
+from miasm.jitter.csts import *
 
 class JitCore(object):
 
diff --git a/miasm2/jitter/jitcore_cc_base.py b/miasm/jitter/jitcore_cc_base.py
index 997d6330..4ec0e358 100644
--- a/miasm2/jitter/jitcore_cc_base.py
+++ b/miasm/jitter/jitcore_cc_base.py
@@ -6,8 +6,8 @@ import platform
 import sysconfig
 from distutils.sysconfig import get_python_inc
 
-from miasm2.jitter.jitcore import JitCore
-from miasm2.core.utils import keydefaultdict
+from miasm.jitter.jitcore import JitCore
+from miasm.core.utils import keydefaultdict
 
 is_win = platform.system() == "Windows"
 
diff --git a/miasm2/jitter/jitcore_gcc.py b/miasm/jitter/jitcore_gcc.py
index 5fd54c3d..292143a2 100644
--- a/miasm2/jitter/jitcore_gcc.py
+++ b/miasm/jitter/jitcore_gcc.py
@@ -8,8 +8,8 @@ import platform
 import sysconfig
 from subprocess import check_call
 from distutils.sysconfig import get_python_inc
-from miasm2.jitter import Jitgcc
-from miasm2.jitter.jitcore_cc_base import JitCore_Cc_Base, gen_core
+from miasm.jitter import Jitgcc
+from miasm.jitter.jitcore_cc_base import JitCore_Cc_Base, gen_core
 
 is_win = platform.system() == "Windows"
 
diff --git a/miasm2/jitter/jitcore_llvm.py b/miasm/jitter/jitcore_llvm.py
index d017e122..46e93282 100644
--- a/miasm2/jitter/jitcore_llvm.py
+++ b/miasm/jitter/jitcore_llvm.py
@@ -4,9 +4,9 @@ import importlib
 import tempfile
 import sysconfig
 
-from miasm2.jitter.llvmconvert import *
-import miasm2.jitter.jitcore as jitcore
-from miasm2.jitter import Jitllvm
+from miasm.jitter.llvmconvert import *
+import miasm.jitter.jitcore as jitcore
+from miasm.jitter import Jitllvm
 import platform
 
 is_win = platform.system() == "Windows"
@@ -78,7 +78,7 @@ class JitCore_LLVM(jitcore.JitCore):
         self.arch = self.ir_arch.arch
 
         # Get the correspondence between registers and vmcpu struct
-        mod_name = "miasm2.jitter.arch.JitCore_%s" % (self.ir_arch.arch.name)
+        mod_name = "miasm.jitter.arch.JitCore_%s" % (self.ir_arch.arch.name)
         mod = importlib.import_module(mod_name)
         self.context.set_vmcpu(mod.get_gpreg_offset_all())
 
diff --git a/miasm2/jitter/jitcore_python.py b/miasm/jitter/jitcore_python.py
index 4262c334..e1e905f3 100644
--- a/miasm2/jitter/jitcore_python.py
+++ b/miasm/jitter/jitcore_python.py
@@ -1,10 +1,10 @@
 from __future__ import print_function
 from builtins import zip
-import miasm2.jitter.jitcore as jitcore
-from miasm2.expression.expression import ExprInt, ExprLoc
-import miasm2.jitter.csts as csts
-from miasm2.expression.simplifications import expr_simp_explicit
-from miasm2.jitter.emulatedsymbexec import EmulatedSymbExec
+import miasm.jitter.jitcore as jitcore
+from miasm.expression.expression import ExprInt, ExprLoc
+import miasm.jitter.csts as csts
+from miasm.expression.simplifications import expr_simp_explicit
+from miasm.jitter.emulatedsymbexec import EmulatedSymbExec
 
 ################################################################################
 #                              Python jitter Core                              #
@@ -43,14 +43,14 @@ class JitCore_Python(jitcore.JitCore):
         arch = self.ir_arch.arch
         has_delayslot = False
         if arch.name == "mips32":
-            from miasm2.arch.mips32.jit import mipsCGen
+            from miasm.arch.mips32.jit import mipsCGen
             cgen_class = mipsCGen
             has_delayslot = True
         elif arch.name == "arm":
-            from miasm2.arch.arm.jit import arm_CGen
+            from miasm.arch.arm.jit import arm_CGen
             cgen_class = arm_CGen
         else:
-            from miasm2.jitter.codegen import CGen
+            from miasm.jitter.codegen import CGen
             cgen_class = CGen
         return cgen_class(self.ir_arch), has_delayslot
 
diff --git a/miasm2/jitter/jitload.py b/miasm/jitter/jitload.py
index 3f3cf10f..292cf498 100644
--- a/miasm2/jitter/jitload.py
+++ b/miasm/jitter/jitload.py
@@ -5,12 +5,12 @@ from collections import Sequence, namedtuple
 
 from future.utils import viewitems
 
-from miasm2.jitter.csts import *
-from miasm2.core.utils import *
-from miasm2.core.bin_stream import bin_stream_vm
-from miasm2.jitter.emulatedsymbexec import EmulatedSymbExec
-from miasm2.jitter.codegen import CGen
-from miasm2.jitter.jitcore_cc_base import JitCore_Cc_Base
+from miasm.jitter.csts import *
+from miasm.core.utils import *
+from miasm.core.bin_stream import bin_stream_vm
+from miasm.jitter.emulatedsymbexec import EmulatedSymbExec
+from miasm.jitter.codegen import CGen
+from miasm.jitter.jitcore_cc_base import JitCore_Cc_Base
 
 hnd = logging.StreamHandler()
 hnd.setFormatter(logging.Formatter("[%(levelname)s]: %(message)s"))
@@ -22,7 +22,7 @@ log_func.addHandler(hnd)
 log_func.setLevel(logging.CRITICAL)
 
 try:
-    from miasm2.jitter import VmMngr
+    from miasm.jitter import VmMngr
 except ImportError:
     log.error('cannot import VmMngr')
 
@@ -190,22 +190,22 @@ class Jitter(object):
 
         try:
             if arch_name == "x86":
-                from miasm2.jitter.arch import JitCore_x86 as jcore
+                from miasm.jitter.arch import JitCore_x86 as jcore
             elif arch_name == "arm":
-                from miasm2.jitter.arch import JitCore_arm as jcore
+                from miasm.jitter.arch import JitCore_arm as jcore
             elif arch_name == "armt":
-                from miasm2.jitter.arch import JitCore_arm as jcore
+                from miasm.jitter.arch import JitCore_arm as jcore
                 ir_arch.arch.name = 'arm'
             elif arch_name == "aarch64":
-                from miasm2.jitter.arch import JitCore_aarch64 as jcore
+                from miasm.jitter.arch import JitCore_aarch64 as jcore
             elif arch_name == "msp430":
-                from miasm2.jitter.arch import JitCore_msp430 as jcore
+                from miasm.jitter.arch import JitCore_msp430 as jcore
             elif arch_name == "mips32":
-                from miasm2.jitter.arch import JitCore_mips32 as jcore
+                from miasm.jitter.arch import JitCore_mips32 as jcore
             elif arch_name == "ppc32":
-                from miasm2.jitter.arch import JitCore_ppc32 as jcore
+                from miasm.jitter.arch import JitCore_ppc32 as jcore
             elif arch_name == "mep":
-                from miasm2.jitter.arch import JitCore_mep as jcore
+                from miasm.jitter.arch import JitCore_mep as jcore
             else:
                 raise ValueError("unknown jit arch: %s" % arch_name)
         except ImportError:
@@ -224,11 +224,11 @@ class Jitter(object):
 
         try:
             if jit_type == "llvm":
-                from miasm2.jitter.jitcore_llvm import JitCore_LLVM as JitCore
+                from miasm.jitter.jitcore_llvm import JitCore_LLVM as JitCore
             elif jit_type == "python":
-                from miasm2.jitter.jitcore_python import JitCore_Python as JitCore
+                from miasm.jitter.jitcore_python import JitCore_Python as JitCore
             elif jit_type == "gcc":
-                from miasm2.jitter.jitcore_gcc import JitCore_Gcc as JitCore
+                from miasm.jitter.jitcore_gcc import JitCore_Gcc as JitCore
             else:
                 raise ValueError("Unknown jitter %s" % jit_type)
         except ImportError:
diff --git a/miasm2/jitter/llvmconvert.py b/miasm/jitter/llvmconvert.py
index bea8cd36..d0e0407b 100644
--- a/miasm2/jitter/llvmconvert.py
+++ b/miasm/jitter/llvmconvert.py
@@ -20,16 +20,16 @@ from builtins import int as int_types
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprMem, ExprSlice, \
+from miasm.expression.expression import ExprId, ExprInt, ExprMem, ExprSlice, \
     ExprCond, ExprLoc, ExprOp, ExprCompose, LocKey, Expr, \
     TOK_EQUAL, \
     TOK_INF_SIGNED, TOK_INF_UNSIGNED, \
     TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED
 
-import miasm2.jitter.csts as m2_csts
-import miasm2.core.asmblock as m2_asmblock
-from miasm2.jitter.codegen import CGen, Attributes
-from miasm2.expression.expression_helper import possible_values
+import miasm.jitter.csts as m2_csts
+import miasm.core.asmblock as m2_asmblock
+from miasm.jitter.codegen import CGen, Attributes
+from miasm.expression.expression_helper import possible_values
 
 
 class LLVMType(llvm_ir.Type):
@@ -263,11 +263,11 @@ class LLVMContext_JIT(LLVMContext):
             self.PC = self.ir_arch.pc
             self.logging_func = "dump_gpregs"
         if arch.name == "mips32":
-            from miasm2.arch.mips32.jit import mipsCGen
+            from miasm.arch.mips32.jit import mipsCGen
             self.cgen_class = mipsCGen
             self.has_delayslot = True
         elif arch.name == "arm":
-            from miasm2.arch.arm.jit import arm_CGen
+            from miasm.arch.arm.jit import arm_CGen
             self.cgen_class = arm_CGen
             self.has_delayslot = False
         else:
diff --git a/miasm2/jitter/loader/__init__.py b/miasm/jitter/loader/__init__.py
index e69de29b..e69de29b 100644
--- a/miasm2/jitter/loader/__init__.py
+++ b/miasm/jitter/loader/__init__.py
diff --git a/miasm2/jitter/loader/elf.py b/miasm/jitter/loader/elf.py
index 1044fe73..b36638f3 100644
--- a/miasm2/jitter/loader/elf.py
+++ b/miasm/jitter/loader/elf.py
@@ -7,9 +7,9 @@ from elfesteem import cstruct
 from elfesteem import *
 import elfesteem.elf as elf_csts
 
-from miasm2.jitter.csts import *
-from miasm2.jitter.loader.utils import canon_libname_libfunc, libimp
-from miasm2.core.interval import interval
+from miasm.jitter.csts import *
+from miasm.jitter.loader.utils import canon_libname_libfunc, libimp
+from miasm.core.interval import interval
 
 import logging
 
diff --git a/miasm2/jitter/loader/pe.py b/miasm/jitter/loader/pe.py
index a8e6ec0d..7145a817 100644
--- a/miasm2/jitter/loader/pe.py
+++ b/miasm/jitter/loader/pe.py
@@ -10,8 +10,8 @@ from elfesteem import pe
 from elfesteem import cstruct
 from elfesteem import *
 
-from miasm2.jitter.csts import *
-from miasm2.jitter.loader.utils import canon_libname_libfunc, libimp
+from miasm.jitter.csts import *
+from miasm.jitter.loader.utils import canon_libname_libfunc, libimp
 
 log = logging.getLogger('loader_pe')
 hnd = logging.StreamHandler()
diff --git a/miasm2/jitter/loader/utils.py b/miasm/jitter/loader/utils.py
index 80e19310..a32729e1 100644
--- a/miasm2/jitter/loader/utils.py
+++ b/miasm/jitter/loader/utils.py
@@ -3,7 +3,7 @@ import logging
 
 from future.utils import viewitems, viewvalues
 
-from miasm2.core.utils import force_bytes
+from miasm.core.utils import force_bytes
 
 log = logging.getLogger('loader_common')
 hnd = logging.StreamHandler()
diff --git a/miasm2/jitter/op_semantics.c b/miasm/jitter/op_semantics.c
index 46e6cca1..46e6cca1 100644
--- a/miasm2/jitter/op_semantics.c
+++ b/miasm/jitter/op_semantics.c
diff --git a/miasm2/jitter/op_semantics.h b/miasm/jitter/op_semantics.h
index 690cfb35..690cfb35 100644
--- a/miasm2/jitter/op_semantics.h
+++ b/miasm/jitter/op_semantics.h
diff --git a/miasm2/jitter/queue.h b/miasm/jitter/queue.h
index 0caf72fb..0caf72fb 100644
--- a/miasm2/jitter/queue.h
+++ b/miasm/jitter/queue.h
diff --git a/miasm2/jitter/vm_mngr.c b/miasm/jitter/vm_mngr.c
index bd1de2f4..bd1de2f4 100644
--- a/miasm2/jitter/vm_mngr.c
+++ b/miasm/jitter/vm_mngr.c
diff --git a/miasm2/jitter/vm_mngr.h b/miasm/jitter/vm_mngr.h
index 660e6998..660e6998 100644
--- a/miasm2/jitter/vm_mngr.h
+++ b/miasm/jitter/vm_mngr.h
diff --git a/miasm2/jitter/vm_mngr_py.c b/miasm/jitter/vm_mngr_py.c
index 1173146b..1173146b 100644
--- a/miasm2/jitter/vm_mngr_py.c
+++ b/miasm/jitter/vm_mngr_py.c
diff --git a/miasm2/jitter/vm_mngr_py.h b/miasm/jitter/vm_mngr_py.h
index e2e43c65..e2e43c65 100644
--- a/miasm2/jitter/vm_mngr_py.h
+++ b/miasm/jitter/vm_mngr_py.h
diff --git a/miasm2/os_dep/__init__.py b/miasm/os_dep/__init__.py
index 6aa660d8..6aa660d8 100644
--- a/miasm2/os_dep/__init__.py
+++ b/miasm/os_dep/__init__.py
diff --git a/miasm2/os_dep/common.py b/miasm/os_dep/common.py
index ed68185f..87602b3c 100644
--- a/miasm2/os_dep/common.py
+++ b/miasm/os_dep/common.py
@@ -2,10 +2,10 @@ import os
 
 from future.utils import viewitems
 
-from miasm2.core.utils import force_bytes
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.core.utils import get_caller_name
-from miasm2.core.utils import pck64, upck64
+from miasm.core.utils import force_bytes
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.core.utils import get_caller_name
+from miasm.core.utils import pck64, upck64
 
 BASE_SB_PATH = "file_sb"
 
diff --git a/miasm2/os_dep/linux/__init__.py b/miasm/os_dep/linux/__init__.py
index 4434ce50..4434ce50 100644
--- a/miasm2/os_dep/linux/__init__.py
+++ b/miasm/os_dep/linux/__init__.py
diff --git a/miasm2/os_dep/linux/environment.py b/miasm/os_dep/linux/environment.py
index ae9c3317..8826abb7 100644
--- a/miasm2/os_dep/linux/environment.py
+++ b/miasm/os_dep/linux/environment.py
@@ -7,8 +7,8 @@ import termios
 
 from future.utils import viewitems
 
-from miasm2.core.interval import interval
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.core.interval import interval
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 
 StatInfo = namedtuple("StatInfo", [
diff --git a/miasm2/os_dep/linux/syscall.py b/miasm/os_dep/linux/syscall.py
index cd4de49f..1edf72c4 100644
--- a/miasm2/os_dep/linux/syscall.py
+++ b/miasm/os_dep/linux/syscall.py
@@ -5,7 +5,7 @@ import logging
 import struct
 import termios
 
-from miasm2.jitter.csts import EXCEPT_PRIV_INSN, EXCEPT_INT_XX
+from miasm.jitter.csts import EXCEPT_PRIV_INSN, EXCEPT_INT_XX
 
 log = logging.getLogger('syscalls')
 hnd = logging.StreamHandler()
diff --git a/miasm2/os_dep/linux_stdlib.py b/miasm/os_dep/linux_stdlib.py
index f12284ee..b2836881 100644
--- a/miasm2/os_dep/linux_stdlib.py
+++ b/miasm/os_dep/linux_stdlib.py
@@ -10,9 +10,9 @@ try:
 except AttributeError:
     pass
 
-from miasm2.core.utils import int_to_byte, cmp_elts
-from miasm2.os_dep.common import heap
-from miasm2.os_dep.common import get_fmt_args as _get_fmt_args
+from miasm.core.utils import int_to_byte, cmp_elts
+from miasm.os_dep.common import heap
+from miasm.os_dep.common import get_fmt_args as _get_fmt_args
 
 
 class c_linobjs(object):
diff --git a/miasm2/os_dep/win_32_structs.py b/miasm/os_dep/win_32_structs.py
index ffe6afc4..fc9c62ea 100644
--- a/miasm2/os_dep/win_32_structs.py
+++ b/miasm/os_dep/win_32_structs.py
@@ -1,4 +1,4 @@
-from miasm2.core.types import MemStruct, Num, Ptr, Str, \
+from miasm.core.types import MemStruct, Num, Ptr, Str, \
     Array, RawStruct, Union, \
     BitField, Self, Void, Bits, \
     set_allocator, MemUnion, Struct
diff --git a/miasm2/os_dep/win_api_x86_32.py b/miasm/os_dep/win_api_x86_32.py
index e6ef3601..ebf40cb0 100644
--- a/miasm2/os_dep/win_api_x86_32.py
+++ b/miasm/os_dep/win_api_x86_32.py
@@ -35,12 +35,12 @@ try:
 except ImportError:
     print("cannot find crypto, skipping")
 
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE, PAGE_EXEC
-from miasm2.core.utils import pck16, pck32, hexdump, whoami
-from miasm2.os_dep.common import heap, windows_to_sbpath
-from miasm2.os_dep.common import set_str_unic, set_str_ansi
-from miasm2.os_dep.common import get_fmt_args as _get_fmt_args
-from miasm2.os_dep.win_api_x86_32_seh import tib_address
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE, PAGE_EXEC
+from miasm.core.utils import pck16, pck32, hexdump, whoami
+from miasm.os_dep.common import heap, windows_to_sbpath
+from miasm.os_dep.common import set_str_unic, set_str_ansi
+from miasm.os_dep.common import get_fmt_args as _get_fmt_args
+from miasm.os_dep.win_api_x86_32_seh import tib_address
 
 log = logging.getLogger("win_api_x86_32")
 console_handler = logging.StreamHandler()
diff --git a/miasm2/os_dep/win_api_x86_32_seh.py b/miasm/os_dep/win_api_x86_32_seh.py
index 27808d83..90a68eec 100644
--- a/miasm2/os_dep/win_api_x86_32_seh.py
+++ b/miasm/os_dep/win_api_x86_32_seh.py
@@ -25,11 +25,11 @@ from future.utils import viewitems
 
 from elfesteem import pe_init
 
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.core.utils import pck32
-import miasm2.arch.x86.regs as x86_regs
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.core.utils import pck32
+import miasm.arch.x86.regs as x86_regs
 
-from miasm2.os_dep.win_32_structs import LdrDataEntry, ListEntry, \
+from miasm.os_dep.win_32_structs import LdrDataEntry, ListEntry, \
     TEB, NT_TIB, PEB, PEB_LDR_DATA, ContextException, \
     EXCEPTION_REGISTRATION_RECORD, EXCEPTION_RECORD
 
diff --git a/miasm2/ir/translators/__init__.py b/miasm2/ir/translators/__init__.py
deleted file mode 100644
index d3678ffc..00000000
--- a/miasm2/ir/translators/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""IR Translators"""
-from miasm2.ir.translators.translator import Translator
-import miasm2.ir.translators.C
-import miasm2.ir.translators.python
-import miasm2.ir.translators.miasm
-import miasm2.ir.translators.smt2
-try:
-    import miasm2.ir.translators.z3_ir
-except ImportError:
-    # Nothing to do, z3 not available
-    pass
-
-__all__ = ["Translator"]
diff --git a/setup.py b/setup.py
index 83e4608e..c52e1f9e 100755
--- a/setup.py
+++ b/setup.py
@@ -13,117 +13,117 @@ is_win = platform.system() == "Windows"
 
 def buil_all():
     packages=[
-        "miasm2",
-        "miasm2/arch",
-        "miasm2/arch/x86",
-        "miasm2/arch/arm",
-        "miasm2/arch/aarch64",
-        "miasm2/arch/msp430",
-        "miasm2/arch/mep",
-        "miasm2/arch/sh4",
-        "miasm2/arch/mips32",
-        "miasm2/arch/ppc",
-        "miasm2/core",
-        "miasm2/expression",
-        "miasm2/ir",
-        "miasm2/ir/translators",
-        "miasm2/analysis",
-        "miasm2/os_dep",
-        "miasm2/os_dep/linux",
-        "miasm2/jitter",
-        "miasm2/jitter/arch",
-        "miasm2/jitter/loader",
+        "miasm",
+        "miasm/arch",
+        "miasm/arch/x86",
+        "miasm/arch/arm",
+        "miasm/arch/aarch64",
+        "miasm/arch/msp430",
+        "miasm/arch/mep",
+        "miasm/arch/sh4",
+        "miasm/arch/mips32",
+        "miasm/arch/ppc",
+        "miasm/core",
+        "miasm/expression",
+        "miasm/ir",
+        "miasm/ir/translators",
+        "miasm/analysis",
+        "miasm/os_dep",
+        "miasm/os_dep/linux",
+        "miasm/jitter",
+        "miasm/jitter/arch",
+        "miasm/jitter/loader",
     ]
     ext_modules_all = [
         Extension(
-            "miasm2.jitter.VmMngr",
+            "miasm.jitter.VmMngr",
             [
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/vm_mngr_py.c",
-                "miasm2/jitter/bn.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/vm_mngr_py.c",
+                "miasm/jitter/bn.c",
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_x86",
+            "miasm.jitter.arch.JitCore_x86",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_x86.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_x86.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_arm",
+            "miasm.jitter.arch.JitCore_arm",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_arm.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_arm.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_aarch64",
+            "miasm.jitter.arch.JitCore_aarch64",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_aarch64.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_aarch64.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_msp430",
+            "miasm.jitter.arch.JitCore_msp430",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_msp430.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_msp430.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_mep",
+            "miasm.jitter.arch.JitCore_mep",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_mep.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_mep.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_mips32",
+            "miasm.jitter.arch.JitCore_mips32",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_mips32.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_mips32.c"
             ]
         ),
         Extension(
-            "miasm2.jitter.arch.JitCore_ppc32",
+            "miasm.jitter.arch.JitCore_ppc32",
             [
-                "miasm2/jitter/JitCore.c",
-                "miasm2/jitter/vm_mngr.c",
-                "miasm2/jitter/op_semantics.c",
-                "miasm2/jitter/bn.c",
-                "miasm2/jitter/arch/JitCore_ppc32.c"
+                "miasm/jitter/JitCore.c",
+                "miasm/jitter/vm_mngr.c",
+                "miasm/jitter/op_semantics.c",
+                "miasm/jitter/bn.c",
+                "miasm/jitter/arch/JitCore_ppc32.c"
             ],
             depends=[
-                "miasm2/jitter/arch/JitCore_ppc32.h",
-                "miasm2/jitter/arch/JitCore_ppc32_regs.h",
-                "miasm2/jitter/bn.h",
+                "miasm/jitter/arch/JitCore_ppc32.h",
+                "miasm/jitter/arch/JitCore_ppc32_regs.h",
+                "miasm/jitter/bn.h",
             ]
         ),
-        Extension("miasm2.jitter.Jitllvm",
-                  ["miasm2/jitter/Jitllvm.c",
-                   "miasm2/jitter/bn.c",
+        Extension("miasm.jitter.Jitllvm",
+                  ["miasm/jitter/Jitllvm.c",
+                   "miasm/jitter/bn.c",
                   ]),
-        Extension("miasm2.jitter.Jitgcc",
-                  ["miasm2/jitter/Jitgcc.c",
-                   "miasm2/jitter/bn.c",
+        Extension("miasm.jitter.Jitgcc",
+                  ["miasm/jitter/Jitgcc.c",
+                   "miasm/jitter/bn.c",
                   ]),
         ]
 
@@ -143,7 +143,7 @@ def buil_all():
                 version = "2.0",
                 packages = packages,
                 package_data = {
-                    "miasm2":[
+                    "miasm":[
                         "jitter/*.h",
                         "jitter/arch/*.h",
                     ]
@@ -199,7 +199,7 @@ def buil_all():
         jitters = []
         for lib in libs:
             filename = os.path.basename(lib)
-            dst = os.path.join(build_base, lib_dirname, "miasm2", "jitter")
+            dst = os.path.join(build_base, lib_dirname, "miasm", "jitter")
             if filename not in ["VmMngr.lib", "Jitgcc.lib", "Jitllvm.lib"]:
                 dst = os.path.join(dst, "arch")
             dst = os.path.join(dst, filename)
diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py
index 288f4bd6..ecca3eac 100644
--- a/test/analysis/data_flow.py
+++ b/test/analysis/data_flow.py
@@ -3,11 +3,11 @@ from __future__ import print_function
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem
-from miasm2.core.locationdb import LocationDB
-from miasm2.analysis.data_flow import *
-from miasm2.ir.analysis import ira
-from miasm2.ir.ir import IRBlock, AssignBlock
+from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem
+from miasm.core.locationdb import LocationDB
+from miasm.analysis.data_flow import *
+from miasm.ir.analysis import ira
+from miasm.ir.ir import IRBlock, AssignBlock
 
 loc_db = LocationDB()
 
diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py
index c229caf2..345f979a 100644
--- a/test/analysis/depgraph.py
+++ b/test/analysis/depgraph.py
@@ -3,13 +3,13 @@ from __future__ import print_function
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprAssign, \
+from miasm.expression.expression import ExprId, ExprInt, ExprAssign, \
     ExprCond, ExprLoc, LocKey
-from miasm2.core.locationdb import LocationDB
-from miasm2.ir.analysis import ira
-from miasm2.ir.ir import IRBlock, AssignBlock
-from miasm2.core.graph import DiGraph
-from miasm2.analysis.depgraph import DependencyNode, DependencyGraph
+from miasm.core.locationdb import LocationDB
+from miasm.ir.analysis import ira
+from miasm.ir.ir import IRBlock, AssignBlock
+from miasm.core.graph import DiGraph
+from miasm.analysis.depgraph import DependencyNode, DependencyGraph
 from itertools import count
 from pdb import pm
 import re
diff --git a/test/analysis/dse.py b/test/analysis/dse.py
index 82668ea8..8691551c 100644
--- a/test/analysis/dse.py
+++ b/test/analysis/dse.py
@@ -4,12 +4,12 @@ from pdb import pm
 from future.utils import viewitems
 
 from elfesteem.strpatchwork import StrPatchwork
-from miasm2.core import parse_asm
-from miasm2.expression.expression import ExprCompose, ExprOp, ExprInt, ExprId
-from miasm2.core.asmblock import asm_resolve_final
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.dse import DSEEngine
+from miasm.core import parse_asm
+from miasm.expression.expression import ExprCompose, ExprOp, ExprInt, ExprId
+from miasm.core.asmblock import asm_resolve_final
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.dse import DSEEngine
 
 
 class DSETest(object):
diff --git a/test/analysis/modularintervals.py b/test/analysis/modularintervals.py
index cf286e3a..2d877567 100644
--- a/test/analysis/modularintervals.py
+++ b/test/analysis/modularintervals.py
@@ -1,10 +1,10 @@
 from builtins import range
 from random import shuffle, seed
 
-from miasm2.core.interval import interval
-from miasm2.analysis.modularintervals import ModularIntervals
-from miasm2.expression.expression import *
-from miasm2.expression.simplifications import expr_simp
+from miasm.core.interval import interval
+from miasm.analysis.modularintervals import ModularIntervals
+from miasm.expression.expression import *
+from miasm.expression.simplifications import expr_simp
 
 
 def gen_all_intervals(size):
diff --git a/test/analysis/range.py b/test/analysis/range.py
index 946d0116..6dc109ac 100644
--- a/test/analysis/range.py
+++ b/test/analysis/range.py
@@ -1,7 +1,7 @@
 from __future__ import print_function
-from miasm2.expression.expression import *
-from miasm2.analysis.expression_range import expr_range
-from miasm2.ir.translators import Translator
+from miasm.expression.expression import *
+from miasm.analysis.expression_range import expr_range
+from miasm.ir.translators import Translator
 import z3
 
 trans = Translator.to_language("z3")
diff --git a/test/analysis/unssa.py b/test/analysis/unssa.py
index 42e56246..55ceac9e 100644
--- a/test/analysis/unssa.py
+++ b/test/analysis/unssa.py
@@ -1,12 +1,12 @@
 """ Test cases for dead code elimination"""
 from future.utils import viewvalues
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem, \
+from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem, \
     ExprCond, ExprLoc
-from miasm2.core.locationdb import LocationDB
-from miasm2.analysis.simplifier import IRCFGSimplifierSSA
-from miasm2.ir.analysis import ira
-from miasm2.ir.ir import IRCFG, IRBlock, AssignBlock
+from miasm.core.locationdb import LocationDB
+from miasm.analysis.simplifier import IRCFGSimplifierSSA
+from miasm.ir.analysis import ira
+from miasm.ir.ir import IRCFG, IRBlock, AssignBlock
 
 loc_db = LocationDB()
 
diff --git a/test/arch/aarch64/arch.py b/test/arch/aarch64/arch.py
index 948ee489..70a44053 100644
--- a/test/arch/aarch64/arch.py
+++ b/test/arch/aarch64/arch.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 import sys
 import time
 from pdb import pm
-from miasm2.core.utils import decode_hex
-from miasm2.arch.aarch64.arch import *
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex
+from miasm.arch.aarch64.arch import *
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 
diff --git a/test/arch/aarch64/unit/asm_test.py b/test/arch/aarch64/unit/asm_test.py
index e49a2a62..65a537a0 100644
--- a/test/arch/aarch64/unit/asm_test.py
+++ b/test/arch/aarch64/unit/asm_test.py
@@ -3,13 +3,13 @@ import os
 
 from future.utils import viewitems
 
-from miasm2.arch.aarch64.arch import mn_aarch64, base_expr, variable
-from miasm2.core import parse_asm
-from miasm2.expression.expression import *
-from miasm2.core import asmblock
+from miasm.arch.aarch64.arch import mn_aarch64, base_expr, variable
+from miasm.core import parse_asm
+from miasm.expression.expression import *
+from miasm.core import asmblock
 from elfesteem.strpatchwork import StrPatchwork
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import *
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import *
 
 reg_and_id = dict(mn_aarch64.regs.all_regs_ids_byname)
 
diff --git a/test/arch/arm/arch.py b/test/arch/arm/arch.py
index bf2b1a02..c8f2d433 100644
--- a/test/arch/arm/arch.py
+++ b/test/arch/arm/arch.py
@@ -1,9 +1,9 @@
 from __future__ import print_function
 import time
 
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.arch.arm.arch import *
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.arch.arm.arch import *
+from miasm.core.locationdb import LocationDB
 from pdb import pm
 
 
diff --git a/test/arch/arm/sem.py b/test/arch/arm/sem.py
index 9c19431b..f38d48e9 100755
--- a/test/arch/arm/sem.py
+++ b/test/arch/arm/sem.py
@@ -7,12 +7,12 @@ import logging
 
 from future.utils import viewitems
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.arch.arm.arch import mn_arm as mn
-from miasm2.arch.arm.sem import ir_arml as ir_arch
-from miasm2.arch.arm.regs import *
-from miasm2.expression.expression import *
-from miasm2.core.locationdb import LocationDB
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.arch.arm.arch import mn_arm as mn
+from miasm.arch.arm.sem import ir_arml as ir_arch
+from miasm.arch.arm.regs import *
+from miasm.expression.expression import *
+from miasm.core.locationdb import LocationDB
 from pdb import pm
 
 logging.getLogger('cpuhelper').setLevel(logging.ERROR)
diff --git a/test/arch/mep/asm/test_asm.py b/test/arch/mep/asm/test_asm.py
index 217def86..7762669a 100644
--- a/test/arch/mep/asm/test_asm.py
+++ b/test/arch/mep/asm/test_asm.py
@@ -2,8 +2,8 @@
 # Guillaume Valadon <guillaume@valadon.net>
 
 from __future__ import print_function
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.arch.mep.arch import mn_mep
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.arch.mep.arch import mn_mep
 
 class TestMisc(object):
 
diff --git a/test/arch/mep/asm/ut_helpers_asm.py b/test/arch/mep/asm/ut_helpers_asm.py
index 26520787..9f6dc5c2 100644
--- a/test/arch/mep/asm/ut_helpers_asm.py
+++ b/test/arch/mep/asm/ut_helpers_asm.py
@@ -5,11 +5,11 @@ from __future__ import print_function
 
 from builtins import range
 
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.arch.mep.arch import mn_mep
-from miasm2.core.cpu import Disasm_Exception
-from miasm2.core.locationdb import LocationDB
-from miasm2.expression.expression import ExprId, ExprInt, ExprLoc
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.arch.mep.arch import mn_mep
+from miasm.core.cpu import Disasm_Exception
+from miasm.core.locationdb import LocationDB
+from miasm.expression.expression import ExprId, ExprInt, ExprLoc
 
 import re
 
diff --git a/test/arch/mep/ir/test_arithmetic.py b/test/arch/mep/ir/test_arithmetic.py
index 2e0dbf32..d404f51c 100644
--- a/test/arch/mep/ir/test_arithmetic.py
+++ b/test/arch/mep/ir/test_arithmetic.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestArithmetic(object):
diff --git a/test/arch/mep/ir/test_bitmanipulation.py b/test/arch/mep/ir/test_bitmanipulation.py
index f4ea2f29..6ec200c5 100644
--- a/test/arch/mep/ir/test_bitmanipulation.py
+++ b/test/arch/mep/ir/test_bitmanipulation.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprMem
+from miasm.expression.expression import ExprId, ExprInt, ExprMem
 
 
 class TestBitManipulation(object):
diff --git a/test/arch/mep/ir/test_branchjump.py b/test/arch/mep/ir/test_branchjump.py
index 7e0953fd..828b172f 100644
--- a/test/arch/mep/ir/test_branchjump.py
+++ b/test/arch/mep/ir/test_branchjump.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt
+from miasm.expression.expression import ExprId, ExprInt
 
 
 class TestBranchJump(object):
diff --git a/test/arch/mep/ir/test_control.py b/test/arch/mep/ir/test_control.py
index 92dcb371..04c8b4d0 100644
--- a/test/arch/mep/ir/test_control.py
+++ b/test/arch/mep/ir/test_control.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestControl(object):
diff --git a/test/arch/mep/ir/test_coprocessor.py b/test/arch/mep/ir/test_coprocessor.py
index e9829c08..bd8fd39c 100644
--- a/test/arch/mep/ir/test_coprocessor.py
+++ b/test/arch/mep/ir/test_coprocessor.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprMem, ExprInt
+from miasm.expression.expression import ExprId, ExprMem, ExprInt
 
 
 class TestCoprocessor(object):
diff --git a/test/arch/mep/ir/test_debug.py b/test/arch/mep/ir/test_debug.py
index b25e3a19..0c1026de 100644
--- a/test/arch/mep/ir/test_debug.py
+++ b/test/arch/mep/ir/test_debug.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestDebug(object):
diff --git a/test/arch/mep/ir/test_divide.py b/test/arch/mep/ir/test_divide.py
index e3e4cb99..424a9876 100644
--- a/test/arch/mep/ir/test_divide.py
+++ b/test/arch/mep/ir/test_divide.py
@@ -3,8 +3,8 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
-from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.jitter.csts import EXCEPT_DIV_BY_ZERO
 
 
 class TestDivide(object):
diff --git a/test/arch/mep/ir/test_extension.py b/test/arch/mep/ir/test_extension.py
index 10f16ebf..72ad8c22 100644
--- a/test/arch/mep/ir/test_extension.py
+++ b/test/arch/mep/ir/test_extension.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprMem, ExprInt
+from miasm.expression.expression import ExprId, ExprMem, ExprInt
 
 
 class TestExtension(object):
diff --git a/test/arch/mep/ir/test_ir.py b/test/arch/mep/ir/test_ir.py
index be717db8..be8e24e1 100644
--- a/test/arch/mep/ir/test_ir.py
+++ b/test/arch/mep/ir/test_ir.py
@@ -3,13 +3,13 @@
 
 from __future__ import print_function
 
-from miasm2.core.utils import decode_hex
-from miasm2.arch.mep.arch import mn_mep
-from miasm2.arch.mep.regs import regs_init
-from miasm2.arch.mep.ira import ir_mepb, ir_a_mepb
-from miasm2.expression.expression import ExprId, ExprInt, ExprMem
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex
+from miasm.arch.mep.arch import mn_mep
+from miasm.arch.mep.regs import regs_init
+from miasm.arch.mep.ira import ir_mepb, ir_a_mepb
+from miasm.expression.expression import ExprId, ExprInt, ExprMem
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.core.locationdb import LocationDB
 
 
 class TestMisc(object):
diff --git a/test/arch/mep/ir/test_ldz.py b/test/arch/mep/ir/test_ldz.py
index 668030c8..f14172b2 100644
--- a/test/arch/mep/ir/test_ldz.py
+++ b/test/arch/mep/ir/test_ldz.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestLdz(object):
diff --git a/test/arch/mep/ir/test_loadstore.py b/test/arch/mep/ir/test_loadstore.py
index 22cb4304..87343fcb 100644
--- a/test/arch/mep/ir/test_loadstore.py
+++ b/test/arch/mep/ir/test_loadstore.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprMem, ExprInt
+from miasm.expression.expression import ExprId, ExprMem, ExprInt
 
 
 class TestLoadStore(object):
diff --git a/test/arch/mep/ir/test_logical.py b/test/arch/mep/ir/test_logical.py
index e78b5488..0e5aef76 100644
--- a/test/arch/mep/ir/test_logical.py
+++ b/test/arch/mep/ir/test_logical.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestLogical(object):
diff --git a/test/arch/mep/ir/test_move.py b/test/arch/mep/ir/test_move.py
index 8da7a18a..30af1a74 100644
--- a/test/arch/mep/ir/test_move.py
+++ b/test/arch/mep/ir/test_move.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprMem, ExprInt
+from miasm.expression.expression import ExprId, ExprMem, ExprInt
 
 
 class TestMove(object):
diff --git a/test/arch/mep/ir/test_multiply.py b/test/arch/mep/ir/test_multiply.py
index 5673994c..065f1a59 100644
--- a/test/arch/mep/ir/test_multiply.py
+++ b/test/arch/mep/ir/test_multiply.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestMultiply(object):
diff --git a/test/arch/mep/ir/test_repeat.py b/test/arch/mep/ir/test_repeat.py
index 1e0e2f86..e684ef87 100644
--- a/test/arch/mep/ir/test_repeat.py
+++ b/test/arch/mep/ir/test_repeat.py
@@ -3,7 +3,7 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
 
 
 class TestRepeat(object):
diff --git a/test/arch/mep/ir/test_shift.py b/test/arch/mep/ir/test_shift.py
index 99755ba5..cac48660 100644
--- a/test/arch/mep/ir/test_shift.py
+++ b/test/arch/mep/ir/test_shift.py
@@ -3,8 +3,8 @@
 
 from ut_helpers_ir import exec_instruction
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
-from miasm2.core.cpu import sign_ext
+from miasm.expression.expression import ExprId, ExprInt, ExprCond, ExprOp
+from miasm.core.cpu import sign_ext
 
 
 class TestShift(object):
diff --git a/test/arch/mep/ir/ut_helpers_ir.py b/test/arch/mep/ir/ut_helpers_ir.py
index 26eebeda..c5bf36b9 100644
--- a/test/arch/mep/ir/ut_helpers_ir.py
+++ b/test/arch/mep/ir/ut_helpers_ir.py
@@ -3,16 +3,16 @@
 
 from __future__ import print_function
 
-from miasm2.arch.mep.arch import mn_mep
-from miasm2.arch.mep.sem import ir_mepb
-from miasm2.arch.mep.regs import regs_init
-
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.core.locationdb import LocationDB
-from miasm2.core.utils import Disasm_Exception
-from miasm2.ir.ir import AssignBlock
-from miasm2.arch.mep.ira import ir_a_mepb
-from miasm2.expression.expression import ExprId, ExprInt, ExprOp, ExprMem, \
+from miasm.arch.mep.arch import mn_mep
+from miasm.arch.mep.sem import ir_mepb
+from miasm.arch.mep.regs import regs_init
+
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.core.locationdb import LocationDB
+from miasm.core.utils import Disasm_Exception
+from miasm.ir.ir import AssignBlock
+from miasm.arch.mep.ira import ir_a_mepb
+from miasm.expression.expression import ExprId, ExprInt, ExprOp, ExprMem, \
     ExprAssign, ExprLoc
 
 
diff --git a/test/arch/mep/jit/ut_helpers_jit.py b/test/arch/mep/jit/ut_helpers_jit.py
index 999ead42..0c756e39 100644
--- a/test/arch/mep/jit/ut_helpers_jit.py
+++ b/test/arch/mep/jit/ut_helpers_jit.py
@@ -3,14 +3,14 @@
 
 from __future__ import print_function
 
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 
 def jit_instructions(mn_str):
     """JIT instructions and return the jitter object."""
 
-    # Get the miasm2 Machine
+    # Get the miasm Machine
     machine = Machine("mepb")
     mn_mep = machine.mn()
 
diff --git a/test/arch/mips32/arch.py b/test/arch/mips32/arch.py
index f71d3ee8..e5e8cff6 100644
--- a/test/arch/mips32/arch.py
+++ b/test/arch/mips32/arch.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 import time
 from pdb import pm
 
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.core.locationdb import LocationDB
-from miasm2.arch.mips32.arch import *
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.core.locationdb import LocationDB
+from miasm.arch.mips32.arch import *
 
 loc_db = LocationDB()
 
diff --git a/test/arch/mips32/unit/asm_test.py b/test/arch/mips32/unit/asm_test.py
index 7a50b38e..38a2d928 100644
--- a/test/arch/mips32/unit/asm_test.py
+++ b/test/arch/mips32/unit/asm_test.py
@@ -3,13 +3,13 @@ import os
 
 from future.utils import viewitems
 
-from miasm2.arch.mips32.arch import mn_mips32
-from miasm2.core import parse_asm
-from miasm2.expression.expression import *
-from miasm2.core import asmblock
+from miasm.arch.mips32.arch import mn_mips32
+from miasm.core import parse_asm
+from miasm.expression.expression import *
+from miasm.core import asmblock
 from elfesteem.strpatchwork import StrPatchwork
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import *
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import *
 
 
 reg_and_id = dict(mn_mips32.regs.all_regs_ids_byname)
diff --git a/test/arch/msp430/arch.py b/test/arch/msp430/arch.py
index eea87091..bc38c363 100644
--- a/test/arch/msp430/arch.py
+++ b/test/arch/msp430/arch.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 
 import time
 from pdb import pm
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.arch.msp430.arch import *
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.arch.msp430.arch import *
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 
diff --git a/test/arch/msp430/sem.py b/test/arch/msp430/sem.py
index 88aa990d..2aca66ed 100755
--- a/test/arch/msp430/sem.py
+++ b/test/arch/msp430/sem.py
@@ -7,12 +7,12 @@ import logging
 
 from future.utils import viewitems
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.arch.msp430.arch import mn_msp430 as mn, mode_msp430 as mode
-from miasm2.arch.msp430.sem import ir_msp430 as ir_arch
-from miasm2.arch.msp430.regs import *
-from miasm2.expression.expression import *
-from miasm2.core.locationdb import LocationDB
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.arch.msp430.arch import mn_msp430 as mn, mode_msp430 as mode
+from miasm.arch.msp430.sem import ir_msp430 as ir_arch
+from miasm.arch.msp430.regs import *
+from miasm.expression.expression import *
+from miasm.core.locationdb import LocationDB
 
 logging.getLogger('cpuhelper').setLevel(logging.ERROR)
 EXCLUDE_REGS = set([res, ir_arch().IRDst])
diff --git a/test/arch/sh4/arch.py b/test/arch/sh4/arch.py
index f52ed070..0fbc6ba2 100644
--- a/test/arch/sh4/arch.py
+++ b/test/arch/sh4/arch.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 import time
 from pdb import pm
 from sys import stderr
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.arch.sh4.arch import *
-from miasm2.core.locationdb import LocationDB
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.arch.sh4.arch import *
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 
diff --git a/test/arch/x86/arch.py b/test/arch/x86/arch.py
index b4cebd28..202ecac5 100644
--- a/test/arch/x86/arch.py
+++ b/test/arch/x86/arch.py
@@ -2,13 +2,13 @@ from __future__ import print_function
 import time
 from pdb import pm
 
-from miasm2.core.utils import decode_hex, encode_hex
-import miasm2.expression.expression as m2_expr
-from miasm2.arch.x86.arch import mn_x86, deref_mem_ad, \
+from miasm.core.utils import decode_hex, encode_hex
+import miasm.expression.expression as m2_expr
+from miasm.arch.x86.arch import mn_x86, deref_mem_ad, \
     base_expr, rmarg, print_size
-from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
-from miasm2.core.bin_stream import bin_stream_str
-from miasm2.core.locationdb import LocationDB
+from miasm.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64
+from miasm.core.bin_stream import bin_stream_str
+from miasm.core.locationdb import LocationDB
 
 loc_db = LocationDB()
 
diff --git a/test/arch/x86/qemu/testqemu.py b/test/arch/x86/qemu/testqemu.py
index 264a84b9..99d6e6c1 100644
--- a/test/arch/x86/qemu/testqemu.py
+++ b/test/arch/x86/qemu/testqemu.py
@@ -10,9 +10,9 @@ try:
 except AttributeError:
     pass
 
-from miasm2.analysis.sandbox import Sandbox_Linux_x86_32
-from miasm2.jitter.jitload import log_func
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.sandbox import Sandbox_Linux_x86_32
+from miasm.jitter.jitload import log_func
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 # Utils
 def parse_fmt(s):
diff --git a/test/arch/x86/qemu/testqemu64.py b/test/arch/x86/qemu/testqemu64.py
index 4fe51992..24193d40 100644
--- a/test/arch/x86/qemu/testqemu64.py
+++ b/test/arch/x86/qemu/testqemu64.py
@@ -10,9 +10,9 @@ try:
 except AttributeError:
     pass
 
-from miasm2.analysis.sandbox import Sandbox_Linux_x86_64
-from miasm2.jitter.jitload import log_func
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.sandbox import Sandbox_Linux_x86_64
+from miasm.jitter.jitload import log_func
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 # Utils
 def parse_fmt(s):
diff --git a/test/arch/x86/sem.py b/test/arch/x86/sem.py
index c0cfc8f2..5109d2b4 100755
--- a/test/arch/x86/sem.py
+++ b/test/arch/x86/sem.py
@@ -12,14 +12,14 @@ import unittest
 import logging
 import copy
 
-from miasm2.ir.symbexec import SymbolicExecutionEngine
-from miasm2.arch.x86.arch import mn_x86 as mn
-from miasm2.arch.x86.sem import ir_x86_32 as ir_32, ir_x86_64 as ir_64
-from miasm2.arch.x86.regs import *
-from miasm2.expression.expression import *
-from miasm2.expression.simplifications import expr_simp
-from miasm2.core import parse_asm, asmblock
-from miasm2.core.locationdb import LocationDB
+from miasm.ir.symbexec import SymbolicExecutionEngine
+from miasm.arch.x86.arch import mn_x86 as mn
+from miasm.arch.x86.sem import ir_x86_32 as ir_32, ir_x86_64 as ir_64
+from miasm.arch.x86.regs import *
+from miasm.expression.expression import *
+from miasm.expression.simplifications import expr_simp
+from miasm.core import parse_asm, asmblock
+from miasm.core.locationdb import LocationDB
 
 
 logging.getLogger('cpuhelper').setLevel(logging.ERROR)
diff --git a/test/arch/x86/unit/access_xmm.py b/test/arch/x86/unit/access_xmm.py
index 8354c30f..65248b2e 100644
--- a/test/arch/x86/unit/access_xmm.py
+++ b/test/arch/x86/unit/access_xmm.py
@@ -1,7 +1,7 @@
 #! /usr/bin/env python2
 """Test getter and setter for XMM registers (128 bits)"""
 
-from miasm2.analysis.machine import Machine
+from miasm.analysis.machine import Machine
 
 # Jitter engine doesn't matter, use the always available 'python' one
 myjit = Machine("x86_32").jitter("python")
diff --git a/test/arch/x86/unit/asm_test.py b/test/arch/x86/unit/asm_test.py
index a87fe278..0059f511 100644
--- a/test/arch/x86/unit/asm_test.py
+++ b/test/arch/x86/unit/asm_test.py
@@ -5,13 +5,13 @@ import os
 
 from future.utils import viewitems
 
-from miasm2.arch.x86.arch import mn_x86, base_expr, variable
-from miasm2.core import parse_asm
-from miasm2.expression.expression import *
-from miasm2.core import asmblock
+from miasm.arch.x86.arch import mn_x86, base_expr, variable
+from miasm.core import parse_asm
+from miasm.expression.expression import *
+from miasm.core import asmblock
 from elfesteem.strpatchwork import StrPatchwork
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import *
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import *
 
 reg_and_id = dict(mn_x86.regs.all_regs_ids_byname)
 
diff --git a/test/arch/x86/unit/mn_cdq.py b/test/arch/x86/unit/mn_cdq.py
index 947b40bb..d015ede9 100644
--- a/test/arch/x86/unit/mn_cdq.py
+++ b/test/arch/x86/unit/mn_cdq.py
@@ -3,7 +3,7 @@
 import sys
 
 from asm_test import Asm_Test_16, Asm_Test_32, Asm_Test_64
-from miasm2.core.utils import pck16, pck32
+from miasm.core.utils import pck16, pck32
 
 
 class Test_CBW_16(Asm_Test_16):
diff --git a/test/arch/x86/unit/mn_int.py b/test/arch/x86/unit/mn_int.py
index efacb105..8cb8080f 100755
--- a/test/arch/x86/unit/mn_int.py
+++ b/test/arch/x86/unit/mn_int.py
@@ -1,7 +1,7 @@
 #! /usr/bin/env python2
 import sys
 
-from miasm2.jitter.csts import EXCEPT_INT_XX
+from miasm.jitter.csts import EXCEPT_INT_XX
 from asm_test import Asm_Test_32
 
 
diff --git a/test/arch/x86/unit/mn_pushpop.py b/test/arch/x86/unit/mn_pushpop.py
index fedd197b..6dc37b74 100755
--- a/test/arch/x86/unit/mn_pushpop.py
+++ b/test/arch/x86/unit/mn_pushpop.py
@@ -3,7 +3,7 @@
 import sys
 
 from asm_test import Asm_Test_16, Asm_Test_32
-from miasm2.core.utils import pck16, pck32
+from miasm.core.utils import pck16, pck32
 
 
 def init_regs(test):
diff --git a/test/arch/x86/unit/mn_seh.py b/test/arch/x86/unit/mn_seh.py
index 1fa0900e..8575cc46 100755
--- a/test/arch/x86/unit/mn_seh.py
+++ b/test/arch/x86/unit/mn_seh.py
@@ -2,10 +2,10 @@
 from __future__ import print_function
 import sys
 
-from miasm2.os_dep.win_api_x86_32_seh import fake_seh_handler, build_teb, \
+from miasm.os_dep.win_api_x86_32_seh import fake_seh_handler, build_teb, \
     set_win_fs_0, return_from_exception, EXCEPTION_PRIV_INSTRUCTION, \
     return_from_seh, DEFAULT_SEH
-from miasm2.os_dep.win_32_structs import ContextException
+from miasm.os_dep.win_32_structs import ContextException
 
 from asm_test import Asm_Test_32
 
diff --git a/test/arch/x86/unit/test_asm_x86_64.py b/test/arch/x86/unit/test_asm_x86_64.py
index 4e600846..e23f9a19 100644
--- a/test/arch/x86/unit/test_asm_x86_64.py
+++ b/test/arch/x86/unit/test_asm_x86_64.py
@@ -1,7 +1,7 @@
-from miasm2.core import asmblock
-from miasm2.arch.x86  import arch
-from miasm2.core import parse_asm
-from miasm2.core.interval import interval
+from miasm.core import asmblock
+from miasm.arch.x86  import arch
+from miasm.core import parse_asm
+from miasm.core.interval import interval
 
 my_mn = arch.mn_x86
 
diff --git a/test/core/asmblock.py b/test/core/asmblock.py
index 48e81e78..e5ccf252 100644
--- a/test/core/asmblock.py
+++ b/test/core/asmblock.py
@@ -4,14 +4,14 @@ from pdb import pm
 
 from future.utils import viewitems
 
-from miasm2.core.utils import decode_hex
-from miasm2.analysis.machine import Machine
-from miasm2.analysis.binary import Container
-from miasm2.core.asmblock import AsmCFG, AsmConstraint, AsmBlock, \
+from miasm.core.utils import decode_hex
+from miasm.analysis.machine import Machine
+from miasm.analysis.binary import Container
+from miasm.core.asmblock import AsmCFG, AsmConstraint, AsmBlock, \
     AsmBlockBad, AsmConstraintTo, AsmConstraintNext, \
     bbl_simplifier
-from miasm2.core.graph import DiGraphSimplifier, MatchGraphJoker
-from miasm2.expression.expression import ExprId
+from miasm.core.graph import DiGraphSimplifier, MatchGraphJoker
+from miasm.expression.expression import ExprId
 
 # Initial data: from 'samples/simple_test.bin'
 data = decode_hex("5589e583ec10837d08007509c745fc01100000eb73837d08017709c745fc02100000eb64837d08057709c745fc03100000eb55837d080774138b450801c083f80e7509c745fc04100000eb3c8b450801c083f80e7509c745fc05100000eb298b450883e03085c07409c745fc06100000eb16837d08427509c745fc07100000eb07c745fc081000008b45fcc9c3")
diff --git a/test/core/graph.py b/test/core/graph.py
index 484591b7..3db5e523 100644
--- a/test/core/graph.py
+++ b/test/core/graph.py
@@ -1,5 +1,5 @@
 from __future__ import print_function
-from miasm2.core.graph import *
+from miasm.core.graph import *
 
 g = DiGraph()
 g.add_node('a')
diff --git a/test/core/interval.py b/test/core/interval.py
index 76c95d66..61f33178 100755
--- a/test/core/interval.py
+++ b/test/core/interval.py
@@ -2,7 +2,7 @@
 #-*- coding:utf-8 -*-
 
 from builtins import range
-from miasm2.core.interval import *
+from miasm.core.interval import *
 from random import randint
 from pdb import pm
 
diff --git a/test/core/locationdb.py b/test/core/locationdb.py
index 3db760d8..b6d7d8e0 100644
--- a/test/core/locationdb.py
+++ b/test/core/locationdb.py
@@ -1,5 +1,5 @@
 from builtins import str
-from miasm2.core.locationdb import LocationDB
+from miasm.core.locationdb import LocationDB
 
 
 # Basic tests (LocationDB description)
diff --git a/test/core/parse_asm.py b/test/core/parse_asm.py
index ade9040d..ab2bca4a 100755
--- a/test/core/parse_asm.py
+++ b/test/core/parse_asm.py
@@ -8,8 +8,8 @@ import unittest
 class TestParseAsm(unittest.TestCase):
 
     def test_ParseTxt(self):
-        from miasm2.arch.x86.arch import mn_x86
-        from miasm2.core.parse_asm import parse_txt
+        from miasm.arch.x86.arch import mn_x86
+        from miasm.core.parse_asm import parse_txt
 
         ASM0 = '''
         ;
@@ -37,9 +37,9 @@ class TestParseAsm(unittest.TestCase):
         self.assertRaises(ValueError, parse_txt, mn_x86, 32, ASM1)
 
     def test_DirectiveDontSplit(self):
-        from miasm2.arch.x86.arch import mn_x86
-        from miasm2.core.parse_asm import parse_txt
-        from miasm2.core.asmblock import asm_resolve_final
+        from miasm.arch.x86.arch import mn_x86
+        from miasm.core.parse_asm import parse_txt
+        from miasm.core.asmblock import asm_resolve_final
 
         ASM0 = '''
         lbl0:
@@ -85,8 +85,8 @@ class TestParseAsm(unittest.TestCase):
         assert(lbls[5] == lbl2block[lbls[4]].get_next())
 
     def test_DirectiveSplit(self):
-        from miasm2.arch.x86.arch import mn_x86
-        from miasm2.core.parse_asm import parse_txt
+        from miasm.arch.x86.arch import mn_x86
+        from miasm.core.parse_asm import parse_txt
 
         ASM0 = '''
         lbl0:
diff --git a/test/core/sembuilder.py b/test/core/sembuilder.py
index 53e9e60e..7c3d578e 100644
--- a/test/core/sembuilder.py
+++ b/test/core/sembuilder.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 import inspect
 from pdb import pm
 
-from miasm2.core.sembuilder import SemBuilder
-from miasm2.core.locationdb import LocationDB
-import miasm2.expression.expression as m2_expr
+from miasm.core.sembuilder import SemBuilder
+from miasm.core.locationdb import LocationDB
+import miasm.expression.expression as m2_expr
 
 
 
diff --git a/test/core/test_types.py b/test/core/test_types.py
index e3914185..1b15630c 100755
--- a/test/core/test_types.py
+++ b/test/core/test_types.py
@@ -1,19 +1,19 @@
 #! /usr/bin/env python2
 
-# miasm2.core.types tests
+# miasm.core.types tests
 
 from __future__ import print_function
 from builtins import range
 import struct
 
-from miasm2.core.utils import int_to_byte
-from miasm2.analysis.machine import Machine
-from miasm2.core.types import MemStruct, Num, Ptr, Str, \
+from miasm.core.utils import int_to_byte
+from miasm.analysis.machine import Machine
+from miasm.core.types import MemStruct, Num, Ptr, Str, \
                               Array, RawStruct, Union, \
                               BitField, Self, Void, Bits, \
                               set_allocator, MemUnion, Struct
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.os_dep.common import heap
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.os_dep.common import heap
 
 # Two structures with some fields
 class OtherStruct(MemStruct):
diff --git a/test/core/utils.py b/test/core/utils.py
index 6f69fdf1..0ca64f4e 100755
--- a/test/core/utils.py
+++ b/test/core/utils.py
@@ -10,7 +10,7 @@ import unittest
 class TestUtils(unittest.TestCase):
 
     def test_boundedDict(self):
-        from miasm2.core.utils import BoundedDict
+        from miasm.core.utils import BoundedDict
 
         # Use a callback
         def logger(key):
diff --git a/test/expr_type/test_chandler.py b/test/expr_type/test_chandler.py
index 92ebd0f2..e6566636 100644
--- a/test/expr_type/test_chandler.py
+++ b/test/expr_type/test_chandler.py
@@ -9,18 +9,18 @@ from __future__ import print_function
 from future.utils import viewitems
 from past.builtins import cmp
 from builtins import str
-from miasm2.expression.expression import ExprInt, ExprId, ExprMem
-from miasm2.expression.simplifications import expr_simp
+from miasm.expression.expression import ExprInt, ExprId, ExprMem
+from miasm.expression.simplifications import expr_simp
 
-from miasm2.core.objc import parse_access
-from miasm2.core.objc import ast_get_c_access_expr
-from miasm2.core.objc import ExprCToExpr, ExprToAccessC, CHandler
+from miasm.core.objc import parse_access
+from miasm.core.objc import ast_get_c_access_expr
+from miasm.core.objc import ExprCToExpr, ExprToAccessC, CHandler
 
 
-from miasm2.core.ctypesmngr import CTypeStruct, CTypeUnion, CAstTypes, CTypePtr, CTypeId
-from miasm2.core.objc import CTypesManagerNotPacked
+from miasm.core.ctypesmngr import CTypeStruct, CTypeUnion, CAstTypes, CTypePtr, CTypeId
+from miasm.core.objc import CTypesManagerNotPacked
 
-from miasm2.arch.x86.ctype import CTypeAMD64_unk
+from miasm.arch.x86.ctype import CTypeAMD64_unk
 
 
 text_1 = """
diff --git a/test/expression/expr_cmp.py b/test/expression/expr_cmp.py
index b238151d..671085f1 100644
--- a/test/expression/expr_cmp.py
+++ b/test/expression/expr_cmp.py
@@ -2,12 +2,12 @@
 # Expression comparison regression tests  #
 #
 from pdb import pm
-from miasm2.expression.expression import ExprInt, expr_is_unsigned_greater,\
+from miasm.expression.expression import ExprInt, expr_is_unsigned_greater,\
     expr_is_unsigned_greater_or_equal, expr_is_unsigned_lower,\
     expr_is_unsigned_lower_or_equal, expr_is_signed_greater,\
     expr_is_signed_greater_or_equal, expr_is_signed_lower, \
     expr_is_signed_lower_or_equal, expr_is_equal, expr_is_not_equal
-from miasm2.expression.simplifications import expr_simp
+from miasm.expression.simplifications import expr_simp
 
 int_0 = ExprInt(0, 32)
 int_1 = ExprInt(1, 32)
diff --git a/test/expression/expr_pickle.py b/test/expression/expr_pickle.py
index 16b87db7..70778d38 100644
--- a/test/expression/expr_pickle.py
+++ b/test/expression/expr_pickle.py
@@ -1,6 +1,6 @@
 from __future__ import print_function
 import pickle
-from miasm2.expression.expression import ExprInt, ExprAssign, ExprId, \
+from miasm.expression.expression import ExprInt, ExprAssign, ExprId, \
     Expr, ExprCompose, ExprMem
 
 
diff --git a/test/expression/expression.py b/test/expression/expression.py
index b8a2642a..3597eae8 100644
--- a/test/expression/expression.py
+++ b/test/expression/expression.py
@@ -3,8 +3,8 @@ from __future__ import print_function
 # Expression regression tests  #
 #
 from pdb import pm
-from miasm2.expression.expression import *
-from miasm2.expression.expression_helper import *
+from miasm.expression.expression import *
+from miasm.expression.expression_helper import *
 
 # Expression comparison
 assert(ExprInt(-1, 64) != ExprInt(-2, 64))
diff --git a/test/expression/expression_helper.py b/test/expression/expression_helper.py
index 6c6fb2a9..c188215e 100755
--- a/test/expression/expression_helper.py
+++ b/test/expression/expression_helper.py
@@ -10,8 +10,8 @@ import unittest
 class TestExpressionExpressionHelper(unittest.TestCase):
 
     def test_Variables_Identifier(self):
-        import miasm2.expression.expression as m2_expr
-        from miasm2.expression.expression_helper import Variables_Identifier
+        import miasm.expression.expression as m2_expr
+        from miasm.expression.expression_helper import Variables_Identifier
 
         # Build a complex expression
         cst = m2_expr.ExprInt(0x100, 16)
diff --git a/test/expression/modint.py b/test/expression/modint.py
index a833ee80..af80b284 100644
--- a/test/expression/modint.py
+++ b/test/expression/modint.py
@@ -1,5 +1,6 @@
 from __future__ import print_function
-from miasm2.expression.modint import *
+
+from miasm.expression.modint import *
 
 a = uint8(0x42)
 b = uint8(0xFF)
diff --git a/test/expression/parser.py b/test/expression/parser.py
index d05f8262..48c63753 100644
--- a/test/expression/parser.py
+++ b/test/expression/parser.py
@@ -1,6 +1,6 @@
 from __future__ import print_function
-from miasm2.expression.parser import str_to_expr
-from miasm2.expression.expression import ExprInt, ExprId, ExprSlice, ExprMem, \
+from miasm.expression.parser import str_to_expr
+from miasm.expression.expression import ExprInt, ExprId, ExprSlice, ExprMem, \
     ExprCond, ExprCompose, ExprOp, ExprAssign, ExprLoc, LocKey
 
 for expr_test in [ExprInt(0x12, 32),
diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index ae9eb1c0..1a22c43d 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -6,11 +6,11 @@ from pdb import pm
 from argparse import ArgumentParser
 import logging
 
-from miasm2.expression.expression import *
-from miasm2.expression.simplifications import expr_simp, expr_simp_explicit, \
+from miasm.expression.expression import *
+from miasm.expression.simplifications import expr_simp, expr_simp_explicit, \
     ExpressionSimplifier, log_exprsimp
 
-from miasm2.expression.simplifications_cond import ExprOp_inf_signed, ExprOp_inf_unsigned, ExprOp_equal
+from miasm.expression.simplifications_cond import ExprOp_inf_signed, ExprOp_inf_unsigned, ExprOp_equal
 
 parser = ArgumentParser("Expression simplification regression tests")
 parser.add_argument("--z3", action="store_true", help="Enable check against z3")
@@ -24,7 +24,7 @@ if args.verbose:
 # Additional imports and definitions
 if args.z3:
     import z3
-    from miasm2.ir.translators import Translator
+    from miasm.ir.translators import Translator
     trans = Translator.to_language("z3")
 
     def check(expr_in, expr_out):
diff --git a/test/expression/stp.py b/test/expression/stp.py
index 7650bf45..b97b0754 100755
--- a/test/expression/stp.py
+++ b/test/expression/stp.py
@@ -8,8 +8,8 @@ import unittest
 class TestIrIr2STP(unittest.TestCase):
 
     def test_ExprOp_strcst(self):
-        from miasm2.expression.expression import ExprInt, ExprOp
-        from miasm2.ir.translators.translator  import Translator
+        from miasm.expression.expression import ExprInt, ExprOp
+        from miasm.ir.translators.translator  import Translator
         translator_smt2 = Translator.to_language("smt2")
 
         args = [ExprInt(i, 32) for i in range(9)]
@@ -23,8 +23,8 @@ class TestIrIr2STP(unittest.TestCase):
         self.assertRaises(NotImplementedError, translator_smt2.from_expr, ExprOp('X', *args[:1]))
 
     def test_ExprSlice_strcst(self):
-        from miasm2.expression.expression import ExprInt, ExprOp
-        from miasm2.ir.translators.translator  import Translator
+        from miasm.expression.expression import ExprInt, ExprOp
+        from miasm.ir.translators.translator  import Translator
         translator_smt2 = Translator.to_language("smt2")
 
         args = [ExprInt(i, 32) for i in range(9)]
diff --git a/test/ir/ir.py b/test/ir/ir.py
index 3dd95c3e..a959a7a7 100644
--- a/test/ir/ir.py
+++ b/test/ir/ir.py
@@ -1,8 +1,8 @@
 from future.utils import viewitems
 
-from miasm2.expression.expression import *
-from miasm2.ir.ir import AssignBlock
-from miasm2.expression.simplifications import expr_simp
+from miasm.expression.expression import *
+from miasm.ir.ir import AssignBlock
+from miasm.expression.simplifications import expr_simp
 
 id_a = ExprId("a", 32)
 id_b = ExprId("b", 32)
diff --git a/test/ir/ir2C.py b/test/ir/ir2C.py
index 26683468..c41c98c9 100755
--- a/test/ir/ir2C.py
+++ b/test/ir/ir2C.py
@@ -3,19 +3,19 @@
 
 from builtins import range
 import unittest
-from miasm2.expression.expression import TOK_EQUAL
+from miasm.expression.expression import TOK_EQUAL
 
 class TestIrIr2C(unittest.TestCase):
 
     def translationTest(self, expr, expected):
-        from miasm2.ir.translators import Translator
+        from miasm.ir.translators import Translator
 
         translator = Translator.to_language("C")
         self.assertEqual(translator.from_expr(expr), expected)
 
     def test_ExprOp_toC(self):
-        from miasm2.expression.expression import ExprInt, ExprOp
-        from miasm2.ir.translators.C import Translator
+        from miasm.expression.expression import ExprInt, ExprOp
+        from miasm.ir.translators.C import Translator
 
         args = [ExprInt(i, 32) for i in range(9)]
         translator = Translator.to_language("C")
diff --git a/test/ir/reduce_graph.py b/test/ir/reduce_graph.py
index f6ebad24..8835b4aa 100644
--- a/test/ir/reduce_graph.py
+++ b/test/ir/reduce_graph.py
@@ -5,13 +5,13 @@ from pdb import pm
 
 from future.utils import viewitems
 
-from miasm2.expression.expression import ExprId, ExprInt, ExprAssign, ExprCond, \
+from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprCond, \
     ExprLoc, LocKey
 
-from miasm2.core.locationdb import LocationDB
-from miasm2.ir.analysis import ira
-from miasm2.ir.ir import IRBlock, AssignBlock, IRCFG
-from miasm2.analysis.data_flow import merge_blocks
+from miasm.core.locationdb import LocationDB
+from miasm.ir.analysis import ira
+from miasm.ir.ir import IRBlock, AssignBlock, IRCFG
+from miasm.analysis.data_flow import merge_blocks
 
 loc_db = LocationDB()
 
diff --git a/test/ir/symbexec.py b/test/ir/symbexec.py
index 3ab99c91..d627f4b9 100755
--- a/test/ir/symbexec.py
+++ b/test/ir/symbexec.py
@@ -11,12 +11,12 @@ import unittest
 class TestSymbExec(unittest.TestCase):
 
     def test_ClassDef(self):
-        from miasm2.expression.expression import ExprInt, ExprId, ExprMem, \
+        from miasm.expression.expression import ExprInt, ExprId, ExprMem, \
             ExprCompose, ExprAssign
-        from miasm2.arch.x86.sem import ir_x86_32
-        from miasm2.core.locationdb import LocationDB
-        from miasm2.ir.symbexec import SymbolicExecutionEngine
-        from miasm2.ir.ir import AssignBlock
+        from miasm.arch.x86.sem import ir_x86_32
+        from miasm.core.locationdb import LocationDB
+        from miasm.ir.symbexec import SymbolicExecutionEngine
+        from miasm.ir.ir import AssignBlock
 
 
         loc_db = LocationDB()
diff --git a/test/ir/translators/smt2.py b/test/ir/translators/smt2.py
index 78472d0a..81f63b45 100644
--- a/test/ir/translators/smt2.py
+++ b/test/ir/translators/smt2.py
@@ -1,7 +1,7 @@
 from z3 import Solver, unsat, parse_smt2_string
-from miasm2.expression.expression import *
-from miasm2.ir.translators.smt2 import TranslatorSMT2
-from miasm2.ir.translators.z3_ir import TranslatorZ3
+from miasm.expression.expression import *
+from miasm.ir.translators.smt2 import TranslatorSMT2
+from miasm.ir.translators.z3_ir import TranslatorZ3
 
 # create nested expression
 a = ExprId("a", 64)
diff --git a/test/ir/translators/z3_ir.py b/test/ir/translators/z3_ir.py
index 68421bea..b28269fb 100644
--- a/test/ir/translators/z3_ir.py
+++ b/test/ir/translators/z3_ir.py
@@ -1,9 +1,9 @@
 from __future__ import print_function
 import z3
 
-from miasm2.core.locationdb import LocationDB
-from miasm2.expression.expression import *
-from miasm2.ir.translators.z3_ir import Z3Mem, TranslatorZ3
+from miasm.core.locationdb import LocationDB
+from miasm.expression.expression import *
+from miasm.ir.translators.z3_ir import Z3Mem, TranslatorZ3
 
 # Some examples of use/unit tests.
 
diff --git a/test/jitter/bad_block.py b/test/jitter/bad_block.py
index 0756dfd5..256d2388 100644
--- a/test/jitter/bad_block.py
+++ b/test/jitter/bad_block.py
@@ -1,7 +1,7 @@
 import sys
-from miasm2.core.utils import decode_hex
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE, EXCEPT_UNK_MNEMO
-from miasm2.analysis.machine import Machine
+from miasm.core.utils import decode_hex
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE, EXCEPT_UNK_MNEMO
+from miasm.analysis.machine import Machine
 
 def code_sentinelle(jitter):
     jitter.run = False
diff --git a/test/jitter/jit_options.py b/test/jitter/jit_options.py
index 91d59edd..74808330 100644
--- a/test/jitter/jit_options.py
+++ b/test/jitter/jit_options.py
@@ -2,9 +2,9 @@ from __future__ import print_function
 import os
 import sys
 
-from miasm2.core.utils import decode_hex
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.machine import Machine
+from miasm.core.utils import decode_hex
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
 from pdb import pm
 
 # Shellcode
diff --git a/test/jitter/jitload.py b/test/jitter/jitload.py
index 5473b7d2..8b758a89 100644
--- a/test/jitter/jitload.py
+++ b/test/jitter/jitload.py
@@ -1,10 +1,10 @@
 import sys
 from pdb import pm
 
-from miasm2.core.utils import decode_hex, encode_hex
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.machine import Machine
-from miasm2.expression.expression import ExprId, ExprAssign, ExprInt, ExprMem
+from miasm.core.utils import decode_hex, encode_hex
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
+from miasm.expression.expression import ExprId, ExprAssign, ExprInt, ExprMem
 
 # Initial data: from 'example/samples/x86_32_sc.bin'
 data = decode_hex("8d49048d5b0180f90174058d5bffeb038d5b0189d8c3")
diff --git a/test/jitter/jmp_out_mem.py b/test/jitter/jmp_out_mem.py
index ff137b84..2b064f73 100644
--- a/test/jitter/jmp_out_mem.py
+++ b/test/jitter/jmp_out_mem.py
@@ -1,7 +1,7 @@
 import sys
-from miasm2.core.utils import decode_hex
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE, EXCEPT_ACCESS_VIOL
-from miasm2.analysis.machine import Machine
+from miasm.core.utils import decode_hex
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE, EXCEPT_ACCESS_VIOL
+from miasm.analysis.machine import Machine
 
 def code_sentinelle(jitter):
     jitter.run = False
diff --git a/test/jitter/test_post_instr.py b/test/jitter/test_post_instr.py
index ab8f8a74..52274a46 100644
--- a/test/jitter/test_post_instr.py
+++ b/test/jitter/test_post_instr.py
@@ -1,9 +1,9 @@
 from __future__ import print_function
 import sys
 
-from miasm2.core.utils import decode_hex
-from miasm2.analysis.machine import Machine
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE, \
+from miasm.core.utils import decode_hex
+from miasm.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE, \
     EXCEPT_BREAKPOINT_MEMORY, EXCEPT_ACCESS_VIOL
 
 machine = Machine("x86_32")
diff --git a/test/jitter/vm_mngr.py b/test/jitter/vm_mngr.py
index 3aa4105e..468fb347 100644
--- a/test/jitter/vm_mngr.py
+++ b/test/jitter/vm_mngr.py
@@ -1,6 +1,6 @@
 import sys
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
-from miasm2.analysis.machine import Machine
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
 
 myjit = Machine("x86_32").jitter(sys.argv[1])
 
diff --git a/test/os_dep/common.py b/test/os_dep/common.py
index 52512075..749d71a7 100755
--- a/test/os_dep/common.py
+++ b/test/os_dep/common.py
@@ -4,10 +4,10 @@
 from builtins import range
 import unittest
 import logging
-from miasm2.analysis.machine import Machine
-import miasm2.os_dep.common as commonapi
-from miasm2.core.utils import pck32
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
+import miasm.os_dep.common as commonapi
+from miasm.core.utils import pck32
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 machine = Machine("x86_32")
 
diff --git a/test/os_dep/linux/stdlib.py b/test/os_dep/linux/stdlib.py
index 80b99969..a205002b 100755
--- a/test/os_dep/linux/stdlib.py
+++ b/test/os_dep/linux/stdlib.py
@@ -3,10 +3,10 @@
 
 import unittest
 import logging
-from miasm2.analysis.machine import Machine
-import miasm2.os_dep.linux_stdlib as stdlib
-from miasm2.core.utils import pck32
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
+import miasm.os_dep.linux_stdlib as stdlib
+from miasm.core.utils import pck32
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 machine = Machine("x86_32")
 
diff --git a/test/os_dep/linux/test_env.py b/test/os_dep/linux/test_env.py
index 1e8e7678..13351a84 100644
--- a/test/os_dep/linux/test_env.py
+++ b/test/os_dep/linux/test_env.py
@@ -2,8 +2,8 @@ from __future__ import print_function
 import os
 import sys
 from pdb import pm
-from miasm2.analysis.binary import Container
-from miasm2.analysis.sandbox import Sandbox_Linux_x86_32, Sandbox_Linux_x86_64,\
+from miasm.analysis.binary import Container
+from miasm.analysis.sandbox import Sandbox_Linux_x86_32, Sandbox_Linux_x86_64,\
     Sandbox_Linux_arml, Sandbox_Linux_aarch64l
 
 if len(sys.argv) < 2:
diff --git a/test/os_dep/win_api_x86_32.py b/test/os_dep/win_api_x86_32.py
index 2dcac61d..a7d88f90 100755
--- a/test/os_dep/win_api_x86_32.py
+++ b/test/os_dep/win_api_x86_32.py
@@ -4,10 +4,10 @@
 from builtins import range
 import unittest
 import logging
-from miasm2.analysis.machine import Machine
-import miasm2.os_dep.win_api_x86_32 as winapi
-from miasm2.core.utils import pck32
-from miasm2.jitter.csts import PAGE_READ, PAGE_WRITE
+from miasm.analysis.machine import Machine
+import miasm.os_dep.win_api_x86_32 as winapi
+from miasm.core.utils import pck32
+from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
 
 machine = Machine("x86_32")