diff --git a/source/Indy.IL2CPU.Assembler.X86/Assembler.cs b/source/Indy.IL2CPU.Assembler.X86/Assembler.cs
index 940b56d4c..57e208dc8 100644
--- a/source/Indy.IL2CPU.Assembler.X86/Assembler.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/Assembler.cs
@@ -13,92 +13,92 @@ namespace Indy.IL2CPU.Assembler.X86 {
                 Label = "WriteByteToComPort";
                 Label = "WriteByteToComPort_Wait";
                 DX = xComStatusAddr;
-                AL = Port(DX);
+                AL = Port[DX];
                 AL.Test(0x20);
                 JumpIfEqual("WriteByteToComPort_Wait");
                 DX = aComAddr;
-                new Move(Registers.AL, "[esp + 4]");
-                new Out(Registers.DX, Registers.AL);
-                new Ret(4);
+                AL = Memory[ESP + 4];
+                Port[DX] = AL;
+                Return(4);
 
-                new Label("DebugWriteEIP");
-                new Move(Registers.AL, "[ebp + 3]");
+                Label = "DebugWriteEIP";
+                AL = Memory[EBP + 3];
                 new Push(Registers.EAX);
-                new Call("WriteByteToComPort");
-                new Move(Registers.AL, "[ebp + 2]");
+                Call("WriteByteToComPort");
+                AL = Memory[EBP + 2];
                 new Push(Registers.EAX);
-                new Call("WriteByteToComPort");
-                new Move(Registers.AL, "[ebp + 1]");
+                Call("WriteByteToComPort");
+                AL = Memory[EBP + 1];
                 new Push(Registers.EAX);
-                new Call("WriteByteToComPort");
-                new Move(Registers.AL, "[ebp]");
+                Call("WriteByteToComPort");
+                AL = Memory[EBP];
                 new Push(Registers.EAX);
-                new Call("WriteByteToComPort");
-                new Ret();
+                Call("WriteByteToComPort");
+                Return();
 
-                new Label("DebugPoint_WaitCmd");
+                Label = "DebugPoint_WaitCmd";
                 DX = xComStatusAddr;
                 new InByte(Registers.AL, Registers.DX);
-                new Test(Registers.AL, 1);
+                AL.Test(0x01);
                 new JumpIfZero("DebugPoint_WaitCmd");
-                new Jump("DebugPoint_ProcessCmd");
+                Jump("DebugPoint_ProcessCmd");
 
-                new Label("DebugPoint__");
-                new Pushad();
+                Label = "DebugPoint__";
+                PushAll32();
                 new Move(Registers.EBP, Registers.ESP);
                 new Add(Registers.EBP, 32);
 
                 // Check TraceMode
                 new Move(Registers.EAX, "[TraceMode]");
                 new Compare(Registers.AX, 1);
-                new JumpIfEqual("DebugPoint_NoTrace");
+                JumpIfEqual("DebugPoint_NoTrace");
                 //
                 new Call("DebugWriteEIP");
                 //
                 new Move(Registers.EAX, "[TraceMode]");
                 new Compare(Registers.AL, 4);
-                new JumpIfEqual("DebugPoint_WaitCmd");
-                new Label("DebugPoint_NoTrace");
+                JumpIfEqual("DebugPoint_WaitCmd");
+                Label = "DebugPoint_NoTrace";
 
                 // Is there a new incoming command?
-                new Label("DebugPoint_CheckCmd");
+                Label = "DebugPoint_CheckCmd";
                 DX = xComStatusAddr;
-                new InByte(Registers.AL, Registers.DX);
-                new Test(Registers.AL, 1);
-                new JumpIfZero("DebugPoint_AfterCmd");
+                AL = Port[DX];
+                AL.Test(0x01);
+                JumpIfZero("DebugPoint_AfterCmd");
 
-                new Label("DebugPoint_ProcessCmd");
+                Label = "DebugPoint_ProcessCmd";
                 DX = aComAddr;
-                new InByte(Registers.AL, Registers.DX);
+                AL = Port[DX];
                 new Compare(Registers.AL, 1);
-                new JumpIfNotEqual("DebugPoint_Cmd02");
+                JumpIfNotEqual("DebugPoint_Cmd02");
                 new Move("dword", "[TraceMode]", 1);
-                new Jump("DebugPoint_CheckCmd");
+                Jump("DebugPoint_CheckCmd");
                 //
-                new Label("DebugPoint_Cmd02");
+                Label = "DebugPoint_Cmd02";
                 new Compare(Registers.AL, 2);
-                new JumpIfNotEqual("DebugPoint_Cmd03");
+                JumpIfNotEqual("DebugPoint_Cmd03");
                 new Move("dword", "[TraceMode]", 2);
-                new Jump("DebugPoint_CheckCmd");
+                Jump("DebugPoint_CheckCmd");
                 //
-                new Label("DebugPoint_Cmd03");
+                Label = "DebugPoint_Cmd03";
                 new Compare(Registers.AL, 3);
-                new JumpIfNotEqual("DebugPoint_Cmd04");
+                JumpIfNotEqual("DebugPoint_Cmd04");
                 new Move("dword", "[TraceMode]", 4);
-                new Jump("DebugPoint_AfterCmd");
+                Jump("DebugPoint_AfterCmd");
                 //
-                new Label("DebugPoint_Cmd04");
+                Label = "DebugPoint_Cmd04";
                 new Compare(Registers.AL, 4);
-                new JumpIfNotEqual("DebugPoint_Cmd05");
+                JumpIfNotEqual("DebugPoint_Cmd05");
                 new Move("dword", "[TraceMode]", 4);
-                new Jump("DebugPoint_WaitCmd");
+                Jump("DebugPoint_WaitCmd");
                 //
-                new Label("DebugPoint_Cmd05");
+                Label = "DebugPoint_Cmd05";
                 // -Evaluate variables
                 // -Step to next debug call
                 // Break points
                 // Immediate break
-                new Label("DebugPoint_AfterCmd");
+                Label = "DebugPoint_AfterCmd";
 
                 // TraceMode
                 // 1 - No tracing
@@ -106,8 +106,8 @@ namespace Indy.IL2CPU.Assembler.X86 {
                 // 3 - 
                 // 4 - Break and wait
 
-                new Popad();
-                new Ret();
+                PopAll32();
+                Return();
             }
         }
 
