diff --git a/src/emu/i8088.rs b/src/emu/i8088.rs
index 12276a6..9cd199d 100644
--- a/src/emu/i8088.rs
+++ b/src/emu/i8088.rs
@@ -3,7 +3,7 @@ use std::fmt::{Debug, Formatter};
 
 use super::byteorder::{ByteOrder, LittleEndian};
 
-use emu::operands::{Addr, Reg, RegHi, RegLo};
+use emu::operands::{FarPtr, Reg, RegHi, RegLo};
 use emu::operations as ops;
 use emu::pc::Bus;
 use emu::util::segoff_to_addr;
@@ -96,7 +96,7 @@ macro_rules! step {
          ($segment:ident, $repeat:ident, $prefix_loop:lifetime),
          $modrm:tt) => { {
     let a16 = i8088::next_ip16($cpu.cs.get(), &mut $cpu.ip, $bus);
-    step!(@arg $cookie, &mut Addr { bus: $bus, segment: $segment.unwrap(), offset: a16 } )
+    step!(@arg $cookie, &mut FarPtr { bus: $bus, segment: $segment.unwrap(), offset: a16 } )
   } };
 
   (@bus $cookie:tt, $cpu:expr, $bus:expr, $prefix:tt, $modrm:tt) => {
@@ -125,27 +125,27 @@ macro_rules! step {
   (@displace0=($reg1:ident $(+ $reg2:ident)? ) $cookie:tt, $cpu:expr, $bus:expr,
                            ($segment:ident, $repeat:ident, $prefix_loop:lifetime),
                            $modrm:tt) => {
-    step!(@arg $cookie, &mut Addr { bus: $bus,
-                                    segment: $segment.unwrap(),
-                                    offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? })
+    step!(@arg $cookie, &mut FarPtr { bus: $bus,
+                                      segment: $segment.unwrap(),
+                                      offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? })
   };
 
   (@displace8=($reg1:ident $(+ $reg2:ident)? ) $cookie:tt, $cpu:expr, $bus:expr,
                                                ($segment:ident, $repeat:ident, $prefix_loop:lifetime),
                                                $modrm:tt) => { {
     let d8 = i8088::next_ip($cpu.cs.get(), &mut $cpu.ip, $bus);
-    step!(@arg $cookie, &mut Addr { bus: $bus,
-                                    segment: $segment.unwrap(),
-                                    offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? + d8 as u16 })
+    step!(@arg $cookie, &mut FarPtr { bus: $bus,
+                                      segment: $segment.unwrap(),
+                                      offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? + d8 as u16 })
   } };
 
   (@displace16=($reg1:ident $(+ $reg2:ident)? ) $cookie:tt, $cpu:expr, $bus:expr,
                                                 ($segment:ident, $repeat:ident, $prefix_loop:lifetime),
                                                 $modrm:tt) => { {
     let d16 = i8088::next_ip16($cpu.cs.get(), &mut $cpu.ip, $bus);
-    step!(@arg $cookie, &mut Addr { bus: $bus,
-                                    segment: $segment.unwrap(),
-                                    offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? + d16 })
+    step!(@arg $cookie, &mut FarPtr { bus: $bus,
+                                      segment: $segment.unwrap(),
+                                      offset: $cpu.$reg1.get() $(+ $cpu.$reg2.get())? + d16 })
   } };
 
   (@flags $cookie:tt, $cpu:expr, $bus:expr, $prefix:tt, $modrm:tt) => {
diff --git a/src/emu/operands.rs b/src/emu/operands.rs
index 4c3c253..d1751bf 100644
--- a/src/emu/operands.rs
+++ b/src/emu/operands.rs
@@ -58,31 +58,31 @@ impl RValue<u16> for u16 {
   }
 }
 
-pub struct Addr<'a> {
+pub struct FarPtr<'a> {
   pub bus: &'a mut Bus,
   pub segment: u16,
   pub offset: u16
 }
 
-impl Address for Addr<'_> {
+impl Address for FarPtr<'_> {
   fn addr(&self) -> usize {
     segoff_to_addr(self.segment, self.offset)
   }
 }
 
