diff --git a/suite/regress/x64_lea_label.py b/suite/regress/x64_lea_label.py
new file mode 100755
index 0000000000000000000000000000000000000000..f75cd6daee99b54d9bc4b4596cc1f7cdccd5feb9
--- /dev/null
+++ b/suite/regress/x64_lea_label.py
@@ -0,0 +1,63 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test label addressing on X86_64
+
+# Github issue: #34
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm(b"lea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm(b"nop\nnop\nlea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttLabel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to AT&T
+        ks.syntax = KS_OPT_SYNTAX_ATT
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm(b"lea __data, %rax\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm(b"nop\nnop\nlea __data, %rax\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelLabel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to intel
+        ks.syntax = KS_OPT_SYNTAX_INTEL
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm(b"lea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm(b"nop\nnop\nlea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+    regress.main()
diff --git a/suite/regress/x64_lea_label_nasm_abs.py b/suite/regress/x64_lea_label_nasm_abs.py
new file mode 100755
index 0000000000000000000000000000000000000000..6c8797ec2590bcbe9e4e7e9f0a80af016779de14
--- /dev/null
+++ b/suite/regress/x64_lea_label_nasm_abs.py
@@ -0,0 +1,31 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test nasm syntax' explicit abs addressing
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabelAbs(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm(b"lea rax, [abs __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm(b"nop\nnop\nlea rax, [abs __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+    regress.main()
diff --git a/suite/regress/x64_lea_label_rel.py b/suite/regress/x64_lea_label_rel.py
new file mode 100755
index 0000000000000000000000000000000000000000..9833f174f85a95f71b6d95cc3b9b402ea4f6150c
--- /dev/null
+++ b/suite/regress/x64_lea_label_rel.py
@@ -0,0 +1,64 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test RIP relative and absolute addressing using all
+# available syntaxes.
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabelRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses rel for rip relative addressing
+        encoding, count = ks.asm(b"lea rax, [rel __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm(b"nop\nnop\nlea rax, [rel __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttLabelRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to AT&T
+        ks.syntax = KS_OPT_SYNTAX_ATT
+
+        # at&t syntax uses symbol(%rip) for rip relative addressing
+        encoding, count = ks.asm(b"lea __data(%rip), %rax\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm(b"nop\nnop\nlea __data(%rip), %rax\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelLabelRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to intel
+        ks.syntax = KS_OPT_SYNTAX_INTEL
+
+        # intel uses rip + label for rip relative addressing
+        encoding, count = ks.asm(b"lea rax, [rip + __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm(b"nop\nnop\nlea rax, [rip + __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+    regress.main()
diff --git a/suite/regress/x64_rip_rel_abs.py b/suite/regress/x64_rip_rel_abs.py
deleted file mode 100755
index 8624af3f9ad6d79685b0442079480bf680a0a1e3..0000000000000000000000000000000000000000
--- a/suite/regress/x64_rip_rel_abs.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/python
-# Ingmar Steen, 2016
-
-# This is to test RIP relative and absolute addressing
-
-# Github issue: #32
-# Author: Ingmar Steen
-
-from keystone import *
-
-import regress
-
-
-class TestX64NasmRel(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to NASM
-        ks.syntax = KS_OPT_SYNTAX_NASM
-
-        # nasm uses rel for rip relative addressing
-        encoding, count = ks.asm(b"lea rax, [rel __data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-        # verify that rip relative addressing is indeed rip relative
-        encoding, count = ks.asm(b"nop\nnop\nlea rax, [rel __data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-
-class TestX64NasmAbs(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to NASM
-        ks.syntax = KS_OPT_SYNTAX_NASM
-
-        # nasm uses abs for explicit absolute addressing
-        encoding, count = ks.asm(b"lea rax, [abs __data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
-
-        # verify that explicit absolute addressing is indeed absolute
-        encoding, count = ks.asm(b"nop\nnop\nlea rax, [abs __data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
-
-
-class TestX64AttRel(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to AT&T
-        ks.syntax = KS_OPT_SYNTAX_ATT
-
-        # at&t syntax uses symbol(%rip) for rip relative addressing
-        encoding, count = ks.asm(b"lea __data(%rip), %rax\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-        # verify that rip relative addressing is indeed rip relative
-        encoding, count = ks.asm(b"nop\nnop\nlea __data(%rip), %rax\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-
-class TestX64AttAbs(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to AT&T
-        ks.syntax = KS_OPT_SYNTAX_ATT
-
-        # nasm uses abs for explicit absolute addressing
-        encoding, count = ks.asm(b"lea __data, %rax\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
-
-        # verify that explicit absolute addressing is indeed absolute
-        encoding, count = ks.asm(b"nop\nnop\nlea __data, %rax\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
-
-
-class TestX64IntelRel(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to intel
-        ks.syntax = KS_OPT_SYNTAX_INTEL
-
-        # nasm uses rel for rip relative addressing
-        encoding, count = ks.asm(b"lea rax, [rip + __data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-        # verify that rip relative addressing is indeed rip relative
-        encoding, count = ks.asm(b"nop\nnop\nlea rax, [rip + __data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-
-class TestX64IntelAbs(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to intel
-        ks.syntax = KS_OPT_SYNTAX_INTEL
-
-        # nasm uses abs for explicit absolute addressing
-        encoding, count = ks.asm(b"lea rax, [__data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
-
-        # verify that explicit absolute addressing is indeed absolute
-        encoding, count = ks.asm(b"nop\nnop\nlea rax, [__data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
-
-
-if __name__ == '__main__':
-    regress.main()