diff --git a/source/Indy.IL2CPU.Assembler.X86/Indy.IL2CPU.Assembler.X86.csproj b/source/Indy.IL2CPU.Assembler.X86/Indy.IL2CPU.Assembler.X86.csproj
index b18374cd8..ed4a1a34f 100644
--- a/source/Indy.IL2CPU.Assembler.X86/Indy.IL2CPU.Assembler.X86.csproj
+++ b/source/Indy.IL2CPU.Assembler.X86/Indy.IL2CPU.Assembler.X86.csproj
@@ -123,7 +123,13 @@
     <Compile Include="SubWithCarry.cs" />
     <Compile Include="Test.cs" />
     <Compile Include="Xor.cs" />
-    <Compile Include="X\PortSource.cs" />
+    <Compile Include="X\AddressIndirect.cs" />
+    <Compile Include="X\AddressNumeric.cs" />
+    <Compile Include="X\Memory.cs" />
+    <Compile Include="X\Address.cs" />
+    <Compile Include="X\MemoryAction.cs" />
+    <Compile Include="X\Ports.cs" />
+    <Compile Include="X\PortNumber.cs" />
     <Compile Include="X\Register.cs" />
     <Compile Include="X\Register08.cs" />
     <Compile Include="X\Register16.cs" />
@@ -131,6 +137,8 @@
     <Compile Include="X\RegisterAL.cs" />
     <Compile Include="X\RegisterDX.cs" />
     <Compile Include="X\RegisterEAX.cs" />
+    <Compile Include="X\RegisterEBP.cs" />
+    <Compile Include="X\RegisterESP.cs" />
     <Compile Include="X\Y86.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Address.cs b/source/Indy.IL2CPU.Assembler.X86/X/Address.cs