-impl LValue<u8> for Addr<'_> {
+impl LValue<u8> for FarPtr<'_> {
   fn write(&mut self, val: u8) {
     self.bus.write(self.addr(), val);
   }
 }
 
-impl RValue<u8> for Addr<'_> {
+impl RValue<u8> for FarPtr<'_> {
   fn read(&self) -> u8 {
     self.bus.read(self.addr())
   }
 }
 
-impl LValue<u16> for Addr<'_> {
+impl LValue<u16> for FarPtr<'_> {
   fn write(&mut self, val: u16) {
     let buf = val.to_le_bytes();
     self.bus.write(self.addr(),     buf[0]);
@@ -90,7 +90,7 @@ impl LValue<u16> for Addr<'_> {
   }
 }
 
-impl RValue<u16> for Addr<'_> {
+impl RValue<u16> for FarPtr<'_> {
   fn read(&self) -> u16 {
     let addr = self.addr();
     let mut buf = [0u8; 2];
diff --git a/src/emu/operations.rs b/src/emu/operations.rs
index ae01807..02a95df 100644
--- a/src/emu/operations.rs
+++ b/src/emu/operations.rs
@@ -2,7 +2,7 @@ use std::fmt::Debug;
 
 use emu::dos;
 use emu::i8088::{Flags, RepPrefix, i8088};
-use emu::operands::{Addr, Address, LValue, Operand, Reg, RValue};
+use emu::operands::{Address, FarPtr, LValue, Operand, Reg, RValue};
 use emu::pc::Bus;
 
 macro_rules! string_op {
@@ -112,8 +112,8 @@ pub fn cmpsb(flags: &mut Flags,
              es: &mut Reg,
              di: &mut Reg) {
   string_op!((u8, flags, rep, cx, di=di, zf=flags.zf), {
-    let src = <Addr as RValue<u8>>::read(&Addr { bus: bus, segment: seg, offset: si.read() });
-    let dst = <Addr as RValue<u8>>::read(&Addr { bus: bus, segment: es.read(), offset: di.read() });
+    let src = <FarPtr as RValue<u8>>::read(&FarPtr { bus: bus, segment: seg, offset: si.read() });
+    let dst = <FarPtr as RValue<u8>>::read(&FarPtr { bus: bus, segment: es.read(), offset: di.read() });
 
     cmp(flags, &dst, &src);
   });
@@ -128,8 +128,8 @@ pub fn cmpsw(flags: &mut Flags,
              es: &mut Reg,
              di: &mut Reg) {
   string_op!((u16, flags, rep, cx, di=di, zf=flags.zf), {
-    let src = <Addr as RValue<u16>>::read(&Addr { bus: bus, segment: seg, offset: si.read() });
-    let dst = <Addr as RValue<u16>>::read(&Addr { bus: bus, segment: es.read(), offset: di.read() });
+    let src = <FarPtr as RValue<u16>>::read(&FarPtr { bus: bus, segment: seg, offset: si.read() });
+    let dst = <FarPtr as RValue<u16>>::read(&FarPtr { bus: bus, segment: es.read(), offset: di.read() });
 
     cmp(flags, &dst, &src);
   });
@@ -142,7 +142,7 @@ pub fn int(cpu: &mut i8088, bus: &mut Bus, num: &u8) {
   }
 }
 
-pub fn lea(dst: &mut Reg, addr: &Addr) {
+pub fn lea(dst: &mut Reg, addr: &FarPtr) {
   dst.write(addr.offset)
 }
 
@@ -154,7 +154,7 @@ pub fn lodsb(flags: &Flags,
              si: &mut Reg,
              al: &mut impl LValue<u8>) {
   string_op!((u8, flags, rep, cx, si=si), {
-    al.write(Addr { bus: bus, segment: seg, offset: si.read() }.read());
+    al.write(FarPtr { bus: bus, segment: seg, offset: si.read() }.read());
   });
 }
 
@@ -166,7 +166,7 @@ pub fn lodsw(flags: &Flags,
              si: &mut Reg,
              ax: &mut impl LValue<u16>) {
   string_op!((u16, flags, rep, cx, si=si), {
-    ax.write(Addr { bus: bus, segment: seg, offset: si.read() }.read());
+    ax.write(FarPtr { bus: bus, segment: seg, offset: si.read() }.read());
   });
 }
 
@@ -183,9 +183,9 @@ pub fn movsb(flags: &Flags,
              es: &Reg,
              di: &mut Reg) {
   string_op!((u8, flags, rep, cx, si=si, di=di), {
-    let src = <Addr as RValue<u8>>::read(&Addr { bus: bus, segment: seg, offset: si.read() });
-    let mut dst = Addr { bus: bus, segment: es.read(), offset: di.read() };
-    <Addr as LValue<u8>>::write(&mut dst, src);
+    let src = <FarPtr as RValue<u8>>::read(&FarPtr { bus: bus, segment: seg, offset: si.read() });
+    let mut dst = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
+    <FarPtr as LValue<u8>>::write(&mut dst, src);
   });
 }
 
@@ -198,16 +198,16 @@ pub fn movsw(flags: &Flags,
              es: &Reg,
              di: &mut Reg) {
   string_op!((u16, flags, rep, cx, si=si, di=di), {
-    let src = <Addr as RValue<u16>>::read(&Addr { bus: bus, segment: seg, offset: si.read() });
-    let mut dst = Addr { bus: bus, segment: es.read(), offset: di.read() };
-    <Addr as LValue<u16>>::write(&mut dst, src);
+    let src = <FarPtr as RValue<u16>>::read(&FarPtr { bus: bus, segment: seg, offset: si.read() });
+    let mut dst = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
+    <FarPtr as LValue<u16>>::write(&mut dst, src);
   });
 }
 
 pub fn nop() {}
 
 pub fn pop(bus: &mut Bus, ss: u16, sp: &mut Reg, dst: &mut Reg) {
-  let ptr = Addr { bus: bus, segment: ss, offset: sp.read() };
+  let ptr = FarPtr { bus: bus, segment: ss, offset: sp.read() };
   dst.write(ptr.read());
   sp.write(sp.read() + 2);
 }
@@ -215,7 +215,7 @@ pub fn pop(bus: &mut Bus, ss: u16, sp: &mut Reg, dst: &mut Reg) {
 pub fn push(bus: &mut Bus, ss: u16, sp: &mut Reg, val: u16) {
   // XXX: Not checking for stack faults or anything
   sp.write(sp.read() - 2);
-  let mut ptr = Addr { bus: bus, segment: ss, offset: sp.read() };
+  let mut ptr = FarPtr { bus: bus, segment: ss, offset: sp.read() };
   ptr.write(val);
 }
 
@@ -227,7 +227,7 @@ pub fn scasb(flags: &mut Flags,
              di: &mut Reg,
              needle: &impl RValue<u8>) {
   string_op!((u8, flags, rep, cx, di=di, zf=flags.zf), {
-    let elem = Addr { bus: bus, segment: es.read(), offset: di.read() };
+    let elem = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
     cmp(flags, &elem, needle);
   });
 }
@@ -240,7 +240,7 @@ pub fn scasw(flags: &mut Flags,
              di: &mut Reg,
              needle: &impl RValue<u16>) {
   string_op!((u16, flags, rep, cx, di=di, zf=flags.zf), {
-    let elem = Addr { bus: bus, segment: es.read(), offset: di.read() };
+    let elem = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
     cmp(flags, &elem, needle);
   });
 }
@@ -253,7 +253,7 @@ pub fn stosb(flags: &Flags,
              di: &mut Reg,
              val: &impl RValue<u8>) {
   string_op!((u8, flags, rep, cx, di=di), {
-    let mut dst = Addr { bus: bus, segment: es.read(), offset: di.read() };
+    let mut dst = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
     dst.write(val.read());
   });
 }
@@ -266,7 +266,7 @@ pub fn stosw(flags: &Flags,
              di: &mut Reg,
              val: &impl RValue<u16>) {
   string_op!((u16, flags, rep, cx, di=di), {
-    let mut dst = Addr { bus: bus, segment: es.read(), offset: di.read() };
+    let mut dst = FarPtr { bus: bus, segment: es.read(), offset: di.read() };
     dst.write(val.read());
   });
 }