new file mode 100644
index 000000000..8e3c3690e
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Address.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class Address {
+
+        public static implicit operator Address(Register32 aRegister) {
+            return new AddressIndirect(aRegister, 0);
+        }
+
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/AddressIndirect.cs b/source/Indy.IL2CPU.Assembler.X86/X/AddressIndirect.cs
new file mode 100644
index 000000000..4127a4c71
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/AddressIndirect.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class AddressIndirect : Address {
+        protected Register32 mBaseRegister;
+        protected UInt32 mDisplacement = 0;
+
+        public AddressIndirect(Register32 aBaseRegister, UInt32 aDisplacement) {
+            mBaseRegister = aBaseRegister;
+            mDisplacement = aDisplacement;
+        }
+
+        public override string ToString() {
+            if (mDisplacement == 0) {
+                return "[" + mBaseRegister.ToString() + "]";
+            } else {
+                return "[" + mBaseRegister.ToString() + " + " + mDisplacement + "]";
+            }
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/AddressNumeric.cs b/source/Indy.IL2CPU.Assembler.X86/X/AddressNumeric.cs
new file mode 100644
index 000000000..a4ee1f8ba
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/AddressNumeric.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class AddressNumeric : Address {
+        protected UInt32 mAddress;
+
+        public AddressNumeric(UInt32 aAddress) {
+            mAddress = aAddress;
+        }
+
+        public override string ToString() {
+          return mAddress.ToString();
+        }
+
+        public static implicit operator AddressNumeric(UInt32 aAddress) {
+            return new AddressNumeric(aAddress);
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Memory.cs b/source/Indy.IL2CPU.Assembler.X86/X/Memory.cs
new file mode 100644
index 000000000..b26074933
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Memory.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class Memory {
+        public MemoryAction this[Address aAddress] {
+            get {
+                return new MemoryAction(aAddress.ToString());
+            }
+            set {
+            }
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/MemoryAction.cs b/source/Indy.IL2CPU.Assembler.X86/X/MemoryAction.cs
new file mode 100644
index 000000000..89981597f
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/MemoryAction.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class MemoryAction {
+        protected string mValue;
+
+        public MemoryAction(string aValue) {
+            mValue = aValue;
+        }
+
+        public override string ToString() {
+            return mValue;
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/PortSource.cs b/source/Indy.IL2CPU.Assembler.X86/X/PortNumber.cs
similarity index 75%
rename from source/Indy.IL2CPU.Assembler.X86/X/PortSource.cs
rename to source/Indy.IL2CPU.Assembler.X86/X/PortNumber.cs
index b024871f1..1d46817c6 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/PortSource.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/PortNumber.cs
@@ -4,10 +4,10 @@ using System.Linq;
 using System.Text;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
-    public class PortSource {
+    public class PortNumber {
         string mPort;
 
-        public PortSource(string aPort) {
+        public PortNumber(string aPort) {
             mPort = aPort;
         }
 
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Ports.cs b/source/Indy.IL2CPU.Assembler.X86/X/Ports.cs
new file mode 100644
index 000000000..4233f9321
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Ports.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class Ports {
+        public PortNumber this[byte aPort] {
+            get { 
+                return new PortNumber(aPort.ToString());
+            }
+            set {
+                new X86.Out("DX", aPort.ToString());
+            }
+        }
+
+        public PortNumber this[RegisterDX aDX] {
+            get {
+                return new PortNumber("DX");
+            }
+            set { 
+                new X86.Out("DX", value.ToString());  
+            }
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Register.cs b/source/Indy.IL2CPU.Assembler.X86/X/Register.cs
index c7f873ad3..ee3c65d91 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/Register.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Register.cs
@@ -6,13 +6,10 @@ using X86 = Indy.IL2CPU.Assembler.X86;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
     public abstract class Register {
-        // Not abstract so 8,16,32 dont have to override it
-        protected virtual string GetName() {
-            throw new NotImplementedException();
-        }
 
         protected void Move(string aValue) {
-            new X86.Move(GetName(), aValue);
+            new X86.Move(ToString(), aValue);
         }
+
     }
 }
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Register08.cs b/source/Indy.IL2CPU.Assembler.X86/X/Register08.cs
index 4f196b940..a6b439ae4 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/Register08.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Register08.cs
@@ -7,7 +7,7 @@ using X86 = Indy.IL2CPU.Assembler.X86;
 namespace Indy.IL2CPU.Assembler.X86.X {
     public class Register08 : Register {
         public void Test(byte aValue) {
-            new X86.Test(GetName(), aValue);
+            new X86.Test(ToString(), aValue);
         }
     }
 }
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Register32.cs b/source/Indy.IL2CPU.Assembler.X86/X/Register32.cs
index df90d20a8..6a3292c03 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/Register32.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Register32.cs
@@ -5,5 +5,10 @@ using System.Text;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
     public class Register32 : Register {
+
+        public static AddressIndirect operator +(Register32 aBaseRegister, UInt32 aDisplacement) {
+            return new AddressIndirect(aBaseRegister, aDisplacement);
+        }
+
     }
 }
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/RegisterAL.cs b/source/Indy.IL2CPU.Assembler.X86/X/RegisterAL.cs
index c12df22ea..1bbcf888f 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/RegisterAL.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/RegisterAL.cs
@@ -6,21 +6,34 @@ using X86 = Indy.IL2CPU.Assembler.X86;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
     public class RegisterAL : Register08 {
+        public const string Name = "AL";
         public static readonly RegisterAL Instance = new RegisterAL();
 
-        protected override string GetName() {
-            return "AL";
+        public override string ToString() {
+            return Name;
         }
 
+        // TODO: Use an attribute to find the register name
+        // Also useful for Memory conversion - Can find attribute
+        // of descendant? or no?
         public static implicit operator RegisterAL(byte aValue) {
             Instance.Move(aValue.ToString());
             return Instance;
         }
 
-        public static implicit operator RegisterAL(PortSource aValue) {
-            new X86.InByte(Instance.GetName(), aValue.ToString());
+        public static implicit operator RegisterAL(PortNumber aValue) {
+            new X86.InByte("AL", aValue.ToString());
             return Instance;
         }
 
+        public static implicit operator RegisterAL(MemoryAction aAction) {
+            new X86.Move("AL", aAction.ToString());
+            return Instance;
+        }
+
+        public static implicit operator PortNumber(RegisterAL aAL) {
+            return new PortNumber("AL");
+        }
+
     }
 }
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/RegisterDX.cs b/source/Indy.IL2CPU.Assembler.X86/X/RegisterDX.cs
index 0da4dad76..a0900ef6d 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/RegisterDX.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/RegisterDX.cs
@@ -5,10 +5,11 @@ using System.Text;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
     public class RegisterDX : Register16 {
+        public const string Name = "DX";
         public static readonly RegisterDX Instance = new RegisterDX();
 
-        protected override string GetName() {
-            return "DX";
+        public override string ToString() {
+            return Name;
         }
 
         public static implicit operator RegisterDX(UInt16 aValue) {
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/RegisterEAX.cs b/source/Indy.IL2CPU.Assembler.X86/X/RegisterEAX.cs
index 4d63b9b11..25ae4941e 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/RegisterEAX.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/RegisterEAX.cs
@@ -5,10 +5,11 @@ using System.Text;
 
 namespace Indy.IL2CPU.Assembler.X86.X {
     public class RegisterEAX : Register32 {
+        public const string Name = "EAX";
         public static readonly RegisterEAX Instance = new RegisterEAX();
 
-        protected override string GetName() {
-            return "EAX";
+        public override string ToString() {
+            return Name;
         }
 
         public static implicit operator RegisterEAX(UInt32 aValue) {
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/RegisterEBP.cs b/source/Indy.IL2CPU.Assembler.X86/X/RegisterEBP.cs
new file mode 100644
index 000000000..050f09600
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/RegisterEBP.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class RegisterEBP : Register32 {
+        public const string Name = "EBP";
+        public static readonly RegisterEBP Instance = new RegisterEBP();
+
+        public override string ToString() {
+            return Name;
+        }
+
+        public static implicit operator RegisterEBP(UInt32 aValue) {
+            Instance.Move(aValue.ToString());
+            return Instance;
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/RegisterESP.cs b/source/Indy.IL2CPU.Assembler.X86/X/RegisterESP.cs
new file mode 100644
index 000000000..fbf1516ff
--- /dev/null
+++ b/source/Indy.IL2CPU.Assembler.X86/X/RegisterESP.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Indy.IL2CPU.Assembler.X86.X {
+    public class RegisterESP : Register32 {
+        public const string Name = "ESP";
+        public static readonly RegisterESP Instance = new RegisterESP();
+
+        public override string ToString() {
+            return Name;
+        }
+
+        public static implicit operator RegisterESP(UInt32 aValue) {
+            Instance.Move(aValue.ToString());
+            return Instance;
+        }
+    }
+}
diff --git a/source/Indy.IL2CPU.Assembler.X86/X/Y86.cs b/source/Indy.IL2CPU.Assembler.X86/X/Y86.cs
index 5e3499c1b..fba3003bb 100644
--- a/source/Indy.IL2CPU.Assembler.X86/X/Y86.cs
+++ b/source/Indy.IL2CPU.Assembler.X86/X/Y86.cs
@@ -11,9 +11,12 @@ namespace Indy.IL2CPU.Assembler.X86.X {
 
         public RegisterDX DX = RegisterDX.Instance;
 
-        public PortSource Port(RegisterDX aDX) {
-            return new PortSource("DX");
-        }
+        public RegisterESP ESP = RegisterESP.Instance;
+
+        public RegisterEBP EBP = RegisterEBP.Instance;
+
+        public readonly Ports Port = new Ports();
+        public readonly Memory Memory = new Memory();
 
         public string Label {
             set { 
@@ -21,9 +24,33 @@ namespace Indy.IL2CPU.Assembler.X86.X {
             }
         }
 
+        public void Call(string aLabel) {
+            new X86.Call(aLabel);
+        }
+        public void Jump(string aLabel) {
+            new X86.Jump(aLabel);
+        }
         public void JumpIfEqual(string aLabel) {
             new X86.JumpIfEqual(aLabel);
         }
+        public void JumpIfZero(string aLabel) {
+            new X86.JumpIfZero(aLabel);
+        }
+        public void JumpIfNotEqual(string aLabel) {
+            new X86.JumpIfNotEqual(aLabel);
+        }
+        public void PopAll32() {
+            new Popad();
+        }
+        public void PushAll32() {
+            new Pushad();
+        }
+        public void Return() {
+            new X86.Ret();
+        }
+        public void Return(UInt16 aBytes) {
+            new X86.Ret(aBytes);
+        }
 
     }
 }