Merge branch 'dev'

41 files changed, 3072 insertions, 406 deletions

diff --git a/python/__init__.py b/python/__init__.py
index e4d45435..4f58a6db 100644
--- a/python/__init__.py
+++ b/python/__init__.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -32,6 +32,7 @@ from .basicblock import *
 from .function import *
 from .log import *
 from .lowlevelil import *
+from .mediumlevelil import *
 from .types import *
 from .functionrecognizer import *
 from .update import *
@@ -45,6 +46,7 @@ from .lineardisassembly import *
 from .undoaction import *
 from .highlight import *
 from .scriptingprovider import *
+from .pluginmanager import *
 
 
 def shutdown():
@@ -54,6 +56,19 @@ def shutdown():
 	core.BNShutdown()
 
 
+def get_unique_identifier():
+	return core.BNGetUniqueIdentifierString()
+
+
+def get_install_directory():
+	"""
+	``get_install_directory`` returns a string pointing to the installed binary currently running
+
+	.warning:: ONLY for use within the Binary Ninja UI, behavior is undefined and unreliable if run headlessly
+	"""
+	return core.BNGetInstallDirectory()
+
+
 class _DestructionCallbackHandler(object):
 	def __init__(self):
 		self._cb = core.BNObjectDestructionCallbacks()
diff --git a/python/architecture.py b/python/architecture.py
index 3e899d68..2eb3c717 100644
--- a/python/architecture.py
+++ b/python/architecture.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -128,7 +128,7 @@ class Architecture(object):
 		if handle is not None:
 			self.handle = core.handle_of_type(handle, core.BNArchitecture)
 			self.__dict__["name"] = core.BNGetArchitectureName(self.handle)
-			self.__dict__["endianness"] = Endianness(core.BNGetArchitectureEndianness(self.handle)).name
+			self.__dict__["endianness"] = Endianness(core.BNGetArchitectureEndianness(self.handle))
 			self.__dict__["address_size"] = core.BNGetArchitectureAddressSize(self.handle)
 			self.__dict__["default_int_size"] = core.BNGetArchitectureDefaultIntegerSize(self.handle)
 			self.__dict__["max_instr_length"] = core.BNGetArchitectureMaxInstructionLength(self.handle)
@@ -146,7 +146,7 @@ class Architecture(object):
 				info = core.BNGetArchitectureRegisterInfo(self.handle, regs[i])
 				full_width_reg = core.BNGetArchitectureRegisterName(self.handle, info.fullWidthRegister)
 				self.regs[name] = function.RegisterInfo(full_width_reg, info.size, info.offset,
-					ImplicitRegisterExtend(info.extend).name, regs[i])
+					ImplicitRegisterExtend(info.extend), regs[i])
 			core.BNFreeRegisterList(regs)
 
 			count = ctypes.c_ulonglong()
@@ -333,6 +333,16 @@ class Architecture(object):
 			self._pending_reg_lists = {}
 			self._pending_token_lists = {}
 
+	def __eq__(self, value):
+		if not isinstance(value, Architecture):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Architecture):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def full_width_regs(self):
 		"""List of full width register strings (read-only)"""
@@ -364,7 +374,7 @@ class Architecture(object):
 
 	def __setattr__(self, name, value):
 		if ((name == "name") or (name == "endianness") or (name == "address_size") or
-		    (name == "default_int_size") or (name == "regs") or (name == "get_max_instruction_length")):
+			(name == "default_int_size") or (name == "regs") or (name == "get_max_instruction_length")):
 			raise AttributeError("attribute '%s' is read only" % name)
 		else:
 			try:
@@ -467,6 +477,8 @@ class Architecture(object):
 				token_buf[i].value = tokens[i].value
 				token_buf[i].size = tokens[i].size
 				token_buf[i].operand = tokens[i].operand
+				token_buf[i].context = tokens[i].context
+				token_buf[i].address = tokens[i].address
 			result[0] = token_buf
 			ptr = ctypes.cast(token_buf, ctypes.c_void_p)
 			self._pending_token_lists[ptr.value] = (ptr.value, token_buf)
@@ -639,11 +651,11 @@ class Architecture(object):
 			operand_list = []
 			for i in xrange(operand_count):
 				if operands[i].constant:
-					operand_list.append(("const", operands[i].value))
+					operand_list.append(operands[i].value)
 				elif lowlevelil.LLIL_REG_IS_TEMP(operands[i].reg):
-					operand_list.append(("reg", operands[i].reg))
+					operand_list.append(lowlevelil.ILRegister(self, operands[i].reg))
 				else:
-					operand_list.append(("reg", self._regs_by_index[operands[i].reg]))
+					operand_list.append(lowlevelil.ILRegister(self, operands[i].reg))
 			return self.perform_get_flag_write_low_level_il(op, size, write_type_name, flag_name, operand_list,
 				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index
 		except (KeyError, OSError):
@@ -903,7 +915,10 @@ class Architecture(object):
 		:param LowLevelILFunction il:
 		:rtype: LowLevelILExpr
 		"""
-		return il.unimplemented()
+		flag = self.get_flag_index(flag)
+		if flag not in self._flag_roles:
+			return il.unimplemented()
+		return self.get_default_flag_write_low_level_il(op, size, self._flag_roles[flag], operands, il)
 
 	@abc.abstractmethod
 	def perform_get_flag_condition_low_level_il(self, cond, il):
@@ -915,7 +930,7 @@ class Architecture(object):
 		:param LowLevelILFunction il:
 		:rtype: LowLevelILExpr
 		"""
-		return il.unimplemented()
+		return self.get_default_flag_condition_low_level_il(cond, il)
 
 	@abc.abstractmethod
 	def perform_assemble(self, code, addr):
@@ -1113,13 +1128,12 @@ class Architecture(object):
 		result.length = info.length
 		result.branch_delay = info.branchDelay
 		for i in xrange(0, info.branchCount):
-			branch_type = BranchType(info.branchType[i]).name
 			target = info.branchTarget[i]
 			if info.branchArch[i]:
 				arch = Architecture(info.branchArch[i])
 			else:
 				arch = None
-			result.add_branch(branch_type, target, arch)
+			result.add_branch(BranchType(info.branchType[i]), target, arch)
 		return result
 
 	def get_instruction_text(self, data, addr):
@@ -1148,7 +1162,9 @@ class Architecture(object):
 			value = tokens[i].value
 			size = tokens[i].size
 			operand = tokens[i].operand
-			result.append(function.InstructionTextToken(token_type, text, value, size, operand))
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
 		core.BNFreeInstructionText(tokens, count.value)
 		return result, length.value
 
@@ -1163,6 +1179,9 @@ class Architecture(object):
 		``get_instruction_low_level_il`` appends LowLevelILExpr objects to ``il`` for the instruction at the given
 		virtual address ``addr`` with data ``data``.
 
+		This is used to analyze arbitrary data at an address, if you are working with an existing binary, you likely
+		want to be using ``Function.get_low_level_il_at``.
+
 		:param str data: max_instruction_length bytes from the binary at virtual address ``addr``
 		:param int addr: virtual address of bytes in ``data``
 		:param LowLevelILFunction il: The function the current instruction belongs to
@@ -1177,6 +1196,24 @@ class Architecture(object):
 		core.BNGetInstructionLowLevelIL(self.handle, buf, addr, length, il.handle)
 		return length.value
 
+	def get_low_level_il_from_bytes(self, data, addr):
+		"""
+		``get_low_level_il_from_bytes`` converts the instruction in bytes to ``il`` at the given virtual address
+
+		:param str data: the bytes of the instruction
+		:param int addr: virtual address of bytes in ``data``
+		:return: the instruction
+		:rtype: LowLevelILInstruction
+		:Example:
+
+			>>> arch.get_low_level_il_from_bytes('\xeb\xfe', 0x40DEAD)
+			<il: jump(0x40dead)>
+			>>>
+		"""
+		func = lowlevelil.LowLevelILFunction(self)
+		self.get_instruction_low_level_il(data, addr, func)
+		return func[0]
+
 	def get_reg_name(self, reg):
 		"""
 		``get_reg_name`` gets a register name from a register number.
@@ -1197,6 +1234,20 @@ class Architecture(object):
 		"""
 		return core.BNGetArchitectureFlagName(self.handle, flag)
 
+	def get_reg_index(self, reg):
+		if isinstance(reg, str):
+			return self.regs[reg].index
+		elif isinstance(reg, lowlevelil.ILRegister):
+			return reg.index
+		return reg
+
+	def get_flag_index(self, flag):
+		if isinstance(flag, str):
+			return self._flags[flag]
+		elif isinstance(flag, lowlevelil.ILFlag):
+			return flag.index
+		return flag
+
 	def get_flag_write_type_name(self, write_type):
 		"""
 		``get_flag_write_type_name`` gets the flag write type name for the given flag.
@@ -1227,7 +1278,7 @@ class Architecture(object):
 		"""
 		return self._flag_write_types[write_type]
 
-	def get_flag_write_low_level_il(self, op, size, write_type, operands, il):
+	def get_flag_write_low_level_il(self, op, size, write_type, flag, operands, il):
 		"""
 		:param LowLevelILOperation op:
 		:param int size:
@@ -1237,22 +1288,26 @@ class Architecture(object):
 		:param LowLevelILFunction il:
 		:rtype: LowLevelILExpr
 		"""
+		flag = self.get_flag_index(flag)
 		operand_list = (core.BNRegisterOrConstant * len(operands))()
 		for i in xrange(len(operands)):
 			if isinstance(operands[i], str):
 				operand_list[i].constant = False
-				operand_list[i].reg = self._flags[operands[i]]
+				operand_list[i].reg = self.regs[operands[i]]
+			elif isinstance(operands[i], lowlevelil.ILRegister):
+				operand_list[i].constant = False
+				operand_list[i].reg = operands[i].index
 			else:
 				operand_list[i].constant = True
 				operand_list[i].value = operands[i]
 		return lowlevelil.LowLevelILExpr(core.BNGetArchitectureFlagWriteLowLevelIL(self.handle, op, size,
-		        self._flag_write_types[write_type], operand_list, len(operand_list), il.handle))
+		        self._flag_write_types[write_type], flag, operand_list, len(operand_list), il.handle))
 
-	def get_default_flag_write_low_level_il(self, op, size, write_type, operands, il):
+	def get_default_flag_write_low_level_il(self, op, size, role, operands, il):
 		"""
 		:param LowLevelILOperation op:
 		:param int size:
-		:param str write_type:
+		:param FlagRole role:
 		:param list(str or int) operands: a list of either items that are either string register names or constant \
 		integer values
 		:param LowLevelILFunction il:
@@ -1262,12 +1317,15 @@ class Architecture(object):
 		for i in xrange(len(operands)):
 			if isinstance(operands[i], str):
 				operand_list[i].constant = False
-				operand_list[i].reg = self._flags[operands[i]]
+				operand_list[i].reg = self.regs[operands[i]]
+			elif isinstance(operands[i], lowlevelil.ILRegister):
+				operand_list[i].constant = False
+				operand_list[i].reg = operands[i].index
 			else:
 				operand_list[i].constant = True
 				operand_list[i].value = operands[i]
 		return lowlevelil.LowLevelILExpr(core.BNGetDefaultArchitectureFlagWriteLowLevelIL(self.handle, op, size,
-		        self._flag_write_types[write_type], operand_list, len(operand_list), il.handle))
+			role, operand_list, len(operand_list), il.handle))
 
 	def get_flag_condition_low_level_il(self, cond, il):
 		"""
@@ -1277,6 +1335,14 @@ class Architecture(object):
 		"""
 		return lowlevelil.LowLevelILExpr(core.BNGetArchitectureFlagConditionLowLevelIL(self.handle, cond, il.handle))
 
+	def get_default_flag_condition_low_level_il(self, cond, il):
+		"""
+		:param LowLevelILFlagCondition cond:
+		:param LowLevelILFunction il:
+		:rtype: LowLevelILExpr
+		"""
+		return lowlevelil.LowLevelILExpr(core.BNGetDefaultArchitectureFlagConditionLowLevelIL(self.handle, cond, il.handle))
+
 	def get_modified_regs_on_write(self, reg):
 		"""
 		``get_modified_regs_on_write`` returns a list of register names that are modified when ``reg`` is written.
@@ -1581,7 +1647,7 @@ class Architecture(object):
 		"""
 		core.BNSetBinaryViewTypeArchitectureConstant(self.handle, type_name, const_name, value)
 
-	def parse_types_from_source(self, source, filename=None, include_dirs=[]):
+	def parse_types_from_source(self, source, filename=None, include_dirs=[], auto_type_source=None):
 		"""
 		``parse_types_from_source`` parses the source string and any needed headers searching for them in
 		the optional list of directories provided in ``include_dirs``.
@@ -1589,8 +1655,9 @@ class Architecture(object):
 		:param str source: source string to be parsed
 		:param str filename: optional source filename
 		:param list(str) include_dirs: optional list of string filename include directories
-		:return: a tuple of py:class:`TypeParserResult` and error string
-		:rtype: tuple(TypeParserResult,str)
+		:param str auto_type_source: optional source of types if used for automatically generated types
+		:return: py:class:`TypeParserResult` (a SyntaxError is thrown on parse error)
+		:rtype: TypeParserResult
 		:Example:
 
 			>>> arch.parse_types_from_source('int foo;\\nint bar(int x);\\nstruct bas{int x,y;};\\n')
@@ -1606,32 +1673,37 @@ class Architecture(object):
 			dir_buf[i] = str(include_dirs[i])
 		parse = core.BNTypeParserResult()
 		errors = ctypes.c_char_p()
-		result = core.BNParseTypesFromSource(self.handle, source, filename, parse, errors, dir_buf, len(include_dirs))
+		result = core.BNParseTypesFromSource(self.handle, source, filename, parse, errors, dir_buf,
+			len(include_dirs), auto_type_source)
 		error_str = errors.value
 		core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte)))
 		if not result:
-			return (None, error_str)
+			raise SyntaxError(error_str)
 		type_dict = {}
 		variables = {}
 		functions = {}
 		for i in xrange(0, parse.typeCount):
-			types[parse.types[i].name] = types.Type(core.BNNewTypeReference(parse.types[i].type))
+			name = types.QualifiedName._from_core_struct(parse.types[i].name)
+			type_dict[name] = types.Type(core.BNNewTypeReference(parse.types[i].type))
 		for i in xrange(0, parse.variableCount):
-			variables[parse.variables[i].name] = types.Type(core.BNNewTypeReference(parse.variables[i].type))
+			name = types.QualifiedName._from_core_struct(parse.variables[i].name)
+			variables[name] = types.Type(core.BNNewTypeReference(parse.variables[i].type))
 		for i in xrange(0, parse.functionCount):
-			functions[parse.functions[i].name] = types.Type(core.BNNewTypeReference(parse.functions[i].type))
+			name = types.QualifiedName._from_core_struct(parse.functions[i].name)
+			functions[name] = types.Type(core.BNNewTypeReference(parse.functions[i].type))
 		core.BNFreeTypeParserResult(parse)
-		return (types.TypeParserResult(type_dict, variables, functions), error_str)
+		return types.TypeParserResult(type_dict, variables, functions)
 
-	def parse_types_from_source_file(self, filename, include_dirs=[]):
+	def parse_types_from_source_file(self, filename, include_dirs=[], auto_type_source=None):
 		"""
 		``parse_types_from_source_file`` parses the source file ``filename`` and any needed headers searching for them in
 		the optional list of directories provided in ``include_dirs``.
 
 		:param str filename: filename of file to be parsed
 		:param list(str) include_dirs: optional list of string filename include directories
-		:return: a tuple of py:class:`TypeParserResult` and error string
-		:rtype: tuple(TypeParserResult, str)
+		:param str auto_type_source: optional source of types if used for automatically generated types
+		:return: py:class:`TypeParserResult` (a SyntaxError is thrown on parse error)
+		:rtype: TypeParserResult
 		:Example:
 
 			>>> file = "/Users/binja/tmp.c"
@@ -1647,22 +1719,26 @@ class Architecture(object):
 			dir_buf[i] = str(include_dirs[i])
 		parse = core.BNTypeParserResult()
 		errors = ctypes.c_char_p()
-		result = core.BNParseTypesFromSourceFile(self.handle, filename, parse, errors, dir_buf, len(include_dirs))
+		result = core.BNParseTypesFromSourceFile(self.handle, filename, parse, errors, dir_buf,
+			len(include_dirs), auto_type_source)
 		error_str = errors.value
 		core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte)))
 		if not result:
-			return (None, error_str)
+			raise SyntaxError(error_str)
 		type_dict = {}
 		variables = {}
 		functions = {}
 		for i in xrange(0, parse.typeCount):
-			type_dict[parse.types[i].name] = types.Type(core.BNNewTypeReference(parse.types[i].type))
+			name = types.QualifiedName._from_core_struct(parse.types[i].name)
+			type_dict[name] = types.Type(core.BNNewTypeReference(parse.types[i].type))
 		for i in xrange(0, parse.variableCount):
-			variables[parse.variables[i].name] = types.Type(core.BNNewTypeReference(parse.variables[i].type))
+			name = types.QualifiedName._from_core_struct(parse.variables[i].name)
+			variables[name] = types.Type(core.BNNewTypeReference(parse.variables[i].type))
 		for i in xrange(0, parse.functionCount):
-			functions[parse.functions[i].name] = types.Type(core.BNNewTypeReference(parse.functions[i].type))
+			name = types.QualifiedName._from_core_struct(parse.functions[i].name)
+			functions[name] = types.Type(core.BNNewTypeReference(parse.functions[i].type))
 		core.BNFreeTypeParserResult(parse)
-		return (types.TypeParserResult(type_dict, variables, functions), error_str)
+		return types.TypeParserResult(type_dict, variables, functions)
 
 	def register_calling_convention(self, cc):
 		"""
diff --git a/python/associateddatastore.py b/python/associateddatastore.py
index 6b5e688e..c9b35ee0 100644
--- a/python/associateddatastore.py
+++ b/python/associateddatastore.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/basicblock.py b/python/basicblock.py
index 02e6a2c5..3dc5b050 100644
--- a/python/basicblock.py
+++ b/python/basicblock.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -29,19 +29,23 @@ import function
 
 
 class BasicBlockEdge(object):
-	def __init__(self, branch_type, target, arch):
+	def __init__(self, branch_type, source, target):
 		self.type = branch_type
-		if self.type != BranchType.UnresolvedBranch:
-			self.target = target
-			self.arch = arch
+		self.source = source
+		self.target = target
 
 	def __repr__(self):
 		if self.type == BranchType.UnresolvedBranch:
 			return "<%s>" % BranchType(self.type).name
-		elif self.arch:
-			return "<%s: %s@%#x>" % (self.type, self.arch.name, self.target)
+		elif self.target.arch:
+			return "<%s: %s@%#x>" % (BranchType(self.type).name, self.target.arch.name, self.target.start)
 		else:
-			return "<%s: %#x>" % (self.type, self.target)
+			return "<%s: %#x>" % (BranchType(self.type).name, self.target.start)
+
+	@property
+	def back_edge(self):
+		"""Whether the edge is a back edge (end of a loop)"""
+		return self.target in self.source.dominators
 
 
 class BasicBlock(object):
@@ -52,6 +56,16 @@ class BasicBlock(object):
 	def __del__(self):
 		core.BNFreeBasicBlock(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, BasicBlock):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, BasicBlock):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def function(self):
 		"""Basic block function (read-only)"""
@@ -84,20 +98,40 @@ class BasicBlock(object):
 		return core.BNGetBasicBlockLength(self.handle)
 
 	@property
+	def index(self):
+		"""Basic block index in list of blocks for the function (read-only)"""
+		return core.BNGetBasicBlockIndex(self.handle)
+
+	@property
 	def outgoing_edges(self):
 		"""List of basic block outgoing edges (read-only)"""
 		count = ctypes.c_ulonglong(0)
 		edges = core.BNGetBasicBlockOutgoingEdges(self.handle, count)
 		result = []
 		for i in xrange(0, count.value):
-			branch_type = edges[i].type
-			target = edges[i].target
-			if edges[i].arch:
-				arch = architecture.Architecture(edges[i].arch)
+			branch_type = BranchType(edges[i].type)
+			if edges[i].target:
+				target = BasicBlock(self.view, core.BNNewBasicBlockReference(edges[i].target))
 			else:
-				arch = None
-			result.append(BasicBlockEdge(branch_type, target, arch))
-		core.BNFreeBasicBlockOutgoingEdgeList(edges)
+				target = None
+			result.append(BasicBlockEdge(branch_type, self, target))
+		core.BNFreeBasicBlockEdgeList(edges, count.value)
+		return result
+
+	@property
+	def incoming_edges(self):
+		"""List of basic block incoming edges (read-only)"""
+		count = ctypes.c_ulonglong(0)
+		edges = core.BNGetBasicBlockIncomingEdges(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			branch_type = BranchType(edges[i].type)
+			if edges[i].target:
+				target = BasicBlock(self.view, core.BNNewBasicBlockReference(edges[i].target))
+			else:
+				target = None
+			result.append(BasicBlockEdge(branch_type, self, target))
+		core.BNFreeBasicBlockEdgeList(edges, count.value)
 		return result
 
 	@property
@@ -106,9 +140,61 @@ class BasicBlock(object):
 		return core.BNBasicBlockHasUndeterminedOutgoingEdges(self.handle)
 
 	@property
+	def dominators(self):
+		"""List of dominators for this basic block (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetBasicBlockDominators(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BasicBlock(self.view, core.BNNewBasicBlockReference(blocks[i])))
+		core.BNFreeBasicBlockList(blocks, count.value)
+		return result
+
+	@property
+	def strict_dominators(self):
+		"""List of strict dominators for this basic block (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetBasicBlockStrictDominators(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BasicBlock(self.view, core.BNNewBasicBlockReference(blocks[i])))
+		core.BNFreeBasicBlockList(blocks, count.value)
+		return result
+
+	@property
+	def immediate_dominator(self):
+		"""Immediate dominator of this basic block (read-only)"""
+		result = core.BNGetBasicBlockImmediateDominator(self.handle)
+		if not result:
+			return None
+		return BasicBlock(self.view, result)
+
+	@property
+	def dominator_tree_children(self):
+		"""List of child blocks in the dominator tree for this basic block (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetBasicBlockDominatorTreeChildren(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BasicBlock(self.view, core.BNNewBasicBlockReference(blocks[i])))
+		core.BNFreeBasicBlockList(blocks, count.value)
+		return result
+
+	@property
+	def dominance_frontier(self):
+		"""Dominance frontier for this basic block (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetBasicBlockDominanceFrontier(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BasicBlock(self.view, core.BNNewBasicBlockReference(blocks[i])))
+		core.BNFreeBasicBlockList(blocks, count.value)
+		return result
+
+	@property
 	def annotations(self):
 		"""List of automatic annotations for the start of this block (read-only)"""
-		return self.function.get_block_annotations(self.arch, self.start)
+		return self.function.get_block_annotations(self.start, self.arch)
 
 	@property
 	def disassembly_text(self):
@@ -144,6 +230,21 @@ class BasicBlock(object):
 	def highlight(self, value):
 		self.set_user_highlight(value)
 
+	@classmethod
+	def get_iterated_dominance_frontier(self, blocks):
+		if len(blocks) == 0:
+			return []
+		block_set = (ctypes.POINTER(core.BNBasicBlock) * len(blocks))()
+		for i in xrange(len(blocks)):
+			block_set[i] = blocks[i].handle
+		count = ctypes.c_ulonglong()
+		out_blocks = core.BNGetBasicBlockIteratedDominanceFrontier(block_set, len(blocks), count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BasicBlock(blocks[0].view, core.BNNewBasicBlockReference(out_blocks[i])))
+		core.BNFreeBasicBlockList(out_blocks, count.value)
+		return result
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self, name, value)
@@ -200,7 +301,9 @@ class BasicBlock(object):
 				value = lines[i].tokens[j].value
 				size = lines[i].tokens[j].size
 				operand = lines[i].tokens[j].operand
-				tokens.append(function.InstructionTextToken(token_type, text, value, size, operand))
+				context = lines[i].tokens[j].context
+				address = lines[i].tokens[j].address
+				tokens.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
 			result.append(function.DisassemblyTextLine(addr, tokens))
 		core.BNFreeDisassemblyTextLines(lines, count.value)
 		return result
diff --git a/python/binaryview.py b/python/binaryview.py
index c021024f..c0ac0abc 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -78,6 +78,12 @@ class BinaryDataNotification(object):
 	def string_removed(self, view, string_type, offset, length):
 		pass
 
+	def type_defined(self, view, name, type):
+		pass
+
+	def type_undefined(self, view, name, type):
+		pass
+
 
 class StringReference(object):
 	def __init__(self, string_type, start, length):
@@ -157,6 +163,8 @@ class BinaryDataNotificationCallbacks(object):
 		self._cb.dataVariableUpdated = self._cb.dataVariableUpdated.__class__(self._data_var_updated)
 		self._cb.stringFound = self._cb.stringFound.__class__(self._string_found)
 		self._cb.stringRemoved = self._cb.stringRemoved.__class__(self._string_removed)
+		self._cb.typeDefined = self._cb.typeDefined.__class__(self._type_defined)
+		self._cb.typeUndefined = self._cb.typeUndefined.__class__(self._type_undefined)
 
 	def _register(self):
 		core.BNRegisterDataNotification(self.view.handle, self._cb)
@@ -202,27 +210,27 @@ class BinaryDataNotificationCallbacks(object):
 
 	def _data_var_added(self, ctxt, view, var):
 		try:
-			address = var.address
-			var_type = types.Type(core.BNNewTypeReference(var.type))
-			auto_discovered = var.autoDiscovered
+			address = var[0].address
+			var_type = types.Type(core.BNNewTypeReference(var[0].type))
+			auto_discovered = var[0].autoDiscovered
 			self.notify.data_var_added(self.view, DataVariable(address, var_type, auto_discovered))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_var_removed(self, ctxt, view, var):
 		try:
-			address = var.address
-			var_type = types.Type(core.BNNewTypeReference(var.type))
-			auto_discovered = var.autoDiscovered
+			address = var[0].address
+			var_type = types.Type(core.BNNewTypeReference(var[0].type))
+			auto_discovered = var[0].autoDiscovered
 			self.notify.data_var_removed(self.view, DataVariable(address, var_type, auto_discovered))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_var_updated(self, ctxt, view, var):
 		try:
-			address = var.address
-			var_type = types.Type(core.BNNewTypeReference(var.type))
-			auto_discovered = var.autoDiscovered
+			address = var[0].address
+			var_type = types.Type(core.BNNewTypeReference(var[0].type))
+			auto_discovered = var[0].autoDiscovered
 			self.notify.data_var_updated(self.view, DataVariable(address, var_type, auto_discovered))
 		except:
 			log.log_error(traceback.format_exc())
@@ -239,6 +247,20 @@ class BinaryDataNotificationCallbacks(object):
 		except:
 			log.log_error(traceback.format_exc())
 
+	def _type_defined(self, ctxt, view, name, type_obj):
+		try:
+			qualified_name = types.QualifiedName._from_core_struct(name[0])
+			self.notify.type_defined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj)))
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _type_undefined(self, ctxt, view, name, type_obj):
+		try:
+			qualified_name = types.QualifiedName._from_core_struct(name[0])
+			self.notify.type_undefined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj)))
+		except:
+			log.log_error(traceback.format_exc())
+
 
 class _BinaryViewTypeMetaclass(type):
 	@property
@@ -277,6 +299,16 @@ class BinaryViewType(object):
 	def __init__(self, handle):
 		self.handle = core.handle_of_type(handle, core.BNBinaryViewType)
 
+	def __eq__(self, value):
+		if not isinstance(value, BinaryViewType):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, BinaryViewType):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def name(self):
 		"""BinaryView name (read-only)"""
@@ -525,6 +557,16 @@ class BinaryView(object):
 		self.notifications = {}
 		self.next_address = None  # Do NOT try to access view before init() is called, use placeholder
 
+	def __eq__(self, value):
+		if not isinstance(value, BinaryView):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, BinaryView):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@classmethod
 	def register(cls):
 		startup._init_plugins()
@@ -599,7 +641,7 @@ class BinaryView(object):
 	@classmethod
 	def set_default_session_data(cls, name, value):
 		"""
-		```set_default_session_data``` saves a variable to the BinaryView.
+		``set_default_session_data`` saves a variable to the BinaryView.
 		:param name: name of the variable to be saved
 		:param value: value of the variable to be saved
 
@@ -825,7 +867,8 @@ class BinaryView(object):
 		type_list = core.BNGetAnalysisTypeList(self.handle, count)
 		result = {}
 		for i in xrange(0, count.value):
-			result[type_list[i].name] = types.Type(core.BNNewTypeReference(type_list[i].type))
+			name = types.QualifiedName._from_core_struct(type_list[i].name)
+			result[name] = types.Type(core.BNNewTypeReference(type_list[i].type))
 		core.BNFreeTypeList(type_list, count.value)
 		return result
 
@@ -1286,7 +1329,7 @@ class BinaryView(object):
 
 	def perform_is_offset_executable(self, addr):
 		"""
-		``perform_is_offset_writable`` implements a check if a virtual address ``addr`` is executable.
+		``perform_is_offset_executable`` implements a check if a virtual address ``addr`` is executable.
 
 		.. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide
 		data without overriding this method.
@@ -1367,7 +1410,7 @@ class BinaryView(object):
 
 	def create_database(self, filename, progress_func=None):
 		"""
-		``perform_get_database`` writes the current database (.bndb) file out to the specified file.
+		``create_database`` writes the current database (.bndb) file out to the specified file.
 
 		:param str filename: path and filename to write the bndb to, this string `should` have ".bndb" appended to it.
 		:param callable() progress_func: optional function to be called with the current progress and total count.
@@ -1808,7 +1851,7 @@ class BinaryView(object):
 
 	def define_user_data_var(self, addr, var_type):
 		"""
-		``define_data_var`` defines a user data variable ``var_type`` at the virtual address ``addr``.
+		``define_user_data_var`` defines a user data variable ``var_type`` at the virtual address ``addr``.
 
 		:param int addr: virtual address to define the given data variable
 		:param binaryninja.Type var_type: type to be defined at the given virtual address
@@ -1838,7 +1881,7 @@ class BinaryView(object):
 
 	def undefine_user_data_var(self, addr):
 		"""
-		``undefine_data_var`` removes the user data variable at the virtual address ``addr``.
+		``undefine_user_data_var`` removes the user data variable at the virtual address ``addr``.
 
 		:param int addr: virtual address to define the data variable to be removed
 		:rtype: None
@@ -1867,7 +1910,7 @@ class BinaryView(object):
 		var = core.BNDataVariable()
 		if not core.BNGetDataVariableAtAddress(self.handle, addr, var):
 			return None
-		return DataVariable(var.address, type.Type(var.type), var.autoDiscovered)
+		return DataVariable(var.address, types.Type(var.type), var.autoDiscovered)
 
 	def get_function_at(self, addr, plat=None):
 		"""
@@ -2102,6 +2145,8 @@ class BinaryView(object):
 		"""
 		``define_auto_symbol`` adds a symbol to the internal list of automatically discovered Symbol objects.
 
+		.. warning:: If multiple symbols for the same address are defined, only the most recent symbol will ever be used.
+
 		:param Symbol sym: the symbol to define
 		:rtype: None
 		"""
@@ -2111,6 +2156,8 @@ class BinaryView(object):
 		"""
 		``define_auto_symbol_and_var_or_function``
 
+		.. warning:: If multiple symbols for the same address are defined, only the most recent symbol will ever be used.
+
 		:param Symbol sym: the symbol to define
 		:param SymbolType sym_type: Type of symbol being defined
 		:param Platform plat: (optional) platform
@@ -2137,6 +2184,8 @@ class BinaryView(object):
 		"""
 		``define_user_symbol`` adds a symbol to the internal list of user added Symbol objects.
 
+		.. warning:: If multiple symbols for the same address are defined, only the most recent symbol will ever be used.
+
 		:param Symbol sym: the symbol to define
 		:rtype: None
 		"""
@@ -2731,7 +2780,9 @@ class BinaryView(object):
 				value = lines[i].contents.tokens[j].value
 				size = lines[i].contents.tokens[j].size
 				operand = lines[i].contents.tokens[j].operand
-				tokens.append(function.InstructionTextToken(token_type, text, value, size, operand))
+				context = lines[i].contents.tokens[j].context
+				address = lines[i].contents.tokens[j].address
+				tokens.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
 			contents = function.DisassemblyTextLine(addr, tokens)
 			result.append(lineardisassembly.LinearDisassemblyLine(lines[i].type, func, block, lines[i].lineOffset, contents))
 
@@ -2831,51 +2882,117 @@ class BinaryView(object):
 		``parse_type_string`` converts `C-style` string into a :py:Class:`Type`.
 
 		:param str text: `C-style` string of type to create
-		:return: A tuple of a :py:Class:`Type` and string type name
-		:rtype: tuple(Type, str)
+		:return: A tuple of a :py:Class:`Type` and type name
+		:rtype: tuple(Type, QualifiedName)
 		:Example:
 
 			>>> bv.parse_type_string("int foo")
 			(<type: int32_t>, 'foo')
 			>>>
 		"""
-		result = core.BNNameAndType()
+		result = core.BNQualifiedNameAndType()
 		errors = ctypes.c_char_p()
 		if not core.BNParseTypeString(self.handle, text, result, errors):
 			error_str = errors.value
 			core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte)))
 			raise SyntaxError(error_str)
 		type_obj = types.Type(core.BNNewTypeReference(result.type))
-		name = result.name
-		core.BNFreeNameAndType(result)
+		name = types.QualifiedName._from_core_struct(result.name)
+		core.BNFreeQualifiedNameAndType(result)
 		return type_obj, name
 
 	def get_type_by_name(self, name):
 		"""
 		``get_type_by_name`` returns the defined type whose name corresponds with the provided ``name``
 
-		:param str name: Type name to lookup
+		:param QualifiedName name: Type name to lookup
 		:return: A :py:Class:`Type` or None if the type does not exist
 		:rtype: Type or None
 		:Example:
 
 			>>> type, name = bv.parse_type_string("int foo")
-			>>> bv.define_type(name, type)
+			>>> bv.define_user_type(name, type)
 			>>> bv.get_type_by_name(name)
 			<type: int32_t>
 			>>>
 		"""
+		name = types.QualifiedName(name)._get_core_struct()
 		obj = core.BNGetAnalysisTypeByName(self.handle, name)
 		if not obj:
 			return None
 		return types.Type(obj)
 
+	def get_type_by_id(self, id):
+		"""
+		``get_type_by_id`` returns the defined type whose unique identifier corresponds with the provided ``id``
+
+		:param str id: Unique identifier to lookup
+		:return: A :py:Class:`Type` or None if the type does not exist
+		:rtype: Type or None
+		:Example:
+
+			>>> type, name = bv.parse_type_string("int foo")
+			>>> type_id = Type.generate_auto_type_id("source", name)
+			>>> bv.define_type(type_id, name, type)
+			>>> bv.get_type_by_id(type_id)
+			<type: int32_t>
+			>>>
+		"""
+		obj = core.BNGetAnalysisTypeById(self.handle, id)
+		if not obj:
+			return None
+		return types.Type(obj)
+
+	def get_type_name_by_id(self, id):
+		"""
+		``get_type_name_by_id`` returns the defined type name whose unique identifier corresponds with the provided ``id``
+
+		:param str id: Unique identifier to lookup
+		:return: A QualifiedName or None if the type does not exist
+		:rtype: QualifiedName or None
+		:Example:
+
+			>>> type, name = bv.parse_type_string("int foo")
+			>>> type_id = Type.generate_auto_type_id("source", name)
+			>>> bv.define_type(type_id, name, type)
+			'foo'
+			>>> bv.get_type_name_by_id(type_id)
+			'foo'
+			>>>
+		"""
+		name = core.BNGetAnalysisTypeNameById(self.handle, id)
+		result = types.QualifiedName._from_core_struct(name)
+		core.BNFreeQualifiedName(name)
+		if len(result) == 0:
+			return None
+		return result
+
+	def get_type_id(self, name):
+		"""
+		``get_type_id`` returns the unique indentifier of the defined type whose name corresponds with the
+		provided ``name``
+
+		:param QualifiedName name: Type name to lookup
+		:return: The unique identifier of the type
+		:rtype: str
+		:Example:
+
+			>>> type, name = bv.parse_type_string("int foo")
+			>>> type_id = Type.generate_auto_type_id("source", name)
+			>>> registered_name = bv.define_type(type_id, name, type)
+			>>> bv.get_type_id(registered_name) == type_id
+			True
+			>>>
+		"""
+		name = types.QualifiedName(name)._get_core_struct()
+		return core.BNGetAnalysisTypeId(self.handle, name)
+
 	def is_type_auto_defined(self, name):
 		"""
 		``is_type_auto_defined`` queries the user type list of name. If name is not in the *user* type list then the name
 		is considered an *auto* type.
 
-		:param str name: Name of type to query
+		:param QualifiedName name: Name of type to query
 		:return: True if the type is not a *user* type. False if the type is a *user* type.
 		:Example:
 			>>> bv.is_type_auto_defined("foo")
@@ -2885,31 +3002,38 @@ class BinaryView(object):
 			False
 			>>>
 		"""
+		name = types.QualifiedName(name)._get_core_struct()
 		return core.BNIsAnalysisTypeAutoDefined(self.handle, name)
 
-	def define_type(self, name, type_obj):
+	def define_type(self, type_id, default_name, type_obj):
 		"""
 		``define_type`` registers a :py:Class:`Type` ``type_obj`` of the given ``name`` in the global list of types for
-		the current :py:Class:`BinaryView`.
+		the current :py:Class:`BinaryView`. This method should only be used for automatically generated types.
 
-		:param str name: Name of the type to be registered
+		:param str type_id: Unique identifier for the automatically generated type
+		:param QualifiedName default_name: Name of the type to be registered
 		:param Type type_obj: Type object to be registered
-		:rtype: None
+		:return: Registered name of the type. May not be the same as the requested name if the user has renamed types.
+		:rtype: QualifiedName
 		:Example:
 
 			>>> type, name = bv.parse_type_string("int foo")
-			>>> bv.define_type(name, type)
-			>>> bv.get_type_by_name(name)
+			>>> registered_name = bv.define_type(Type.generate_auto_type_id("source", name), name, type)
+			>>> bv.get_type_by_name(registered_name)
 			<type: int32_t>
 		"""
-		core.BNDefineAnalysisType(self.handle, name, type_obj.handle)
+		name = types.QualifiedName(default_name)._get_core_struct()
+		reg_name = core.BNDefineAnalysisType(self.handle, type_id, name, type_obj.handle)
+		result = types.QualifiedName._from_core_struct(reg_name)
+		core.BNFreeQualifiedName(reg_name)
+		return result
 
 	def define_user_type(self, name, type_obj):
 		"""
 		``define_user_type`` registers a :py:Class:`Type` ``type_obj`` of the given ``name`` in the global list of user
 		types for the current :py:Class:`BinaryView`.
 
-		:param str name: Name of the user type to be registered
+		:param QualifiedName name: Name of the user type to be registered
 		:param Type type_obj: Type object to be registered
 		:rtype: None
 		:Example:
@@ -2919,45 +3043,86 @@ class BinaryView(object):
 			>>> bv.get_type_by_name(name)
 			<type: int32_t>
 		"""
+		name = types.QualifiedName(name)._get_core_struct()
 		core.BNDefineUserAnalysisType(self.handle, name, type_obj.handle)
 
-	def undefine_type(self, name):
+	def undefine_type(self, type_id):
 		"""
 		``undefine_type`` removes a :py:Class:`Type` from the global list of types for the current :py:Class:`BinaryView`
 
-		:param str name: Name of type to be undefined
+		:param str type_id: Unique identifier of type to be undefined
 		:rtype: None
 		:Example:
 
 			>>> type, name = bv.parse_type_string("int foo")
-			>>> bv.define_type(name, type)
+			>>> type_id = Type.generate_auto_type_id("source", name)
+			>>> bv.define_type(type_id, name, type)
 			>>> bv.get_type_by_name(name)
 			<type: int32_t>
-			>>> bv.undefine_type(name)
+			>>> bv.undefine_type(type_id)
 			>>> bv.get_type_by_name(name)
 			>>>
 		"""
-		core.BNUndefineAnalysisType(self.handle, name)
+		core.BNUndefineAnalysisType(self.handle, type_id)
 
 	def undefine_user_type(self, name):
 		"""
 		``undefine_user_type`` removes a :py:Class:`Type` from the global list of user types for the current
 		:py:Class:`BinaryView`
 
-		:param str name: Name of user type to be undefined
+		:param QualifiedName name: Name of user type to be undefined
 		:rtype: None
 		:Example:
 
 			>>> type, name = bv.parse_type_string("int foo")
-			>>> bv.define_type(name, type)
+			>>> bv.define_user_type(name, type)
 			>>> bv.get_type_by_name(name)
 			<type: int32_t>
-			>>> bv.undefine_type(name)
+			>>> bv.undefine_user_type(name)
 			>>> bv.get_type_by_name(name)
 			>>>
 		"""
+		name = types.QualifiedName(name)._get_core_struct()
 		core.BNUndefineUserAnalysisType(self.handle, name)
 
+	def rename_type(self, old_name, new_name):
+		"""
+		``rename_type`` renames a type in the global list of types for the current :py:Class:`BinaryView`
+
+		:param QualifiedName old_name: Existing name of type to be renamed
+		:param QualifiedName new_name: New name of type to be renamed
+		:rtype: None
+		:Example:
+
+			>>> type, name = bv.parse_type_string("int foo")
+			>>> bv.define_user_type(name, type)
+			>>> bv.get_type_by_name("foo")
+			<type: int32_t>
+			>>> bv.rename_type("foo", "bar")
+			>>> bv.get_type_by_name("bar")
+			<type: int32_t>
+			>>>
+		"""
+		old_name = types.QualifiedName(old_name)._get_core_struct()
+		new_name = types.QualifiedName(new_name)._get_core_struct()
+		core.BNRenameAnalysisType(self.handle, old_name, new_name)
+
+	def register_platform_types(self, platform):
+		"""
+		``register_platform_types`` ensures that the platform-specific types for a :py:Class:`Platform` are available
+		for the current :py:Class:`BinaryView`. This is automatically performed when adding a new function or setting
+		the default platform.
+
+		:param Platform platform: Platform containing types to be registered
+		:rtype: None
+		:Example:
+
+			>>> platform = Platform["linux-x86"]
+			>>> bv.register_platform_types(platform)
+			>>>
+		"""
+		core.BNRegisterPlatformTypes(self.handle, platform.handle)
+
 	def find_next_data(self, start, data, flags = 0):
 		"""
 		``find_next_data`` searchs for the bytes in data starting at the virtual address ``start`` either, case-sensitive,
@@ -3025,6 +3190,12 @@ class BinaryView(object):
 			segment.flags)
 		return result
 
+	def get_address_for_data_offset(self, offset):
+		address = ctypes.c_ulonglong()
+		if not core.BNGetAddressForDataOffset(self.handle, offset, address):
+			return None
+		return address.value
+
 	def add_auto_section(self, name, start, length, type = "", align = 1, entry_size = 1, linked_section = "",
 		info_section = "", info_data = 0):
 		core.BNAddAutoSection(self.handle, name, start, length, type, align, entry_size, linked_section,
@@ -3110,6 +3281,16 @@ class BinaryReader(object):
 	def __del__(self):
 		core.BNFreeBinaryReader(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, BinaryReader):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, BinaryReader):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def endianness(self):
 		"""
@@ -3417,6 +3598,16 @@ class BinaryWriter(object):
 	def __del__(self):
 		core.BNFreeBinaryWriter(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, BinaryWriter):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, BinaryWriter):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def endianness(self):
 		"""
@@ -3591,7 +3782,7 @@ class BinaryWriter(object):
 			>>> hex(bw.offset)
 			'0x100000008L'
 			>>> bw.seek(0x100000000)
-			>>> hex(br.offset)
+			>>> hex(bw.offset)
 			'0x100000000L'
 			>>>
 		"""
@@ -3608,7 +3799,7 @@ class BinaryWriter(object):
 			>>> hex(bw.offset)
 			'0x100000008L'
 			>>> bw.seek_relative(-8)
-			>>> hex(br.offset)
+			>>> hex(bw.offset)
 			'0x100000000L'
 			>>>
 		"""
diff --git a/python/callingconvention.py b/python/callingconvention.py
index 5f4adeab..4c87eef6 100644
--- a/python/callingconvention.py
+++ b/python/callingconvention.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -112,6 +112,16 @@ class CallingConvention(object):
 	def __del__(self):
 		core.BNFreeCallingConvention(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, CallingConvention):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, CallingConvention):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	def _get_caller_saved_regs(self, ctxt, count):
 		try:
 			regs = self.__class__.caller_saved_regs
diff --git a/python/databuffer.py b/python/databuffer.py
index 6b3423da..3f9e4ce5 100644
--- a/python/databuffer.py
+++ b/python/databuffer.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/demangle.py b/python/demangle.py
index ed38674a..11673263 100644
--- a/python/demangle.py
+++ b/python/demangle.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -48,8 +48,8 @@ def demangle_ms(arch, mangled_name):
 
 	:param Architecture arch: Architecture for the symbol. Required for pointer and integer sizes.
 	:param str mangled_name: a mangled Microsoft Visual Studio C++ name
-	:return: returns a Type object for the mangled name
-	:rtype: Type
+	:return: returns tuple of (Type, demangled_name) or (None, mangled_name) on error
+	:rtype: Tuple
 	:Example:
 
 		>>> demangle_ms(Architecture["x86_64"], "?testf@Foobar@@SA?AW4foo@1@W421@@Z")
diff --git a/python/examples/angr_plugin.py b/python/examples/angr_plugin.py
index 90217d65..c84373be 100644
--- a/python/examples/angr_plugin.py
+++ b/python/examples/angr_plugin.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/bin_info.py b/python/examples/bin_info.py
index 4c4ab8fd..17a96685 100644
--- a/python/examples/bin_info.py
+++ b/python/examples/bin_info.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -38,7 +38,6 @@ def get_bininfo(bv):
 				sys.exit(1)
 
 		bv = BinaryViewType.get_view_of_file(filename)
-		log.redirect_output_to_log()
 		log.log_to_stdout(True)
 
 	contents = "## %s ##\n" % bv.file.filename
diff --git a/python/examples/breakpoint.py b/python/examples/breakpoint.py
index b1297e26..a2801511 100644
--- a/python/examples/breakpoint.py
+++ b/python/examples/breakpoint.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/export_svg.py b/python/examples/export_svg.py
index 89bc41a1..7814c9fd 100755
--- a/python/examples/export_svg.py
+++ b/python/examples/export_svg.py
@@ -1,6 +1,7 @@
 # from binaryninja import *
 import os
 import webbrowser
+import time
 try:
 	from urllib import pathname2url          # Python 2.x
 except:
@@ -34,7 +35,7 @@ def save_svg(bv, function):
 	outputfile = get_save_filename_input('File name for export_svg', 'HTML files (*.html)', filename)
 	if outputfile is None:
 		return
-	content = render_svg(function)
+	content = render_svg(function, origname)
 	output = open(outputfile, 'w')
 	output.write(content)
 	output.close()
@@ -54,7 +55,7 @@ def instruction_data_flow(function, address):
 	return 'Opcode: {bytes}'.format(bytes=padded)
 
 
-def render_svg(function):
+def render_svg(function, origname):
 	graph = function.create_graph()
 	graph.layout_and_wait()
 	heightconst = 15
@@ -67,7 +68,13 @@ def render_svg(function):
 			@import url(https://fonts.googleapis.com/css?family=Source+Code+Pro);
 			body {
 				background-color: rgb(42, 42, 42);
+                                color: rgb(220, 220, 220);
+                                font-family: "Source Code Pro", "Lucida Console", "Consolas", monospace;
 			}
+                        a, a:visited  {
+                                color: rgb(200, 200, 200);
+                                font-weight: bold;
+                        }
 			svg {
 				background-color: rgb(42, 42, 42);
 				display: block;
@@ -80,6 +87,10 @@ def render_svg(function):
 				fill: none;
 				stroke-width: 1px;
 			}
+			.back_edge {
+				fill: none;
+				stroke-width: 2px;
+			}
 			.UnconditionalBranch, .IndirectBranch {
 				stroke: rgb(128, 198, 233);
 				color: rgb(128, 198, 233);
@@ -97,7 +108,7 @@ def render_svg(function):
 				fill: currentColor;
 			}
 			text {
-				font-family: 'Source Code Pro';
+                                font-family: "Source Code Pro", "Lucida Console", "Consolas", monospace;
 				font-size: 9pt;
 				fill: rgb(224, 224, 224);
 			}
@@ -197,10 +208,16 @@ def render_svg(function):
 				points += str(x * widthconst) + "," + str(y * heightconst) + " "
 			x, y = edge.points[-1]
 			points += str(x * widthconst) + "," + str(y * heightconst + 0) + " "
-			edges += '		<polyline class="edge {type}" points="{points}" marker-end="url(#arrow-{type})"/>\n'.format(type=BranchType(edge.type).name, points=points)
+			if edge.back_edge:
+				edges += '		<polyline class="back_edge {type}" points="{points}" marker-end="url(#arrow-{type})"/>\n'.format(type=BranchType(edge.type).name, points=points)
+			else:
+				edges += '		<polyline class="edge {type}" points="{points}" marker-end="url(#arrow-{type})"/>\n'.format(type=BranchType(edge.type).name, points=points)
 	output += ' ' + edges + '\n'
 	output += '	</g>\n'
-	output += '</svg></html>'
+	output += '</svg>'
+
+        output += '<p>This CFG generated by <a href="https://binary.ninja/">Binary Ninja</a> from {filename} on {timestring}.</p>'.format(filename = origname, timestring = time.strftime("%c"))
+        output += '</html>'
 	return output
 
 
diff --git a/python/examples/instruction_iterator.py b/python/examples/instruction_iterator.py
index 7ff2d692..f55e1c1b 100644
--- a/python/examples/instruction_iterator.py
+++ b/python/examples/instruction_iterator.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/jump_table.py b/python/examples/jump_table.py
index 439e2ab6..419cc188 100644
--- a/python/examples/jump_table.py
+++ b/python/examples/jump_table.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/nds.py b/python/examples/nds.py
index ff137b4b..34d8a292 100644
--- a/python/examples/nds.py
+++ b/python/examples/nds.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/nes.py b/python/examples/nes.py
index 4122cde0..e55a90b7 100644
--- a/python/examples/nes.py
+++ b/python/examples/nes.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -191,21 +191,21 @@ OperandTokens = [
 
 def indirect_load(il, value):
 	if (value & 0xff) == 0xff:
-		lo_addr = il.const(2, value)
-		hi_addr = il.const(2, (value & 0xff00) | ((value + 1) & 0xff))
+		lo_addr = il.const_pointer(2, value)
+		hi_addr = il.const_pointer(2, (value & 0xff00) | ((value + 1) & 0xff))
 		lo = il.zero_extend(2, il.load(1, lo_addr))
 		hi = il.shift_left(2, il.zero_extend(2, il.load(1, hi_addr)), il.const(2, 8))
 		return il.or_expr(2, lo, hi)
-	return il.load(2, il.const(2, value))
+	return il.load(2, il.const_pointer(2, value))
 
 
 def load_zero_page_16(il, value):
 	if il[value].operation == LowLevelILOperation.LLIL_CONST:
-		if il[value].value == 0xff:
-			lo = il.zero_extend(2, il.load(1, il.const(2, 0xff)))
-			hi = il.shift_left(2, il.zero_extend(2, il.load(1, il.const(2, 0)), il.const(2, 8)))
+		if il[value].constant == 0xff:
+			lo = il.zero_extend(2, il.load(1, il.const_pointer(2, 0xff)))
+			hi = il.shift_left(2, il.zero_extend(2, il.load(1, il.const_pointer(2, 0)), il.const(2, 8)))
 			return il.or_expr(2, lo, hi)
-		return il.load(2, il.const(2, il[value].value))
+		return il.load(2, il.const_pointer(2, il[value].constant))
 	il.append(il.set_reg(1, LLIL_TEMP(0), value))
 	value = il.reg(1, LLIL_TEMP(0))
 	lo_addr = value
@@ -217,23 +217,23 @@ def load_zero_page_16(il, value):
 
 OperandIL = [
 	lambda il, value: None,  # NONE
-	lambda il, value: il.load(1, il.const(2, value)),  # ABS
+	lambda il, value: il.load(1, il.const_pointer(2, value)),  # ABS
 	lambda il, value: il.const(2, value),  # ABS_DEST
 	lambda il, value: il.load(1, il.add(2, il.const(2, value), il.zero_extend(2, il.reg(1, "x")))),  # ABS_X
 	lambda il, value: il.add(2, il.const(2, value), il.zero_extend(2, il.reg(1, "x"))),  # ABS_X_DEST
 	lambda il, value: il.load(1, il.add(2, il.const(2, value), il.zero_extend(2, il.reg(1, "y")))),  # ABS_Y
 	lambda il, value: il.add(2, il.const(2, value), il.zero_extend(2, il.reg(1, "y"))),  # ABS_Y_DEST
 	lambda il, value: il.reg(1, "a"),  # ACCUM
-	lambda il, value: il.const(2, value),  # ADDR
+	lambda il, value: il.const_pointer(2, value),  # ADDR
 	lambda il, value: il.const(1, value),  # IMMED
 	lambda il, value: indirect_load(il, value),  # IND
 	lambda il, value: il.load(1, load_zero_page_16(il, il.add(1, il.const(1, value), il.reg(1, "x")))),  # IND_X
 	lambda il, value: load_zero_page_16(il, il.add(1, il.const(1, value), il.reg(1, "x"))),  # IND_X_DEST
 	lambda il, value: il.load(1, il.add(2, load_zero_page_16(il, il.const(1, value)), il.reg(1, "y"))),  # IND_Y
 	lambda il, value: il.add(2, load_zero_page_16(il, il.const(1, value)), il.reg(1, "y")),  # IND_Y_DEST
-	lambda il, value: il.const(2, value),  # REL
-	lambda il, value: il.load(1, il.const(2, value)),  # ZERO
-	lambda il, value: il.const(2, value),  # ZERO_DEST
+	lambda il, value: il.const_pointer(2, value),  # REL
+	lambda il, value: il.load(1, il.const_pointer(2, value)),  # ZERO
+	lambda il, value: il.const_pointer(2, value),  # ZERO_DEST
 	lambda il, value: il.load(1, il.zero_extend(2, il.add(1, il.const(1, value), il.reg(1, "x")))),  # ZERO_X
 	lambda il, value: il.zero_extend(2, il.add(1, il.const(1, value), il.reg(1, "x"))),  # ZERO_X_DEST
 	lambda il, value: il.load(1, il.zero_extend(2, il.add(1, il.const(1, value), il.reg(1, "y")))),  # ZERO_Y
@@ -244,7 +244,7 @@ OperandIL = [
 def cond_branch(il, cond, dest):
 	t = None
 	if il[dest].operation == LowLevelILOperation.LLIL_CONST:
-		t = il.get_label_for_address(Architecture['6502'], il[dest].value)
+		t = il.get_label_for_address(Architecture['6502'], il[dest].constant)
 	if t is None:
 		t = LowLevelILLabel()
 		indirect = True
@@ -262,7 +262,7 @@ def cond_branch(il, cond, dest):
 def jump(il, dest):
 	label = None
 	if il[dest].operation == LowLevelILOperation.LLIL_CONST:
-		label = il.get_label_for_address(Architecture['6502'], il[dest].value)
+		label = il.get_label_for_address(Architecture['6502'], il[dest].constant)
 	if label is None:
 		il.append(il.jump(dest))
 	else:
@@ -300,7 +300,7 @@ def rti(il):
 
 
 InstructionIL = {
-	"adc": lambda il, operand: il.set_reg(1, "a", il.add_carry(1, il.reg(1, "a"), operand, flags = "*")),
+	"adc": lambda il, operand: il.set_reg(1, "a", il.add_carry(1, il.reg(1, "a"), operand, il.flag("c"), flags = "*")),
 	"asl": lambda il, operand: il.store(1, operand, il.shift_left(1, il.load(1, operand), il.const(1, 1), flags = "czs")),
 	"asl@": lambda il, operand: il.set_reg(1, "a", il.shift_left(1, operand, il.const(1, 1), flags = "czs")),
 	"and": lambda il, operand: il.set_reg(1, "a", il.and_expr(1, il.reg(1, "a"), operand, flags = "zs")),
@@ -341,13 +341,13 @@ InstructionIL = {
 	"php": lambda il, operand: il.push(1, get_p_value(il)),
 	"pla": lambda il, operand: il.set_reg(1, "a", il.pop(1), flags = "zs"),
 	"plp": lambda il, operand: set_p_value(il, il.pop(1)),
-	"rol": lambda il, operand: il.store(1, operand, il.rotate_left_carry(1, il.load(1, operand), il.const(1, 1), flags = "czs")),
-	"rol@": lambda il, operand: il.set_reg(1, "a", il.rotate_left_carry(1, il.reg(1, "a"), il.const(1, 1), flags = "czs")),
-	"ror": lambda il, operand: il.store(1, operand, il.rotate_right_carry(1, il.load(1, operand), il.const(1, 1), flags = "czs")),
-	"ror@": lambda il, operand: il.set_reg(1, "a", il.rotate_right_carry(1, il.reg(1, "a"), il.const(1, 1), flags = "czs")),
+	"rol": lambda il, operand: il.store(1, operand, il.rotate_left_carry(1, il.load(1, operand), il.const(1, 1), il.flag("c"), flags = "czs")),
+	"rol@": lambda il, operand: il.set_reg(1, "a", il.rotate_left_carry(1, il.reg(1, "a"), il.const(1, 1), il.flag("c"), flags = "czs")),
+	"ror": lambda il, operand: il.store(1, operand, il.rotate_right_carry(1, il.load(1, operand), il.const(1, 1), il.flag("c"), flags = "czs")),
+	"ror@": lambda il, operand: il.set_reg(1, "a", il.rotate_right_carry(1, il.reg(1, "a"), il.const(1, 1), il.flag("c"), flags = "czs")),
 	"rti": lambda il, operand: rti(il),
 	"rts": lambda il, operand: il.ret(il.add(2, il.pop(2), il.const(2, 1))),
-	"sbc": lambda il, operand: il.set_reg(1, "a", il.sub_borrow(1, il.reg(1, "a"), operand, flags = "*")),
+	"sbc": lambda il, operand: il.set_reg(1, "a", il.sub_borrow(1, il.reg(1, "a"), operand, il.flag("c"), flags = "*")),
 	"sec": lambda il, operand: il.set_flag("c", il.const(0, 1)),
 	"sed": lambda il, operand: il.set_flag("d", il.const(0, 1)),
 	"sei": lambda il, operand: il.set_flag("i", il.const(0, 1)),
@@ -469,6 +469,15 @@ class M6502(Architecture):
 
 		return length
 
+	def perform_get_flag_write_low_level_il(self, op, size, write_type, flag, operands, il):
+		if flag == 'c':
+			if (op == LowLevelILOperation.LLIL_SUB) or (op == LowLevelILOperation.LLIL_SBB):
+				# Subtraction carry flag is inverted from the commom implementation
+				return il.not_expr(0, self.get_default_flag_write_low_level_il(op, size, FlagRole.CarryFlagRole, operands, il))
+			# Other operations use a normal carry flag
+			return self.get_default_flag_write_low_level_il(op, size, FlagRole.CarryFlagRole, operands, il)
+		return Architecture.perform_get_flag_write_low_level_il(self, op, size, write_type, flag, operands, il)
+
 	def perform_is_never_branch_patch_available(self, data, addr):
 		if (data[0] == "\x10") or (data[0] == "\x30") or (data[0] == "\x50") or (data[0] == "\x70") or (data[0] == "\x90") or (data[0] == "\xb0") or (data[0] == "\xd0") or (data[0] == "\xf0"):
 			return True
diff --git a/python/examples/notification_callbacks.py b/python/examples/notification_callbacks.py
new file mode 100644
index 00000000..b7c9cde9
--- /dev/null
+++ b/python/examples/notification_callbacks.py
@@ -0,0 +1,51 @@
+from binaryninja import BinaryDataNotification, PluginCommand, log_info
+import inspect
+
+def reg_notif(view):
+    demo_notification = DemoNotification(view)
+    view.register_notification(demo_notification)
+
+class DemoNotification(BinaryDataNotification):
+    def __init__(self, view):
+        self.view = view
+
+    def data_written(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def data_inserted(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def data_removed(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def function_added(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def function_removed(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def function_updated(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def data_var_added(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def data_var_updated(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def data_var_removed(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def string_found(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def string_removed(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def type_defined(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+    def type_undefined(self, *args):
+        log_info(inspect.stack()[0][3] + str(args))
+
+PluginCommand.register("Register Notification", "", reg_notif)
diff --git a/python/examples/nsf.py b/python/examples/nsf.py
index b1bac3a8..b0164065 100644
--- a/python/examples/nsf.py
+++ b/python/examples/nsf.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/print_syscalls.py b/python/examples/print_syscalls.py
index 2af4d38d..d995ad1e 100644
--- a/python/examples/print_syscalls.py
+++ b/python/examples/print_syscalls.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/examples/version_switcher.py b/python/examples/version_switcher.py
index 9d5bbf05..3e1cab40 100644
--- a/python/examples/version_switcher.py
+++ b/python/examples/version_switcher.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/fileaccessor.py b/python/fileaccessor.py
index 8fec43a1..2c1f1d19 100644
--- a/python/fileaccessor.py
+++ b/python/fileaccessor.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/filemetadata.py b/python/filemetadata.py
index f6593405..4bfc0214 100644
--- a/python/filemetadata.py
+++ b/python/filemetadata.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -93,6 +93,16 @@ class FileMetadata(object):
 			core.BNSetFileMetadataNavigationHandler(self.handle, None)
 		core.BNFreeFileMetadata(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, FileMetadata):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, FileMetadata):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@classmethod
 	def _unregister(cls, f):
 		handle = ctypes.cast(f, ctypes.c_void_p)
diff --git a/python/function.py b/python/function.py
index 9b00eec2..34511cfa 100644
--- a/python/function.py
+++ b/python/function.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -26,13 +26,15 @@ import ctypes
 import _binaryninjacore as core
 from enums import (FunctionGraphType, BranchType, SymbolType, InstructionTextTokenType,
 	HighlightStandardColor, HighlightColorStyle, RegisterValueType, ImplicitRegisterExtend,
-	DisassemblyOption, IntegerDisplayType)
+	DisassemblyOption, IntegerDisplayType, InstructionTextTokenContext, VariableSourceType)
 import architecture
+import platform
 import highlight
 import associateddatastore
 import types
 import basicblock
 import lowlevelil
+import mediumlevelil
 import binaryview
 import log
 
@@ -50,99 +52,168 @@ class RegisterValue(object):
 	def __init__(self, arch, value):
 		self.type = RegisterValueType(value.state)
 		if value.state == RegisterValueType.EntryValue:
-			self.reg = arch.get_reg_name(value.reg)
-		elif value.state == RegisterValueType.OffsetFromEntryValue:
-			self.reg = arch.get_reg_name(value.reg)
+			self.reg = arch.get_reg_name(value.value)
+		elif value.state == RegisterValueType.ConstantValue:
+			self.value = value.value
+		elif value.state == RegisterValueType.StackFrameOffset:
 			self.offset = value.value
+
+	def __repr__(self):
+		if self.type == RegisterValueType.EntryValue:
+			return "<entry %s>" % self.reg
+		if self.type == RegisterValueType.ConstantValue:
+			return "<const %#x>" % self.value
+		if self.type == RegisterValueType.StackFrameOffset:
+			return "<stack frame offset %#x>" % self.offset
+		if self.type == RegisterValueType.ReturnAddressValue:
+			return "<return address>"
+		return "<undetermined>"
+
+
+class ValueRange(object):
+	def __init__(self, start, end, step):
+		self.start = start
+		self.end = end
+		self.step = step
+
+	def __repr__(self):
+		if self.step == 1:
+			return "<range: %#x to %#x>" % (self.start, self.end)
+		return "<range: %#x to %#x, step %#x>" % (self.start, self.end, self.step)
+
+
+class PossibleValueSet(object):
+	def __init__(self, arch, value):
+		self.type = RegisterValueType(value.state)
+		if value.state == RegisterValueType.EntryValue:
+			self.reg = arch.get_reg_name(value.value)
 		elif value.state == RegisterValueType.ConstantValue:
 			self.value = value.value
 		elif value.state == RegisterValueType.StackFrameOffset:
 			self.offset = value.value
 		elif value.state == RegisterValueType.SignedRangeValue:
 			self.offset = value.value
-			self.start = value.rangeStart
-			self.end = value.rangeEnd
-			self.step = value.rangeStep
-			if self.start & (1 << 63):
-				self.start |= ~((1 << 63) - 1)
-			if self.end & (1 << 63):
-				self.end |= ~((1 << 63) - 1)
+			self.ranges = []
+			for i in xrange(0, value.count):
+				start = value.ranges[i].start
+				end = value.ranges[i].end
+				step = value.ranges[i].step
+				if start & (1 << 63):
+					start |= ~((1 << 63) - 1)
+				if end & (1 << 63):
+					end |= ~((1 << 63) - 1)
+				self.ranges.append(ValueRange(start, end, step))
 		elif value.state == RegisterValueType.UnsignedRangeValue:
 			self.offset = value.value
-			self.start = value.rangeStart
-			self.end = value.rangeEnd
-			self.step = value.rangeStep
+			self.ranges = []
+			for i in xrange(0, value.count):
+				start = value.ranges[i].start
+				end = value.ranges[i].end
+				step = value.ranges[i].step
+				self.ranges.append(ValueRange(start, end, step))
 		elif value.state == RegisterValueType.LookupTableValue:
 			self.table = []
 			self.mapping = {}
-			for i in xrange(0, value.rangeEnd):
+			for i in xrange(0, value.count):
 				from_list = []
 				for j in xrange(0, value.table[i].fromCount):
 					from_list.append(value.table[i].fromValues[j])
 					self.mapping[value.table[i].fromValues[j]] = value.table[i].toValue
 				self.table.append(LookupTableEntry(from_list, value.table[i].toValue))
-		elif value.state == RegisterValueType.OffsetFromUndeterminedValue:
-			self.offset = value.value
+		elif (value.state == RegisterValueType.InSetOfValues) or (value.state == RegisterValueType.NotInSetOfValues):
+			self.values = set()
+			for i in xrange(0, value.count):
+				self.values.add(value.valueSet[i])
 
 	def __repr__(self):
 		if self.type == RegisterValueType.EntryValue:
 			return "<entry %s>" % self.reg
-		if self.type == RegisterValueType.OffsetFromEntryValue:
-			return "<entry %s + %#x>" % (self.reg, self.offset)
 		if self.type == RegisterValueType.ConstantValue:
 			return "<const %#x>" % self.value
 		if self.type == RegisterValueType.StackFrameOffset:
 			return "<stack frame offset %#x>" % self.offset
-		if (self.type == RegisterValueType.SignedRangeValue) or (self.type == RegisterValueType.UnsignedRangeValue):
-			if self.step == 1:
-				return "<range: %#x to %#x>" % (self.start, self.end)
-			return "<range: %#x to %#x, step %#x>" % (self.start, self.end, self.step)
+		if self.type == RegisterValueType.SignedRangeValue:
+			return "<signed ranges: %s>" % repr(self.ranges)
+		if self.type == RegisterValueType.UnsignedRangeValue:
+			return "<unsigned ranges: %s>" % repr(self.ranges)
 		if self.type == RegisterValueType.LookupTableValue:
 			return "<table: %s>" % ', '.join([repr(i) for i in self.table])
-		if self.type == RegisterValueType.OffsetFromUndeterminedValue:
-			return "<undetermined with offset %#x>" % self.offset
+		if self.type == RegisterValueType.InSetOfValues:
+			return "<in %s>" % repr(self.values)
+		if self.type == RegisterValueType.NotInSetOfValues:
+			return "<not in %s>" % repr(self.values)
+		if self.type == RegisterValueType.ReturnAddressValue:
+			return "<return address>"
 		return "<undetermined>"
 
 
-class StackVariable(object):
-	def __init__(self, ofs, name, t):
-		self.offset = ofs
-		self.name = name
-		self.type = t
-
-	def __repr__(self):
-		return "<var@%x: %s %s>" % (self.offset, self.type, self.name)
-
-	def __str__(self):
-		return self.name
-
-
 class StackVariableReference(object):
-	def __init__(self, src_operand, t, name, start_ofs, ref_ofs):
+	def __init__(self, src_operand, t, name, var, ref_ofs):
 		self.source_operand = src_operand
 		self.type = t
 		self.name = name
-		self.starting_offset = start_ofs
+		self.var = var
 		self.referenced_offset = ref_ofs
 		if self.source_operand == 0xffffffff:
 			self.source_operand = None
 
 	def __repr__(self):
 		if self.source_operand is None:
-			if self.referenced_offset != self.starting_offset:
-				return "<ref to %s%+#x>" % (self.name, self.referenced_offset - self.starting_offset)
+			if self.referenced_offset != self.var.storage:
+				return "<ref to %s%+#x>" % (self.name, self.referenced_offset - self.var.storage)
 			return "<ref to %s>" % self.name
-		if self.referenced_offset != self.starting_offset:
-			return "<operand %d ref to %s%+#x>" % (self.source_operand, self.name, self.referenced_offset)
+		if self.referenced_offset != self.var.storage:
+			return "<operand %d ref to %s%+#x>" % (self.source_operand, self.name, self.var.storage)
 		return "<operand %d ref to %s>" % (self.source_operand, self.name)
 
 
+class Variable(object):
+	def __init__(self, func, source_type, index, storage, name = None, var_type = None):
+		self.function = func
+		self.source_type = VariableSourceType(source_type)
+		self.index = index
+		self.storage = storage
+
+		var = core.BNVariable()
+		var.type = source_type
+		var.index = index
+		var.storage = storage
+		self.identifier = core.BNToVariableIdentifier(var)
+
+		if name is None:
+			name = core.BNGetVariableName(func.handle, var)
+		if var_type is None:
+			var_type = core.BNGetVariableType(func.handle, var)
+			if var_type:
+				var_type = types.Type(var_type)
+
+		self.name = name
+		self.type = var_type
+
+	@classmethod
+	def from_identifier(self, func, identifier, name = None, var_type = None):
+		var = core.BNFromVariableIdentifier(identifier)
+		return Variable(func, VariableSourceType(var.type), var.index, var.storage, name, var_type)
+
+	def __repr__(self):
+		if self.type is None:
+			return "<var %s>" % self.name
+		return "<var %s %s%s>" % (self.type.get_string_before_name(), self.name, self.type.get_string_after_name())
+
+	def __str__(self):
+		return self.name
+
+
 class ConstantReference(object):
-	def __init__(self, val, size):
+	def __init__(self, val, size, ptr, intermediate):
 		self.value = val
 		self.size = size
+		self.pointer = ptr
+		self.intermediate = intermediate
 
 	def __repr__(self):
+		if self.pointer:
+			return "<constant pointer %#x>" % self.value
 		if self.size == 0:
 			return "<constant %#x>" % self.value
 		return "<constant %#x size %d>" % (self.value, self.size)
@@ -177,6 +248,16 @@ class Function(object):
 			core.BNReleaseAdvancedFunctionAnalysisDataMultiple(self.handle, self._advanced_analysis_requests)
 		core.BNFreeFunction(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, Function):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Function):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@classmethod
 	def _unregister(cls, func):
 		handle = ctypes.cast(func, ctypes.c_void_p)
@@ -217,10 +298,10 @@ class Function(object):
 	@property
 	def platform(self):
 		"""Function platform (read-only)"""
-		platform = core.BNGetFunctionPlatform(self.handle)
-		if platform is None:
+		plat = core.BNGetFunctionPlatform(self.handle)
+		if plat is None:
 			return None
-		return platform.Platform(None, handle = platform)
+		return platform.Platform(None, handle = plat)
 
 	@property
 	def start(self):
@@ -248,7 +329,7 @@ class Function(object):
 	@property
 	def explicitly_defined_type(self):
 		"""Whether function has explicitly defined types (read-only)"""
-		return core.BNHasExplicitlyDefinedType(self.handle)
+		return core.BNFunctionHasExplicitlyDefinedType(self.handle)
 
 	@property
 	def needs_update(self):
@@ -279,15 +360,20 @@ class Function(object):
 
 	@property
 	def low_level_il(self):
-		"""Function low level IL (read-only)"""
+		"""returns LowLevelILFunction used to represent Function low level IL (read-only)"""
 		return lowlevelil.LowLevelILFunction(self.arch, core.BNGetFunctionLowLevelIL(self.handle), self)
 
 	@property
 	def lifted_il(self):
-		"""Function lifted IL (read-only)"""
+		"""returns LowLevelILFunction used to represent lifted IL (read-only)"""
 		return lowlevelil.LowLevelILFunction(self.arch, core.BNGetFunctionLiftedIL(self.handle), self)
 
 	@property
+	def medium_level_il(self):
+		"""Function medium level IL (read-only)"""
+		return mediumlevelil.MediumLevelILFunction(self.arch, core.BNGetFunctionMediumLevelIL(self.handle), self)
+
+	@property
 	def function_type(self):
 		"""Function type object"""
 		return types.Type(core.BNGetFunctionType(self.handle))
@@ -298,14 +384,28 @@ class Function(object):
 
 	@property
 	def stack_layout(self):
-		"""List of function stack (read-only)"""
+		"""List of function stack variables (read-only)"""
 		count = ctypes.c_ulonglong()
 		v = core.BNGetStackLayout(self.handle, count)
 		result = []
 		for i in xrange(0, count.value):
-			result.append(StackVariable(v[i].offset, v[i].name, types.Type(handle = core.BNNewTypeReference(v[i].type))))
-		result.sort(key = lambda x: x.offset)
-		core.BNFreeStackLayout(v, count.value)
+			result.append(Variable(self, v[i].var.type, v[i].var.index, v[i].var.storage, v[i].name,
+				types.Type(handle = core.BNNewTypeReference(v[i].type))))
+		result.sort(key = lambda x: x.identifier)
+		core.BNFreeVariableList(v, count.value)
+		return result
+
+	@property
+	def vars(self):
+		"""List of function variables (read-only)"""
+		count = ctypes.c_ulonglong()
+		v = core.BNGetFunctionVariables(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(Variable(self, v[i].var.type, v[i].var.index, v[i].var.storage, v[i].name,
+				types.Type(handle = core.BNNewTypeReference(v[i].type))))
+		result.sort(key = lambda x: x.identifier)
+		core.BNFreeVariableList(v, count.value)
 		return result
 
 	@property
@@ -330,6 +430,16 @@ class Function(object):
 		else:
 			return Function._associated_data[handle.value]
 
+	@property
+	def analysis_performance_info(self):
+		count = ctypes.c_ulonglong()
+		info = core.BNGetFunctionAnalysisPerformanceInfo(self.handle, count)
+		result = {}
+		for i in xrange(0, count.value):
+			result[info[i].name] = info[i].seconds
+		core.BNFreeAnalysisPerformanceInfo(info, count.value)
+		return result
+
 	def __iter__(self):
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetFunctionBasicBlockList(self.handle, count)
@@ -363,20 +473,20 @@ class Function(object):
 
 	def get_low_level_il_at(self, addr, arch=None):
 		"""
-		``get_low_level_il_at`` gets the LowLevelIL instruction address corresponding to the given virtual address
+		``get_low_level_il_at`` gets the LowLevelILInstruction corresponding to the given virtual address
 
 		:param int addr: virtual address of the function to be queried
 		:param Architecture arch: (optional) Architecture for the given function
-		:rtype: int
+		:rtype: LowLevelILInstruction
 		:Example:
 
 			>>> func = bv.functions[0]
 			>>> func.get_low_level_il_at(func.start)
-			0L
+			<il: push(rbp)>
 		"""
 		if arch is None:
 			arch = self.arch
-		return core.BNGetLowLevelILForInstruction(self.handle, arch.handle, addr)
+		return self.low_level_il[core.BNGetLowLevelILForInstruction(self.handle, arch.handle, addr)]
 
 	def get_low_level_il_exits_at(self, addr, arch=None):
 		if arch is None:
@@ -386,7 +496,7 @@ class Function(object):
 		result = []
 		for i in xrange(0, count.value):
 			result.append(exits[i])
-		core.BNFreeLowLevelILInstructionList(exits)
+		core.BNFreeILInstructionList(exits)
 		return result
 
 	def get_reg_value_at(self, addr, reg, arch=None):
@@ -404,11 +514,9 @@ class Function(object):
 		"""
 		if arch is None:
 			arch = self.arch
-		if isinstance(reg, str):
-			reg = arch.regs[reg].index
+		reg = arch.get_reg_index(reg)
 		value = core.BNGetRegisterValueAtInstruction(self.handle, arch.handle, addr, reg)
 		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_reg_value_after(self, addr, reg, arch=None):
@@ -426,41 +534,9 @@ class Function(object):
 		"""
 		if arch is None:
 			arch = self.arch
-		if isinstance(reg, str):
-			reg = arch.regs[reg].index
+		reg = arch.get_reg_index(reg)
 		value = core.BNGetRegisterValueAfterInstruction(self.handle, arch.handle, addr, reg)
 		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
-		return result
-
-	def get_reg_value_at_low_level_il_instruction(self, i, reg, arch=None):
-		"""
-		``get_reg_value_at_low_level_il_instruction`` returns the value of the specified register ``reg`` at the il address
-		i
-
-		:param int i: il address of instruction to query
-		:param Architecture arch: (optional) Architecture for the given function
-		:rtype: function.RegisterValue
-		:Example:
-
-			>>> func.get_reg_value_at_low_level_il_instruction(15, 'rdi')
-			<const 0x2>
-		"""
-		if arch is None:
-			arch = self.arch
-		if isinstance(reg, str):
-			reg = self.arch.regs[reg].index
-		value = core.BNGetRegisterValueAtLowLevelILInstruction(self.handle, i, reg)
-		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
-		return result
-
-	def get_reg_value_after_low_level_il_instruction(self, i, reg):
-		if isinstance(reg, str):
-			reg = self.arch.regs[reg].index
-		value = core.BNGetRegisterValueAfterLowLevelILInstruction(self.handle, i, reg)
-		result = RegisterValue(self.arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_stack_contents_at(self, addr, offset, size, arch=None):
@@ -486,7 +562,6 @@ class Function(object):
 			arch = self.arch
 		value = core.BNGetStackContentsAtInstruction(self.handle, arch.handle, addr, offset, size)
 		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_stack_contents_after(self, addr, offset, size, arch=None):
@@ -494,19 +569,6 @@ class Function(object):
 			arch = self.arch
 		value = core.BNGetStackContentsAfterInstruction(self.handle, arch.handle, addr, offset, size)
 		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
-		return result
-
-	def get_stack_contents_at_low_level_il_instruction(self, i, offset, size):
-		value = core.BNGetStackContentsAtLowLevelILInstruction(self.handle, i, offset, size)
-		result = RegisterValue(self.arch, value)
-		core.BNFreeRegisterValue(value)
-		return result
-
-	def get_stack_contents_after_low_level_il_instruction(self, i, offset, size):
-		value = core.BNGetStackContentsAfterInstruction(self.handle, i, offset, size)
-		result = RegisterValue(self.arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_parameter_at(self, addr, func_type, i, arch=None):
@@ -516,7 +578,6 @@ class Function(object):
 			func_type = func_type.handle
 		value = core.BNGetParameterValueAtInstruction(self.handle, arch.handle, addr, func_type, i)
 		result = RegisterValue(arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_parameter_at_low_level_il_instruction(self, instr, func_type, i):
@@ -524,7 +585,6 @@ class Function(object):
 			func_type = func_type.handle
 		value = core.BNGetParameterValueAtLowLevelILInstruction(self.handle, instr, func_type, i)
 		result = RegisterValue(self.arch, value)
-		core.BNFreeRegisterValue(value)
 		return result
 
 	def get_regs_read_by(self, addr, arch=None):
@@ -556,8 +616,10 @@ class Function(object):
 		refs = core.BNGetStackVariablesReferencedByInstruction(self.handle, arch.handle, addr, count)
 		result = []
 		for i in xrange(0, count.value):
-			result.append(StackVariableReference(refs[i].sourceOperand, types.Type(core.BNNewTypeReference(refs[i].type)),
-				refs[i].name, refs[i].startingOffset, refs[i].referencedOffset))
+			var_type = types.Type(core.BNNewTypeReference(refs[i].type))
+			result.append(StackVariableReference(refs[i].sourceOperand, var_type,
+				refs[i].name, Variable.from_identifier(self, refs[i].varIdentifier, refs[i].name, var_type),
+				refs[i].referencedOffset))
 		core.BNFreeStackVariableReferenceList(refs, count.value)
 		return result
 
@@ -568,35 +630,33 @@ class Function(object):
 		refs = core.BNGetConstantsReferencedByInstruction(self.handle, arch.handle, addr, count)
 		result = []
 		for i in xrange(0, count.value):
-			result.append(ConstantReference(refs[i].value, refs[i].size))
+			result.append(ConstantReference(refs[i].value, refs[i].size, refs[i].pointer, refs[i].intermediate))
 		core.BNFreeConstantReferenceList(refs)
 		return result
 
 	def get_lifted_il_at(self, addr, arch=None):
 		if arch is None:
 			arch = self.arch
-		return core.BNGetLiftedILForInstruction(self.handle, arch.handle, addr)
+		return self.lifted_il[core.BNGetLiftedILForInstruction(self.handle, arch.handle, addr)]
 
 	def get_lifted_il_flag_uses_for_definition(self, i, flag):
-		if isinstance(flag, str):
-			flag = self.arch._flags[flag]
+		flag = self.arch.get_flag_index(flag)
 		count = ctypes.c_ulonglong()
 		instrs = core.BNGetLiftedILFlagUsesForDefinition(self.handle, i, flag, count)
 		result = []
 		for i in xrange(0, count.value):
 			result.append(instrs[i])
-		core.BNFreeLowLevelILInstructionList(instrs)
+		core.BNFreeILInstructionList(instrs)
 		return result
 
 	def get_lifted_il_flag_definitions_for_use(self, i, flag):
-		if isinstance(flag, str):
-			flag = self.arch._flags[flag]
+		flag = self.arch.get_flag_index(flag)
 		count = ctypes.c_ulonglong()
 		instrs = core.BNGetLiftedILFlagDefinitionsForUse(self.handle, i, flag, count)
 		result = []
 		for i in xrange(0, count.value):
 			result.append(instrs[i])
-		core.BNFreeLowLevelILInstructionList(instrs)
+		core.BNFreeILInstructionList(instrs)
 		return result
 
 	def get_flags_read_by_lifted_il_instruction(self, i):
@@ -669,7 +729,9 @@ class Function(object):
 				value = lines[i].tokens[j].value
 				size = lines[i].tokens[j].size
 				operand = lines[i].tokens[j].operand
-				tokens.append(InstructionTextToken(token_type, text, value, size, operand))
+				context = lines[i].tokens[j].context
+				address = lines[i].tokens[j].address
+				tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address))
 			result.append(tokens)
 		core.BNFreeInstructionTextLines(lines, count.value)
 		return result
@@ -691,7 +753,7 @@ class Function(object):
 		:param int instr_addr:
 		:param int value:
 		:param int operand:
-		:param IntegerDisplayTypeEnum display_type:
+		:param enums.IntegerDisplayType display_type:
 		:param Architecture arch: (optional)
 		"""
 		if arch is None:
@@ -790,6 +852,57 @@ class Function(object):
 			color = highlight.HighlightColor(color)
 		core.BNSetUserInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct())
 
+	def create_auto_stack_var(self, offset, var_type, name):
+		core.BNCreateAutoStackVariable(self.handle, offset, var_type.handle, name)
+
+	def create_user_stack_var(self, offset, var_type, name):
+		core.BNCreateUserStackVariable(self.handle, offset, var_type.handle, name)
+
+	def delete_auto_stack_var(self, offset):
+		core.BNDeleteAutoStackVariable(self.handle, offset)
+
+	def delete_user_stack_var(self, offset):
+		core.BNDeleteUserStackVariable(self.handle, offset)
+
+	def create_auto_var(self, var, var_type, name, ignore_disjoint_uses = False):
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		core.BNCreateAutoVariable(self.handle, var_data, var_type.handle, name, ignore_disjoint_uses)
+
+	def create_user_var(self, var, var_type, name, ignore_disjoint_uses = False):
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		core.BNCreateUserVariable(self.handle, var_data, var_type.handle, name, ignore_disjoint_uses)
+
+	def delete_auto_var(self, var):
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		core.BNDeleteAutoVariable(self.handle, var_data)
+
+	def delete_user_var(self, var):
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		core.BNDeleteUserVariable(self.handle, var_data)
+
+	def get_stack_var_at_frame_offset(self, offset, addr, arch=None):
+		if arch is None:
+			arch = self.arch
+		found_var = core.BNVariableNameAndType()
+		if not core.BNGetStackVariableAtFrameOffset(self.handle, arch.handle, addr, offset, found_var):
+			return None
+		result = Variable(self, found_var.var.type, found_var.var.index, found_var.var.storage,
+			found_var.name, types.Type(handle = core.BNNewTypeReference(found_var.type)))
+		core.BNFreeVariableNameAndType(found_var)
+		return result
+
 
 class AdvancedFunctionAnalysisDataRequestor(object):
 	def __init__(self, func = None):
@@ -835,16 +948,19 @@ class DisassemblyTextLine(object):
 
 
 class FunctionGraphEdge(object):
-	def __init__(self, branch_type, arch, target, points):
+	def __init__(self, branch_type, source, target, points):
 		self.type = BranchType(branch_type)
-		self.arch = arch
+		self.source = source
 		self.target = target
 		self.points = points
 
 	def __repr__(self):
-		if self.arch:
-			return "<%s: %s@%#x>" % (self.type.name, self.arch.name, self.target)
-		return "<%s: %#x>" % (self.type, self.target)
+		return "<%s: %s>" % (self.type.name, repr(self.target))
+
+	@property
+	def back_edge(self):
+		"""Whether the edge is a back edge (end of a loop)"""
+		return self.target in self.source.basic_block.dominators
 
 
 class FunctionGraphBlock(object):
@@ -854,6 +970,16 @@ class FunctionGraphBlock(object):
 	def __del__(self):
 		core.BNFreeFunctionGraphBlock(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, FunctionGraphBlock):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, FunctionGraphBlock):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def basic_block(self):
 		"""Basic block associated with this part of the function graph (read-only)"""
@@ -920,7 +1046,9 @@ class FunctionGraphBlock(object):
 				value = lines[i].tokens[j].value
 				size = lines[i].tokens[j].size
 				operand = lines[i].tokens[j].operand
-				tokens.append(InstructionTextToken(token_type, text, value, size, operand))
+				context = lines[i].tokens[j].context
+				address = lines[i].tokens[j].address
+				tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address))
 			result.append(DisassemblyTextLine(addr, tokens))
 		core.BNFreeDisassemblyTextLines(lines, count.value)
 		return result
@@ -934,13 +1062,19 @@ class FunctionGraphBlock(object):
 		for i in xrange(0, count.value):
 			branch_type = BranchType(edges[i].type)
 			target = edges[i].target
-			arch = None
-			if edges[i].arch is not None:
-				arch = architecture.Architecture(edges[i].arch)
+			if target:
+				func = core.BNGetBasicBlockFunction(target)
+				if func is None:
+					core.BNFreeBasicBlock(target)
+					target = None
+				else:
+					target = basicblock.BasicBlock(binaryview.BinaryView(handle = core.BNGetFunctionData(func)),
+						core.BNNewBasicBlockReference(target))
+					core.BNFreeFunction(func)
 			points = []
 			for j in xrange(0, edges[i].pointCount):
 				points.append((edges[i].points[j].x, edges[i].points[j].y))
-			result.append(FunctionGraphEdge(branch_type, arch, target, points))
+			result.append(FunctionGraphEdge(branch_type, self, target, points))
 		core.BNFreeFunctionGraphBlockOutgoingEdgeList(edges, count.value)
 		return result
 
@@ -970,7 +1104,9 @@ class FunctionGraphBlock(object):
 					value = lines[i].tokens[j].value
 					size = lines[i].tokens[j].size
 					operand = lines[i].tokens[j].operand
-					tokens.append(InstructionTextToken(token_type, text, value, size, operand))
+					context = lines[i].tokens[j].context
+					address = lines[i].tokens[j].address
+					tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address))
 				yield DisassemblyTextLine(addr, tokens)
 		finally:
 			core.BNFreeDisassemblyTextLines(lines, count.value)
@@ -1024,6 +1160,16 @@ class FunctionGraph(object):
 		self.abort()
 		core.BNFreeFunctionGraph(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, FunctionGraph):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, FunctionGraph):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def function(self):
 		"""Function for a function graph (read-only)"""
@@ -1241,12 +1387,15 @@ class InstructionTextToken(object):
 		========================== ============================================
 
 	"""
-	def __init__(self, token_type, text, value = 0, size = 0, operand = 0xffffffff):
+	def __init__(self, token_type, text, value = 0, size = 0, operand = 0xffffffff,
+		context = InstructionTextTokenContext.NoTokenContext, address = 0):
 		self.type = InstructionTextTokenType(token_type)
 		self.text = text
 		self.value = value
 		self.size = size
 		self.operand = operand
+		self.context = InstructionTextTokenContext(context)
+		self.address = address
 
 	def __str__(self):
 		return self.text
diff --git a/python/functionrecognizer.py b/python/functionrecognizer.py
index 960aee2f..8514a2ee 100644
--- a/python/functionrecognizer.py
+++ b/python/functionrecognizer.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/generator.cpp b/python/generator.cpp
index d3725b6d..6f19db66 100644
--- a/python/generator.cpp
+++ b/python/generator.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2016 Vector 35 LLC
+// Copyright (c) 2015-2017 Vector 35 LLC
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -97,17 +97,19 @@ void OutputType(FILE* out, Type* type, bool isReturnType = false, bool isCallbac
 		else
 			fprintf(out, "ctypes.c_double");
 		break;
-	case StructureTypeClass:
-		fprintf(out, "%s", type->GetQualifiedName(type->GetStructure()->GetName()).c_str());
-		break;
-	case EnumerationTypeClass:
-	{
-		string name = type->GetQualifiedName(type->GetEnumeration()->GetName());
-		if (name.size() > 2 && name.substr(0, 2) == "BN")
-			name = name.substr(2);
-		fprintf(out, "%sEnum", name.c_str());
+	case NamedTypeReferenceClass:
+		if (type->GetNamedTypeReference()->GetTypeClass() == EnumNamedTypeClass)
+		{
+			string name = type->GetNamedTypeReference()->GetName().GetString();
+			if (name.size() > 2 && name.substr(0, 2) == "BN")
+				name = name.substr(2);
+			fprintf(out, "%sEnum", name.c_str());
+		}
+		else
+		{
+			fprintf(out, "%s", type->GetNamedTypeReference()->GetName().GetString().c_str());
+		}
 		break;
-	}
 	case PointerTypeClass:
 		if (isCallback || (type->GetChildType()->GetClass() == VoidTypeClass))
 		{
@@ -161,7 +163,7 @@ int main(int argc, char* argv[])
 	Architecture::Register(new GeneratorArchitecture());
 
 	// Parse API header to get type and function information
-	map<string, Ref<Type>> types, vars, funcs;
+	map<QualifiedName, Ref<Type>> types, vars, funcs;
 	string errors;
 	bool ok = Architecture::GetByName("generator")->ParseTypesFromSourceFile(argv[1], types, vars, funcs, errors);
 	fprintf(stderr, "%s", errors.c_str());
@@ -195,14 +197,17 @@ int main(int argc, char* argv[])
 	fprintf(out, "# Type definitions\n");
 	for (auto& i : types)
 	{
+		string name;
+		if (i.first.size() != 1)
+			continue;
+		name = i.first[0];
 		if (i.second->GetClass() == StructureTypeClass)
 		{
-			fprintf(out, "class %s(ctypes.Structure):\n", i.first.c_str());
+			fprintf(out, "class %s(ctypes.Structure):\n", name.c_str());
 			fprintf(out, "\tpass\n");
 		}
 		else if (i.second->GetClass() == EnumerationTypeClass)
 		{
-			string name = i.first;
 			if (name.size() > 2 && name.substr(0, 2) == "BN")
 				name = name.substr(2);
 
@@ -217,7 +222,7 @@ int main(int argc, char* argv[])
 		else if ((i.second->GetClass() == BoolTypeClass) || (i.second->GetClass() == IntegerTypeClass) ||
 		         (i.second->GetClass() == FloatTypeClass) || (i.second->GetClass() == ArrayTypeClass))
 		{
-			fprintf(out, "%s = ", i.first.c_str());
+			fprintf(out, "%s = ", name.c_str());
 			OutputType(out, i.second);
 			fprintf(out, "\n");
 		}
@@ -227,9 +232,13 @@ int main(int argc, char* argv[])
 	fprintf(out, "\n# Structure definitions\n");
 	for (auto& i : types)
 	{
+		string name;
+		if (i.first.size() != 1)
+			continue;
+		name = i.first[0];
 		if ((i.second->GetClass() == StructureTypeClass) && (i.second->GetStructure()->GetMembers().size() != 0))
 		{
-			fprintf(out, "%s._fields_ = [\n", i.first.c_str());
+			fprintf(out, "%s._fields_ = [\n", name.c_str());
 			for (auto& j : i.second->GetStructure()->GetMembers())
 			{
 				fprintf(out, "\t\t(\"%s\", ", j.name.c_str());
@@ -243,6 +252,11 @@ int main(int argc, char* argv[])
 	fprintf(out, "\n# Function definitions\n");
 	for (auto& i : funcs)
 	{
+		string name;
+		if (i.first.size() != 1)
+			continue;
+		name = i.first[0];
+
 		// Check for a string result, these will be automatically wrapped to free the string
 		// memory and return a Python string
 		bool stringResult = (i.second->GetChildType()->GetClass() == PointerTypeClass) &&
@@ -251,7 +265,7 @@ int main(int argc, char* argv[])
 		// Pointer returns will be automatically wrapped to return None on null pointer
 		bool pointerResult = (i.second->GetChildType()->GetClass() == PointerTypeClass);
 		bool callbackConvention = false;
-		if (i.first == "BNAllocString")
+		if (name == "BNAllocString")
 		{
 			// Don't perform automatic wrapping of string allocation, and return a void
 			// pointer so that callback functions (which is the only valid use of BNAllocString)
@@ -260,11 +274,11 @@ int main(int argc, char* argv[])
 			callbackConvention = true;
 		}
 
-		string funcName = i.first;
+		string funcName = name;
 		if (stringResult || pointerResult)
 			funcName = string("_") + funcName;
 
-		fprintf(out, "%s = core.%s\n", funcName.c_str(), i.first.c_str());
+		fprintf(out, "%s = core.%s\n", funcName.c_str(), name.c_str());
 		fprintf(out, "%s.restype = ", funcName.c_str());
 		OutputType(out, i.second->GetChildType(), true, callbackConvention);
 		fprintf(out, "\n");
@@ -274,7 +288,7 @@ int main(int argc, char* argv[])
 			for (auto& j : i.second->GetParameters())
 			{
 				fprintf(out, "\t\t");
-				if (i.first == "BNFreeString")
+				if (name == "BNFreeString")
 				{
 					// BNFreeString expects a pointer to a string allocated by the core, so do not use
 					// a c_char_p here, as that would be allocated by the Python runtime.  This can
@@ -293,7 +307,7 @@ int main(int argc, char* argv[])
 		if (stringResult)
 		{
 			// Emit wrapper to get Python string and free native memory
-			fprintf(out, "def %s(*args):\n", i.first.c_str());
+			fprintf(out, "def %s(*args):\n", name.c_str());
 			fprintf(out, "\tresult = %s(*args)\n", funcName.c_str());
 			fprintf(out, "\tstring = ctypes.cast(result, ctypes.c_char_p).value\n");
 			fprintf(out, "\tBNFreeString(result)\n");
@@ -302,7 +316,7 @@ int main(int argc, char* argv[])
 		else if (pointerResult)
 		{
 			// Emit wrapper to return None on null pointer
-			fprintf(out, "def %s(*args):\n", i.first.c_str());
+			fprintf(out, "def %s(*args):\n", name.c_str());
 			fprintf(out, "\tresult = %s(*args)\n", funcName.c_str());
 			fprintf(out, "\tif not result:\n");
 			fprintf(out, "\t\treturn None\n");
diff --git a/python/highlight.py b/python/highlight.py
index 6af1cf95..96bc543d 100644
--- a/python/highlight.py
+++ b/python/highlight.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/interaction.py b/python/interaction.py
index 6d640d17..60607692 100644
--- a/python/interaction.py
+++ b/python/interaction.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -23,7 +23,7 @@ import traceback
 
 # Binary Ninja components
 import _binaryninjacore as core
-from enums import FormInputFieldType, MessageBoxIcon, MessageBoxButtonResult
+from enums import FormInputFieldType, MessageBoxIcon, MessageBoxButtonSet, MessageBoxButtonResult
 import binaryview
 import log
 
@@ -517,5 +517,17 @@ def get_form_input(fields, title):
 	return True
 
 
-def show_message_box(title, text, buttons = MessageBoxButtonResult.OKButton, icon = MessageBoxIcon.InformationIcon):
+def show_message_box(title, text, buttons = MessageBoxButtonSet.OKButtonSet, icon = MessageBoxIcon.InformationIcon):
+	"""
+	``show_message_box`` Displays a configurable message box in the UI, or prompts on the console as appropriate
+	retrieves a list of all Symbol objects of the provided symbol type in the optionally
+	provided range.
+
+	:param str title: Text title for the message box.
+	:param str text: Text for the main body of the message box.
+	:param MessageBoxButtonSet buttons: One of :py:class:`MessageBoxButtonSet`
+	:param MessageBoxIcon icon: One of :py:class:`MessageBoxIcon`
+	:return: Which button was selected
+	:rtype: MessageBoxButtonResult
+	"""
 	return core.BNShowMessageBox(title, text, buttons, icon)
diff --git a/python/lineardisassembly.py b/python/lineardisassembly.py
index 9b88b78a..5ef8d623 100644
--- a/python/lineardisassembly.py
+++ b/python/lineardisassembly.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/log.py b/python/log.py
index 45adb4aa..f7144183 100644
--- a/python/log.py
+++ b/python/log.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -23,11 +23,19 @@
 import _binaryninjacore as core
 
 
+_output_to_log = False
+
+
 def redirect_output_to_log():
 	global _output_to_log
 	_output_to_log = True
 
 
+def is_output_redirected_to_log():
+	global _output_to_log
+	return _output_to_log
+
+
 def log(level, text):
 	"""
 	``log`` writes messages to the log console for the given log level.
diff --git a/python/lowlevelil.py b/python/lowlevelil.py
index 419e8513..c359a79c 100644
--- a/python/lowlevelil.py
+++ b/python/lowlevelil.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -25,6 +25,7 @@ import _binaryninjacore as core
 from .enums import LowLevelILOperation, LowLevelILFlagCondition, InstructionTextTokenType
 import function
 import basicblock
+import mediumlevelil
 
 
 class LowLevelILLabel(object):
@@ -36,6 +37,76 @@ class LowLevelILLabel(object):
 			self.handle = handle
 
 
+class ILRegister(object):
+	def __init__(self, arch, reg):
+		self.arch = arch
+		self.index = reg
+		self.temp = (self.index & 0x80000000) != 0
+		if self.temp:
+			self.name = "temp%d" % (self.index & 0x7fffffff)
+		else:
+			self.name = self.arch.get_reg_name(self.index)
+
+	@property
+	def info(self):
+		return self.arch.regs[self.name]
+
+	def __str__(self):
+		return self.name
+
+	def __repr__(self):
+		return self.name
+
+	def __eq__(self, other):
+		return self.info == other.info
+
+
+class ILFlag(object):
+	def __init__(self, arch, flag):
+		self.arch = arch
+		self.index = flag
+		self.temp = (self.index & 0x80000000) != 0
+		if self.temp:
+			self.name = "cond:%d" % (self.index & 0x7fffffff)
+		else:
+			self.name = self.arch.get_flag_name(self.index)
+
+	def __str__(self):
+		return self.name
+
+	def __repr__(self):
+		return self.name
+
+
+class SSARegister(object):
+	def __init__(self, reg, version):
+		self.reg = reg
+		self.version = version
+
+	def __repr__(self):
+		return "<ssa %s version %d>" % (repr(self.reg), self.version)
+
+
+class SSAFlag(object):
+	def __init__(self, flag, version):
+		self.flag = flag
+		self.version = version
+
+	def __repr__(self):
+		return "<ssa %s version %d>" % (repr(self.flag), self.version)
+
+
+class LowLevelILOperationAndSize(object):
+	def __init__(self, operation, size):
+		self.operation = operation
+		self.size = size
+
+	def __repr__(self):
+		if self.size == 0:
+			return "<%s>" % self.operation.name
+		return "<%s %d>" % (self.operation.name, self.size)
+
+
 class LowLevelILInstruction(object):
 	"""
 	``class LowLevelILInstruction`` Low Level Intermediate Language Instructions are infinite length tree-based
@@ -53,13 +124,14 @@ class LowLevelILInstruction(object):
 		LowLevelILOperation.LLIL_PUSH: [("src", "expr")],
 		LowLevelILOperation.LLIL_POP: [],
 		LowLevelILOperation.LLIL_REG: [("src", "reg")],
-		LowLevelILOperation.LLIL_CONST: [("value", "int")],
+		LowLevelILOperation.LLIL_CONST: [("constant", "int")],
+		LowLevelILOperation.LLIL_CONST_PTR: [("constant", "int")],
 		LowLevelILOperation.LLIL_FLAG: [("src", "flag")],
 		LowLevelILOperation.LLIL_FLAG_BIT: [("src", "flag"), ("bit", "int")],
 		LowLevelILOperation.LLIL_ADD: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_ADC: [("left", "expr"), ("right", "expr")],
+		LowLevelILOperation.LLIL_ADC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
 		LowLevelILOperation.LLIL_SUB: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_SBB: [("left", "expr"), ("right", "expr")],
+		LowLevelILOperation.LLIL_SBB: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
 		LowLevelILOperation.LLIL_AND: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_OR: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_XOR: [("left", "expr"), ("right", "expr")],
@@ -67,9 +139,9 @@ class LowLevelILInstruction(object):
 		LowLevelILOperation.LLIL_LSR: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_ASR: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_ROL: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_RLC: [("left", "expr"), ("right", "expr")],
+		LowLevelILOperation.LLIL_RLC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
 		LowLevelILOperation.LLIL_ROR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_RRC: [("left", "expr"), ("right", "expr")],
+		LowLevelILOperation.LLIL_RRC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
 		LowLevelILOperation.LLIL_MUL: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_MULU_DP: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_MULS_DP: [("left", "expr"), ("right", "expr")],
@@ -85,6 +157,7 @@ class LowLevelILInstruction(object):
 		LowLevelILOperation.LLIL_NOT: [("src", "expr")],
 		LowLevelILOperation.LLIL_SX: [("src", "expr")],
 		LowLevelILOperation.LLIL_ZX: [("src", "expr")],
+		LowLevelILOperation.LLIL_LOW_PART: [("src", "expr")],
 		LowLevelILOperation.LLIL_JUMP: [("dest", "expr")],
 		LowLevelILOperation.LLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")],
 		LowLevelILOperation.LLIL_CALL: [("dest", "expr")],
@@ -105,12 +178,32 @@ class LowLevelILInstruction(object):
 		LowLevelILOperation.LLIL_CMP_UGT: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_TEST_BIT: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_BOOL_TO_INT: [("src", "expr")],
+		LowLevelILOperation.LLIL_ADD_OVERFLOW: [("left", "expr"), ("right", "expr")],
 		LowLevelILOperation.LLIL_SYSCALL: [],
 		LowLevelILOperation.LLIL_BP: [],
-		LowLevelILOperation.LLIL_TRAP: [("value", "int")],
+		LowLevelILOperation.LLIL_TRAP: [("vector", "int")],
 		LowLevelILOperation.LLIL_UNDEF: [],
 		LowLevelILOperation.LLIL_UNIMPL: [],
-		LowLevelILOperation.LLIL_UNIMPL_MEM: [("src", "expr")]
+		LowLevelILOperation.LLIL_UNIMPL_MEM: [("src", "expr")],
+		LowLevelILOperation.LLIL_SET_REG_SSA: [("dest", "reg_ssa"), ("src", "expr")],
+		LowLevelILOperation.LLIL_SET_REG_SSA_PARTIAL: [("full_reg", "reg_ssa"), ("dest", "reg"), ("src", "expr")],
+		LowLevelILOperation.LLIL_SET_REG_SPLIT_SSA: [("hi", "expr"), ("lo", "expr"), ("src", "expr")],
+		LowLevelILOperation.LLIL_REG_SPLIT_DEST_SSA: [("dest", "reg_ssa")],
+		LowLevelILOperation.LLIL_REG_SSA: [("src", "reg_ssa")],
+		LowLevelILOperation.LLIL_REG_SSA_PARTIAL: [("full_reg", "reg_ssa"), ("src", "reg")],
+		LowLevelILOperation.LLIL_SET_FLAG_SSA: [("dest", "flag_ssa"), ("src", "expr")],
+		LowLevelILOperation.LLIL_FLAG_SSA: [("src", "flag_ssa")],
+		LowLevelILOperation.LLIL_FLAG_BIT_SSA: [("src", "flag_ssa"), ("bit", "int")],
+		LowLevelILOperation.LLIL_CALL_SSA: [("output", "expr"), ("dest", "expr"), ("stack", "expr"), ("param", "expr")],
+		LowLevelILOperation.LLIL_SYSCALL_SSA: [("output", "expr"), ("stack", "expr"), ("param", "expr")],
+		LowLevelILOperation.LLIL_CALL_OUTPUT_SSA: [("dest_memory", "int"), ("dest", "reg_ssa_list")],
+		LowLevelILOperation.LLIL_CALL_STACK_SSA: [("src", "reg_ssa"), ("src_memory", "int")],
+		LowLevelILOperation.LLIL_CALL_PARAM_SSA: [("src", "reg_ssa_list")],
+		LowLevelILOperation.LLIL_LOAD_SSA: [("src", "expr"), ("src_memory", "int")],
+		LowLevelILOperation.LLIL_STORE_SSA: [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
+		LowLevelILOperation.LLIL_REG_PHI: [("dest", "reg_ssa"), ("src", "reg_ssa_list")],
+		LowLevelILOperation.LLIL_FLAG_PHI: [("dest", "flag_ssa"), ("src", "flag_ssa_list")],
+		LowLevelILOperation.LLIL_MEM_PHI: [("dest_memory", "int"), ("src_memory", "int_list")]
 	}
 
 	def __init__(self, func, expr_index, instr_index=None):
@@ -130,30 +223,58 @@ class LowLevelILInstruction(object):
 			self.source_operand = None
 		operands = LowLevelILInstruction.ILOperations[instr.operation]
 		self.operands = []
-		for i in xrange(0, len(operands)):
-			name, operand_type = operands[i]
+		i = 0
+		for operand in operands:
+			name, operand_type = operand
 			if operand_type == "int":
 				value = instr.operands[i]
 			elif operand_type == "expr":
 				value = LowLevelILInstruction(func, instr.operands[i])
 			elif operand_type == "reg":
-				if (instr.operands[i] & 0x80000000) != 0:
-					value = instr.operands[i]
-				else:
-					value = func.arch.get_reg_name(instr.operands[i])
+				value = ILRegister(func.arch, instr.operands[i])
+			elif operand_type == "reg_ssa":
+				reg = ILRegister(func.arch, instr.operands[i])
+				i += 1
+				value = SSARegister(reg, instr.operands[i])
 			elif operand_type == "flag":
-				value = func.arch.get_flag_name(instr.operands[i])
+				value = ILFlag(func.arch, instr.operands[i])
+			elif operand_type == "flag_ssa":
+				flag = ILFlag(func.arch, instr.operands[i])
+				i += 1
+				value = SSAFlag(flag, instr.operands[i])
 			elif operand_type == "cond":
 				value = LowLevelILFlagCondition(instr.operands[i])
 			elif operand_type == "int_list":
 				count = ctypes.c_ulonglong()
-				operands = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
 				value = []
 				for i in xrange(count.value):
-					value.append(operands[i])
-				core.BNLowLevelILFreeOperandList(operands)
+					value.append(operand_list[i])
+				core.BNLowLevelILFreeOperandList(operand_list)
+			elif operand_type == "reg_ssa_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
+				value = []
+				for i in xrange(count.value / 2):
+					reg = operand_list[i * 2]
+					reg_version = operand_list[(i * 2) + 1]
+					value.append(SSARegister(ILRegister(func.arch, reg), reg_version))
+				core.BNLowLevelILFreeOperandList(operand_list)
+			elif operand_type == "flag_ssa_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
+				value = []
+				for i in xrange(count.value / 2):
+					flag = operand_list[i * 2]
+					flag_version = operand_list[(i * 2) + 1]
+					value.append(SSAFlag(ILFlag(func.arch, flag), flag_version))
+				core.BNLowLevelILFreeOperandList(operand_list)
 			self.operands.append(value)
 			self.__dict__[name] = value
+			i += 1
 
 	def __str__(self):
 		tokens = self.tokens
@@ -187,10 +308,144 @@ class LowLevelILInstruction(object):
 			value = tokens[i].value
 			size = tokens[i].size
 			operand = tokens[i].operand
-			result.append(function.InstructionTextToken(token_type, text, value, size, operand))
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
 		core.BNFreeInstructionText(tokens, count.value)
 		return result
 
+	@property
+	def ssa_form(self):
+		"""SSA form of expression (read-only)"""
+		return LowLevelILInstruction(self.function.ssa_form,
+			core.BNGetLowLevelILSSAExprIndex(self.function.handle, self.expr_index))
+
+	@property
+	def non_ssa_form(self):
+		"""Non-SSA form of expression (read-only)"""
+		return LowLevelILInstruction(self.function.non_ssa_form,
+			core.BNGetLowLevelILNonSSAExprIndex(self.function.handle, self.expr_index))
+
+	@property
+	def mapped_medium_level_il(self):
+		"""Gets the medium level IL expression corresponding to this expression"""
+		expr = self.function.get_mapped_medium_level_il_expr_index(self.expr_index)
+		if expr is None:
+			return None
+		return mediumlevelil.MediumLevelILInstruction(self.function.mapped_medium_level_il, expr)
+
+	@property
+	def value(self):
+		"""Value of expression if constant or a known value (read-only)"""
+		value = core.BNGetLowLevelILExprValue(self.function.handle, self.expr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	@property
+	def possible_values(self):
+		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
+		value = core.BNGetLowLevelILPossibleExprValues(self.function.handle, self.expr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	@property
+	def prefix_operands(self):
+		"""All operands in the expression tree in prefix order"""
+		result = [LowLevelILOperationAndSize(self.operation, self.size)]
+		for operand in self.operands:
+			if isinstance(operand, LowLevelILInstruction):
+				result += operand.prefix_operands
+			else:
+				result.append(operand)
+		return result
+
+	@property
+	def postfix_operands(self):
+		"""All operands in the expression tree in postfix order"""
+		result = []
+		for operand in self.operands:
+			if isinstance(operand, LowLevelILInstruction):
+				result += operand.postfix_operands
+			else:
+				result.append(operand)
+		result.append(LowLevelILOperationAndSize(self.operation, self.size))
+		return result
+
+	def get_reg_value(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILRegisterValueAtInstruction(self.function.handle, reg, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_reg_value_after(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILRegisterValueAfterInstruction(self.function.handle, reg, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_reg_values(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILPossibleRegisterValuesAtInstruction(self.function.handle, reg, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_reg_values_after(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILPossibleRegisterValuesAfterInstruction(self.function.handle, reg, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_flag_value(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetLowLevelILFlagValueAtInstruction(self.function.handle, flag, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_flag_value_after(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetLowLevelILFlagValueAfterInstruction(self.function.handle, flag, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_flag_values(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetLowLevelILPossibleFlagValuesAtInstruction(self.function.handle, flag, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_flag_values_after(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetLowLevelILPossibleFlagValuesAfterInstruction(self.function.handle, flag, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_stack_contents(self, offset, size):
+		value = core.BNGetLowLevelILStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_stack_contents_after(self, offset, size):
+		value = core.BNGetLowLevelILStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_stack_contents(self, offset, size):
+		value = core.BNGetLowLevelILPossibleStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_stack_contents_after(self, offset, size):
+		value = core.BNGetLowLevelILPossibleStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self, name, value)
@@ -251,6 +506,16 @@ class LowLevelILFunction(object):
 	def __del__(self):
 		core.BNFreeLowLevelILFunction(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, LowLevelILFunction):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, LowLevelILFunction):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def current_address(self):
 		"""Current IL Address (read/write)"""
@@ -258,7 +523,12 @@ class LowLevelILFunction(object):
 
 	@current_address.setter
 	def current_address(self, value):
-		core.BNLowLevelILSetCurrentAddress(self.handle, value)
+		core.BNLowLevelILSetCurrentAddress(self.handle, self.arch.handle, value)
+
+	def set_current_address(self, value, arch = None):
+		if arch is None:
+			arch = self.arch
+		core.BNLowLevelILSetCurrentAddress(self.handle, arch.handle, value)
 
 	@property
 	def temp_reg_count(self):
@@ -284,6 +554,40 @@ class LowLevelILFunction(object):
 		core.BNFreeBasicBlockList(blocks, count.value)
 		return result
 
+	@property
+	def ssa_form(self):
+		"""Low level IL in SSA form (read-only)"""
+		result = core.BNGetLowLevelILSSAForm(self.handle)
+		if not result:
+			return None
+		return LowLevelILFunction(self.arch, result, self.source_function)
+
+	@property
+	def non_ssa_form(self):
+		"""Low level IL in non-SSA (default) form (read-only)"""
+		result = core.BNGetLowLevelILNonSSAForm(self.handle)
+		if not result:
+			return None
+		return LowLevelILFunction(self.arch, result, self.source_function)
+
+	@property
+	def medium_level_il(self):
+		"""Medium level IL for this low level IL."""
+		result = core.BNGetMediumLevelILForLowLevelIL(self.handle)
+		if not result:
+			return None
+		return mediumlevelil.MediumLevelILFunction(self.arch, result, self.source_function)
+
+	@property
+	def mapped_medium_level_il(self):
+		"""Medium level IL with mappings between low level IL and medium level IL. Unused stores are not removed.
+		Typically, this should only be used to answer queries on assembly or low level IL where the query is
+		easier to perform on medium level IL."""
+		result = core.BNGetMappedMediumLevelIL(self.handle)
+		if not result:
+			return None
+		return mediumlevelil.MediumLevelILFunction(self.arch, result, self.source_function)
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self, name, value)
@@ -317,6 +621,14 @@ class LowLevelILFunction(object):
 		finally:
 			core.BNFreeBasicBlockList(blocks, count.value)
 
+	def get_instruction_start(self, addr, arch = None):
+		if arch is None:
+			arch = self.arch
+		result = core.BNLowLevelILGetInstructionStart(self.handle, arch.handle, addr)
+		if result >= core.BNGetLowLevelILInstructionCount(self.handle):
+			return None
+		return result
+
 	def clear_indirect_branches(self):
 		core.BNLowLevelILClearIndirectBranches(self.handle)
 
@@ -368,8 +680,7 @@ class LowLevelILFunction(object):
 		:return: The expression ``reg = value``
 		:rtype: LowLevelILExpr
 		"""
-		if isinstance(reg, str):
-			reg = self.arch.regs[reg].index
+		reg = self.arch.get_reg_index(reg)
 		return self.expr(LowLevelILOperation.LLIL_SET_REG, reg, value.index, size = size, flags = flags)
 
 	def set_reg_split(self, size, hi, lo, value, flags = 0):
@@ -385,10 +696,8 @@ class LowLevelILFunction(object):
 		:return: The expression ``hi:lo = value``
 		:rtype: LowLevelILExpr
 		"""
-		if isinstance(hi, str):
-			hi = self.arch.regs[hi].index
-		if isinstance(lo, str):
-			lo = self.arch.regs[lo].index
+		hi = self.arch.get_reg_index(hi)
+		lo = self.arch.get_reg_index(lo)
 		return self.expr(LowLevelILOperation.LLIL_SET_REG_SPLIT, hi, lo, value.index, size = size, flags = flags)
 
 	def set_flag(self, flag, value):
@@ -455,8 +764,7 @@ class LowLevelILFunction(object):
 		:return: A register expression for the given string
 		:rtype: LowLevelILExpr
 		"""
-		if isinstance(reg, str):
-			reg = self.arch.regs[reg].index
+		reg = self.arch.get_reg_index(reg)
 		return self.expr(LowLevelILOperation.LLIL_REG, reg, size=size)
 
 	def const(self, size, value):
@@ -470,6 +778,17 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_CONST, value, size=size)
 
+	def const_pointer(self, size, value):
+		"""
+		``const_pointer`` returns an expression for the constant pointer ``value`` with size ``size``
+
+		:param int size: the size of the pointer in bytes
+		:param int value: address referenced by pointer
+		:return: A constant expression of given value and size
+		:rtype: LowLevelILExpr
+		"""
+		return self.expr(LowLevelILOperation.LLIL_CONST_PTR, value, size=size)
+
 	def flag(self, reg):
 		"""
 		``flag`` returns a flag expression for the given flag name.
@@ -506,7 +825,7 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_ADD, a.index, b.index, size=size, flags=flags)
 
-	def add_carry(self, size, a, b, flags=None):
+	def add_carry(self, size, a, b, carry, flags=None):
 		"""
 		``add_carry`` adds with carry expression ``a`` to expression ``b`` potentially setting flags ``flags`` and
 		returning an expression of ``size`` bytes.
@@ -514,11 +833,12 @@ class LowLevelILFunction(object):
 		:param int size: the size of the result in bytes
 		:param LowLevelILExpr a: LHS expression
 		:param LowLevelILExpr b: RHS expression
+		:param LowLevelILExpr carry: Carry flag expression
 		:param str flags: flags to set
-		:return: The expression ``adc.<size>{<flags>}(a, b)``
+		:return: The expression ``adc.<size>{<flags>}(a, b, carry)``
 		:rtype: LowLevelILExpr
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ADC, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ADC, a.index, b.index, carry.index, size=size, flags=flags)
 
 	def sub(self, size, a, b, flags=None):
 		"""
@@ -534,7 +854,7 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_SUB, a.index, b.index, size=size, flags=flags)
 
-	def sub_borrow(self, size, a, b, flags=None):
+	def sub_borrow(self, size, a, b, carry, flags=None):
 		"""
 		``sub_borrow`` subtracts with borrow expression ``b`` from expression ``a`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
@@ -542,11 +862,12 @@ class LowLevelILFunction(object):
 		:param int size: the size of the result in bytes
 		:param LowLevelILExpr a: LHS expression
 		:param LowLevelILExpr b: RHS expression
+		:param LowLevelILExpr carry: Carry flag expression
 		:param str flags: flags to set
-		:return: The expression ``sbc.<size>{<flags>}(a, b)``
+		:return: The expression ``sbb.<size>{<flags>}(a, b, carry)``
 		:rtype: LowLevelILExpr
 		"""
-		return self.expr(LowLevelILOperation.LLIL_SBB, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_SBB, a.index, b.index, carry.index, size=size, flags=flags)
 
 	def and_expr(self, size, a, b, flags=None):
 		"""
@@ -646,7 +967,7 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_ROL, a.index, b.index, size=size, flags=flags)
 
-	def rotate_left_carry(self, size, a, b, flags=None):
+	def rotate_left_carry(self, size, a, b, carry, flags=None):
 		"""
 		``rotate_left_carry`` bitwise rotates left with carry expression ``a`` by expression ``b`` potentially setting
 		flags ``flags`` and returning an expression of ``size`` bytes.
@@ -654,11 +975,12 @@ class LowLevelILFunction(object):
 		:param int size: the size of the result in bytes
 		:param LowLevelILExpr a: LHS expression
 		:param LowLevelILExpr b: RHS expression
+		:param LowLevelILExpr carry: Carry flag expression
 		:param str flags: optional, flags to set
-		:return: The expression ``rcl.<size>{<flags>}(a, b)``
+		:return: The expression ``rlc.<size>{<flags>}(a, b, carry)``
 		:rtype: LowLevelILExpr
 		"""
-		return self.expr(LowLevelILOperation.LLIL_RLC, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_RLC, a.index, b.index, carry.index, size=size, flags=flags)
 
 	def rotate_right(self, size, a, b, flags=None):
 		"""
@@ -674,7 +996,7 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_ROR, a.index, b.index, size=size, flags=flags)
 
-	def rotate_right_carry(self, size, a, b, flags=None):
+	def rotate_right_carry(self, size, a, b, carry, flags=None):
 		"""
 		``rotate_right_carry`` bitwise rotates right with carry expression ``a`` by expression ``b`` potentially setting
 		flags ``flags`` and returning an expression of ``size`` bytes.
@@ -682,11 +1004,12 @@ class LowLevelILFunction(object):
 		:param int size: the size of the result in bytes
 		:param LowLevelILExpr a: LHS expression
 		:param LowLevelILExpr b: RHS expression
+		:param LowLevelILExpr carry: Carry flag expression
 		:param str flags: optional, flags to set
-		:return: The expression ``rcr.<size>{<flags>}(a, b)``
+		:return: The expression ``rrc.<size>{<flags>}(a, b, carry)``
 		:rtype: LowLevelILExpr
 		"""
-		return self.expr(LowLevelILOperation.LLIL_RRC, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_RRC, a.index, b.index, carry.index, size=size, flags=flags)
 
 	def mult(self, size, a, b, flags=None):
 		"""
@@ -886,7 +1209,7 @@ class LowLevelILFunction(object):
 		"""
 		return self.expr(LowLevelILOperation.LLIL_SX, value.index, size=size, flags=flags)
 
-	def zero_extend(self, size, value):
+	def zero_extend(self, size, value, flags=None):
 		"""
 		``zero_extend`` zero-extends the expression in ``value`` to ``size`` bytes
 
@@ -895,7 +1218,18 @@ class LowLevelILFunction(object):
 		:return: The expression ``sx.<size>(value)``
 		:rtype: LowLevelILExpr
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ZX, value.index, size=size)
+		return self.expr(LowLevelILOperation.LLIL_ZX, value.index, size=size, flags=flags)
+
+	def low_part(self, size, value, flags=None):
+		"""
+		``low_part`` truncates ``value`` to ``size`` bytes
+
+		:param int size: the size of the result in bytes
+		:param LowLevelILExpr value: the expression to zero extend
+		:return: The expression ``(value).<size>``
+		:rtype: LowLevelILExpr
+		"""
+		return self.expr(LowLevelILOperation.LLIL_LOW_PART, value.index, size=size, flags=flags)
 
 	def jump(self, dest):
 		"""
@@ -1250,6 +1584,91 @@ class LowLevelILFunction(object):
 			return None
 		return LowLevelILLabel(label)
 
+	def get_ssa_instruction_index(self, instr):
+		return core.BNGetLowLevelILSSAInstructionIndex(self.handle, instr)
+
+	def get_non_ssa_instruction_index(self, instr):
+		return core.BNGetLowLevelILNonSSAInstructionIndex(self.handle, instr)
+
+	def get_ssa_reg_definition(self, reg_ssa):
+		reg = self.arch.get_reg_index(reg_ssa.reg)
+		result = core.BNGetLowLevelILSSARegisterDefinition(self.handle, reg, reg_ssa.version)
+		if result >= core.BNGetLowLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def get_ssa_flag_definition(self, flag_ssa):
+		flag = self.arch.get_flag_index(flag_ssa.flag)
+		result = core.BNGetLowLevelILSSAFlagDefinition(self.handle, flag, flag_ssa.version)
+		if result >= core.BNGetLowLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def get_ssa_memory_definition(self, index):
+		result = core.BNGetLowLevelILSSAMemoryDefinition(self.handle, index)
+		if result >= core.BNGetLowLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def get_ssa_reg_uses(self, reg_ssa):
+		reg = self.arch.get_reg_index(reg_ssa.reg)
+		count = ctypes.c_ulonglong()
+		instrs = core.BNGetLowLevelILSSARegisterUses(self.handle, reg, reg_ssa.version, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(instrs[i])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_ssa_flag_uses(self, flag_ssa):
+		flag = self.arch.get_flag_index(flag_ssa.flag)
+		count = ctypes.c_ulonglong()
+		instrs = core.BNGetLowLevelILSSAFlagUses(self.handle, flag, flag_ssa.version, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(instrs[i])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_ssa_memory_uses(self, index):
+		count = ctypes.c_ulonglong()
+		instrs = core.BNGetLowLevelILSSAMemoryUses(self.handle, index, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(instrs[i])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_ssa_reg_value(self, reg_ssa):
+		reg = self.arch.get_reg_index(reg_ssa.reg)
+		value = core.BNGetLowLevelILSSARegisterValue(self.handle, reg, reg_ssa.version)
+		result = function.RegisterValue(self.arch, value)
+		return result
+
+	def get_ssa_flag_value(self, flag_ssa):
+		flag = self.arch.get_flag_index(flag_ssa.flag)
+		value = core.BNGetLowLevelILSSAFlagValue(self.handle, flag, flag_ssa.version)
+		result = function.RegisterValue(self.arch, value)
+		return result
+
+	def get_mapped_medium_level_il_instruction_index(self, instr):
+		med_il = self.mapped_medium_level_il
+		if med_il is None:
+			return None
+		result = core.BNGetMappedMediumLevelILInstructionIndex(self.handle, instr)
+		if result >= core.BNGetMediumLevelILInstructionCount(med_il.handle):
+			return None
+		return result
+
+	def get_mapped_medium_level_il_expr_index(self, expr):
+		med_il = self.mapped_medium_level_il
+		if med_il is None:
+			return None
+		result = core.BNGetMappedMediumLevelILExprIndex(self.handle, expr)
+		if result >= core.BNGetMediumLevelILExprCount(med_il.handle):
+			return None
+		return result
+
 
 class LowLevelILBasicBlock(basicblock.BasicBlock):
 	def __init__(self, view, handle, owner):
diff --git a/python/mainthread.py b/python/mainthread.py
index 220f0b64..3e12bd65 100644
--- a/python/mainthread.py
+++ b/python/mainthread.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/mediumlevelil.py b/python/mediumlevelil.py
new file mode 100644
index 00000000..1274bd9b
--- /dev/null
+++ b/python/mediumlevelil.py
@@ -0,0 +1,836 @@
+# Copyright (c) 2017 Vector 35 LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import ctypes
+
+# Binary Ninja components
+import _binaryninjacore as core
+from .enums import MediumLevelILOperation, InstructionTextTokenType, ILBranchDependence
+import function
+import basicblock
+import lowlevelil
+
+
+class SSAVariable(object):
+	def __init__(self, var, version):
+		self.var = var
+		self.version = version
+
+	def __repr__(self):
+		return "<ssa %s version %d>" % (repr(self.var), self.version)
+
+
+class MediumLevelILLabel(object):
+	def __init__(self, handle = None):
+		if handle is None:
+			self.handle = (core.BNMediumLevelILLabel * 1)()
+			core.BNMediumLevelILInitLabel(self.handle)
+		else:
+			self.handle = handle
+
+
+class MediumLevelILOperationAndSize(object):
+	def __init__(self, operation, size):
+		self.operation = operation
+		self.size = size
+
+	def __repr__(self):
+		if self.size == 0:
+			return "<%s>" % self.operation.name
+		return "<%s %d>" % (self.operation.name, self.size)
+
+
+class MediumLevelILInstruction(object):
+	"""
+	``class MediumLevelILInstruction`` Medium Level Intermediate Language Instructions are infinite length tree-based
+	instructions. Tree-based instructions use infix notation with the left hand operand being the destination operand.
+	Infix notation is thus more natural to read than other notations (e.g. x86 ``mov eax, 0`` vs. MLIL ``eax = 0``).
+	"""
+
+	ILOperations = {
+		MediumLevelILOperation.MLIL_NOP: [],
+		MediumLevelILOperation.MLIL_SET_VAR: [("dest", "var"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_FIELD: [("dest", "var"), ("offset", "int"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_SPLIT: [("high", "var"), ("low", "var"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_LOAD: [("src", "expr")],
+		MediumLevelILOperation.MLIL_STORE: [("dest", "expr"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_VAR: [("src", "var")],
+		MediumLevelILOperation.MLIL_VAR_FIELD: [("src", "var"), ("offset", "int")],
+		MediumLevelILOperation.MLIL_ADDRESS_OF: [("src", "var")],
+		MediumLevelILOperation.MLIL_ADDRESS_OF_FIELD: [("src", "var"), ("offset", "int")],
+		MediumLevelILOperation.MLIL_CONST: [("constant", "int")],
+		MediumLevelILOperation.MLIL_CONST_PTR: [("constant", "int")],
+		MediumLevelILOperation.MLIL_ADD: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_ADC: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_SUB: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_SBB: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_AND: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_OR: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_XOR: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_LSL: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_LSR: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_ASR: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_ROL: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_RLC: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_ROR: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_RRC: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MUL: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MULU_DP: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MULS_DP: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_DIVU: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_DIVU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_DIVS: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_DIVS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MODU: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MODU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MODS: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_MODS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_NEG: [("src", "expr")],
+		MediumLevelILOperation.MLIL_NOT: [("src", "expr")],
+		MediumLevelILOperation.MLIL_SX: [("src", "expr")],
+		MediumLevelILOperation.MLIL_ZX: [("src", "expr")],
+		MediumLevelILOperation.MLIL_LOW_PART: [("src", "expr")],
+		MediumLevelILOperation.MLIL_JUMP: [("dest", "expr")],
+		MediumLevelILOperation.MLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")],
+		MediumLevelILOperation.MLIL_CALL: [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
+		MediumLevelILOperation.MLIL_CALL_UNTYPED: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+		MediumLevelILOperation.MLIL_CALL_OUTPUT: [("dest", "var_list")],
+		MediumLevelILOperation.MLIL_CALL_PARAM: [("src", "var_list")],
+		MediumLevelILOperation.MLIL_RET: [("src", "expr_list")],
+		MediumLevelILOperation.MLIL_NORET: [],
+		MediumLevelILOperation.MLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")],
+		MediumLevelILOperation.MLIL_GOTO: [("dest", "int")],
+		MediumLevelILOperation.MLIL_CMP_E: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_NE: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_SLT: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_ULT: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_SLE: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_ULE: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_SGE: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_UGE: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_SGT: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_CMP_UGT: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_TEST_BIT: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_BOOL_TO_INT: [("src", "expr")],
+		MediumLevelILOperation.MLIL_ADD_OVERFLOW: [("left", "expr"), ("right", "expr")],
+		MediumLevelILOperation.MLIL_SYSCALL: [("output", "var_list"), ("params", "expr_list")],
+		MediumLevelILOperation.MLIL_SYSCALL_UNTYPED: [("output", "expr"), ("params", "expr"), ("stack", "expr")],
+		MediumLevelILOperation.MLIL_BP: [],
+		MediumLevelILOperation.MLIL_TRAP: [("vector", "int")],
+		MediumLevelILOperation.MLIL_UNDEF: [],
+		MediumLevelILOperation.MLIL_UNIMPL: [],
+		MediumLevelILOperation.MLIL_UNIMPL_MEM: [("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_SSA: [("dest", "var_ssa"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD: [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA: [("high", "expr"), ("low", "expr"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_ALIASED: [("prev", "var_ssa_dest_and_src"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD: [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_VAR_SSA: [("src", "var_ssa")],
+		MediumLevelILOperation.MLIL_VAR_SSA_FIELD: [("src", "var_ssa"), ("offset", "int")],
+		MediumLevelILOperation.MLIL_VAR_ALIASED: [("src", "var_ssa")],
+		MediumLevelILOperation.MLIL_VAR_ALIASED_FIELD: [("src", "var_ssa"), ("offset", "int")],
+		MediumLevelILOperation.MLIL_CALL_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr_list"), ("src_memory", "int")],
+		MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+		MediumLevelILOperation.MLIL_SYSCALL_SSA: [("output", "expr"), ("params", "expr_list"), ("src_memory", "int")],
+		MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA: [("output", "expr"), ("params", "expr"), ("stack", "expr")],
+		MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA: [("dest_memory", "int"), ("dest", "var_ssa_list")],
+		MediumLevelILOperation.MLIL_CALL_PARAM_SSA: [("src_memory", "int"), ("src", "var_ssa_list")],
+		MediumLevelILOperation.MLIL_LOAD_SSA: [("src", "expr"), ("src_memory", "int")],
+		MediumLevelILOperation.MLIL_STORE_SSA: [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
+		MediumLevelILOperation.MLIL_VAR_PHI: [("dest", "var_ssa"), ("src", "var_ssa_list")],
+		MediumLevelILOperation.MLIL_MEM_PHI: [("dest_memory", "int"), ("src_memory", "int_list")]
+	}
+
+	def __init__(self, func, expr_index, instr_index=None):
+		instr = core.BNGetMediumLevelILByIndex(func.handle, expr_index)
+		self.function = func
+		self.expr_index = expr_index
+		if instr_index is None:
+			self.instr_index = core.BNGetMediumLevelILInstructionForExpr(func.handle, expr_index)
+		else:
+			self.instr_index = instr_index
+		self.operation = MediumLevelILOperation(instr.operation)
+		self.size = instr.size
+		self.address = instr.address
+		operands = MediumLevelILInstruction.ILOperations[instr.operation]
+		self.operands = []
+		i = 0
+		for operand in operands:
+			name, operand_type = operand
+			if operand_type == "int":
+				value = instr.operands[i]
+			elif operand_type == "expr":
+				value = MediumLevelILInstruction(func, instr.operands[i])
+			elif operand_type == "var":
+				value = function.Variable.from_identifier(self.function.source_function, instr.operands[i])
+			elif operand_type == "var_ssa":
+				var = function.Variable.from_identifier(self.function.source_function, instr.operands[i])
+				version = instr.operands[i + 1]
+				i += 1
+				value = SSAVariable(var, version)
+			elif operand_type == "var_ssa_dest_and_src":
+				var = function.Variable.from_identifier(self.function.source_function, instr.operands[i])
+				dest_version = instr.operands[i + 1]
+				src_version = instr.operands[i + 2]
+				i += 2
+				self.operands.append(SSAVariable(var, dest_version))
+				self.dest = SSAVariable(var, dest_version)
+				value = SSAVariable(var, src_version)
+			elif operand_type == "int_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				value = []
+				for j in xrange(count.value):
+					value.append(operand_list[j])
+				core.BNMediumLevelILFreeOperandList(operand_list)
+			elif operand_type == "var_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
+				value = []
+				for j in xrange(count.value):
+					value.append(function.Variable.from_identifier(self.function.source_function, operand_list[j]))
+				core.BNMediumLevelILFreeOperandList(operand_list)
+			elif operand_type == "var_ssa_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
+				value = []
+				for j in xrange(count.value / 2):
+					var_id = operand_list[j * 2]
+					var_version = operand_list[(j * 2) + 1]
+					value.append(SSAVariable(function.Variable.from_identifier(self.function.source_function,
+						var_id), var_version))
+				core.BNMediumLevelILFreeOperandList(operand_list)
+			elif operand_type == "expr_list":
+				count = ctypes.c_ulonglong()
+				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self.expr_index, i, count)
+				i += 1
+				value = []
+				for j in xrange(count.value):
+					value.append(MediumLevelILInstruction(func, operand_list[j]))
+				core.BNMediumLevelILFreeOperandList(operand_list)
+			self.operands.append(value)
+			self.__dict__[name] = value
+			i += 1
+
+	def __str__(self):
+		tokens = self.tokens
+		if tokens is None:
+			return "invalid"
+		result = ""
+		for token in tokens:
+			result += token.text
+		return result
+
+	def __repr__(self):
+		return "<il: %s>" % str(self)
+
+	@property
+	def tokens(self):
+		"""MLIL tokens (read-only)"""
+		count = ctypes.c_ulonglong()
+		tokens = ctypes.POINTER(core.BNInstructionTextToken)()
+		if ((self.instr_index is not None) and (self.function.source_function is not None) and
+			(self.expr_index == core.BNGetMediumLevelILIndexForInstruction(self.function.handle, self.instr_index))):
+			if not core.BNGetMediumLevelILInstructionText(self.function.handle, self.function.source_function.handle,
+				self.function.arch.handle, self.instr_index, tokens, count):
+				return None
+		else:
+			if not core.BNGetMediumLevelILExprText(self.function.handle, self.function.arch.handle,
+				self.expr_index, tokens, count):
+				return None
+		result = []
+		for i in xrange(0, count.value):
+			token_type = InstructionTextTokenType(tokens[i].type)
+			text = tokens[i].text
+			value = tokens[i].value
+			size = tokens[i].size
+			operand = tokens[i].operand
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
+		core.BNFreeInstructionText(tokens, count.value)
+		return result
+
+	@property
+	def ssa_form(self):
+		"""SSA form of expression (read-only)"""
+		return MediumLevelILInstruction(self.function.ssa_form,
+			core.BNGetMediumLevelILSSAExprIndex(self.function.handle, self.expr_index))
+
+	@property
+	def non_ssa_form(self):
+		"""Non-SSA form of expression (read-only)"""
+		return MediumLevelILInstruction(self.function.non_ssa_form,
+			core.BNGetMediumLevelILNonSSAExprIndex(self.function.handle, self.expr_index))
+
+	@property
+	def value(self):
+		"""Value of expression if constant or a known value (read-only)"""
+		value = core.BNGetMediumLevelILExprValue(self.function.handle, self.expr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	@property
+	def possible_values(self):
+		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
+		value = core.BNGetMediumLevelILPossibleExprValues(self.function.handle, self.expr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	@property
+	def branch_dependence(self):
+		"""Set of branching instructions that must take the true or false path to reach this instruction"""
+		count = ctypes.c_ulonglong()
+		deps = core.BNGetAllMediumLevelILBranchDependence(self.function.handle, self.instr_index, count)
+		result = {}
+		for i in xrange(0, count.value):
+			result[deps[i].branch] = ILBranchDependence(deps[i].dependence)
+		core.BNFreeILBranchDependenceList(deps)
+		return result
+
+	@property
+	def low_level_il(self):
+		"""Low level IL form of this expression"""
+		expr = self.function.get_low_level_il_expr_index(self.expr_index)
+		if expr is None:
+			return None
+		return lowlevelil.LowLevelILInstruction(self.function.low_level_il.ssa_form, expr)
+
+	@property
+	def ssa_memory_version(self):
+		"""Version of active memory contents in SSA form for this instruction"""
+		return core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction(self.function.handle, self.instr_index)
+
+	@property
+	def prefix_operands(self):
+		"""All operands in the expression tree in prefix order"""
+		result = [MediumLevelILOperationAndSize(self.operation, self.size)]
+		for operand in self.operands:
+			if isinstance(operand, MediumLevelILInstruction):
+				result += operand.prefix_operands
+			else:
+				result.append(operand)
+		return result
+
+	@property
+	def postfix_operands(self):
+		"""All operands in the expression tree in postfix order"""
+		result = []
+		for operand in self.operands:
+			if isinstance(operand, MediumLevelILInstruction):
+				result += operand.postfix_operands
+			else:
+				result.append(operand)
+		result.append(MediumLevelILOperationAndSize(self.operation, self.size))
+		return result
+
+	@property
+	def vars_written(self):
+		"""List of variables written by instruction"""
+		if self.operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
+			MediumLevelILOperation.MLIL_SET_VAR_SSA, MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
+			MediumLevelILOperation.MLIL_SET_VAR_ALIASED, MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD,
+			MediumLevelILOperation.MLIL_VAR_PHI]:
+			return [self.dest]
+		elif self.operation in [MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA]:
+			return [self.high, self.low]
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL]:
+			return self.output
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED,
+			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA,
+			MediumLevelILOperation.MLIL_SYSCALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA]:
+			return self.output.vars_written
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
+			return self.dest
+		return []
+
+	@property
+	def vars_read(self):
+		"""List of variables read by instruction"""
+		if self.operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
+			MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SSA,
+			MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA, MediumLevelILOperation.MLIL_SET_VAR_ALIASED]:
+			return self.src.vars_read
+		elif self.operation in [MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
+			MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD]:
+			return [self.prev] + self.src.vars_read
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL,
+			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_SSA]:
+			result = []
+			for param in self.params:
+				result += param.vars_read
+			return result
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED,
+			MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA]:
+			return self.params.vars_read
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL_PARAM, MediumLevelILOperation.MLIL_CALL_PARAM_SSA,
+			MediumLevelILOperation.MLIL_VAR_PHI]:
+			return self.src
+		elif self.operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
+			return []
+		result = []
+		for operand in self.operands:
+			if (isinstance(operand, function.Variable)) or (isinstance(operand, SSAVariable)):
+				result.append(operand)
+			elif isinstance(operand, MediumLevelILInstruction):
+				result += operand.vars_read
+		return result
+
+	def get_ssa_var_possible_values(self, ssa_var):
+		var_data = core.BNVariable()
+		var_data.type = ssa_var.var.source_type
+		var_data.index = ssa_var.var.index
+		var_data.storage = ssa_var.var.storage
+		value = core.BNGetMediumLevelILPossibleSSAVarValues(self.function.handle, var_data, ssa_var.version, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_ssa_var_version(self, var):
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		return core.BNGetMediumLevelILSSAVarVersionAtILInstruction(self.function.handle, var_data, self.instr_index)
+
+	def get_var_for_reg(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		result = core.BNGetMediumLevelILVariableForRegisterAtInstruction(self.function.handle, reg, self.instr_index)
+		return function.Variable(self.function.source_function, result.type, result.index, result.storage)
+
+	def get_var_for_flag(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		result = core.BNGetMediumLevelILVariableForFlagAtInstruction(self.function.handle, flag, self.instr_index)
+		return function.Variable(self.function.source_function, result.type, result.index, result.storage)
+
+	def get_var_for_stack_location(self, offset):
+		result = core.BNGetMediumLevelILVariableForStackLocationAtInstruction(self.function.handle, offset, self.instr_index)
+		return function.Variable(self.function.source_function, result.type, result.index, result.storage)
+
+	def get_reg_value(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILRegisterValueAtInstruction(self.function.handle, reg, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_reg_value_after(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILRegisterValueAfterInstruction(self.function.handle, reg, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_reg_values(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction(self.function.handle, reg, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_reg_values_after(self, reg):
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(self.function.handle, reg, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_flag_value(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILFlagValueAtInstruction(self.function.handle, flag, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_flag_value_after(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILFlagValueAfterInstruction(self.function.handle, flag, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_flag_values(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction(self.function.handle, flag, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_flag_values_after(self, flag):
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction(self.function.handle, flag, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_stack_contents(self, offset, size):
+		value = core.BNGetMediumLevelILStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_stack_contents_after(self, offset, size):
+		value = core.BNGetMediumLevelILStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.RegisterValue(self.function.arch, value)
+		return result
+
+	def get_possible_stack_contents(self, offset, size):
+		value = core.BNGetMediumLevelILPossibleStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_possible_stack_contents_after(self, offset, size):
+		value = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index)
+		result = function.PossibleValueSet(self.function.arch, value)
+		core.BNFreePossibleValueSet(value)
+		return result
+
+	def get_branch_dependence(self, branch_instr):
+		return ILBranchDependence(core.BNGetMediumLevelILBranchDependence(self.function.handle, self.instr_index, branch_instr))
+
+	def __setattr__(self, name, value):
+		try:
+			object.__setattr__(self, name, value)
+		except AttributeError:
+			raise AttributeError("attribute '%s' is read only" % name)
+
+
+class MediumLevelILExpr(object):
+	"""
+	``class MediumLevelILExpr`` hold the index of IL Expressions.
+
+	.. note:: This class shouldn't be instantiated directly. Rather the helper members of MediumLevelILFunction should be \
+	used instead.
+	"""
+	def __init__(self, index):
+		self.index = index
+
+
+class MediumLevelILFunction(object):
+	"""
+	``class MediumLevelILFunction`` contains the list of MediumLevelILExpr objects that make up a function. MediumLevelILExpr
+	objects can be added to the MediumLevelILFunction by calling ``append`` and passing the result of the various class
+	methods which return MediumLevelILExpr objects.
+	"""
+	def __init__(self, arch, handle = None, source_func = None):
+		self.arch = arch
+		self.source_function = source_func
+		if handle is not None:
+			self.handle = core.handle_of_type(handle, core.BNMediumLevelILFunction)
+		else:
+			func_handle = None
+			if self.source_function is not None:
+				func_handle = self.source_function.handle
+			self.handle = core.BNCreateMediumLevelILFunction(arch.handle, func_handle)
+
+	def __del__(self):
+		core.BNFreeMediumLevelILFunction(self.handle)
+
+	def __eq__(self, value):
+		if not isinstance(value, MediumLevelILFunction):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, MediumLevelILFunction):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
+	@property
+	def current_address(self):
+		"""Current IL Address (read/write)"""
+		return core.BNMediumLevelILGetCurrentAddress(self.handle)
+
+	@current_address.setter
+	def current_address(self, value):
+		core.BNMediumLevelILSetCurrentAddress(self.handle, self.arch.handle, value)
+
+	def set_current_address(self, value, arch = None):
+		if arch is None:
+			arch = self.arch
+		core.BNMediumLevelILSetCurrentAddress(self.handle, arch.handle, value)
+
+	@property
+	def basic_blocks(self):
+		"""list of MediumLevelILBasicBlock objects (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetMediumLevelILBasicBlockList(self.handle, count)
+		result = []
+		view = None
+		if self.source_function is not None:
+			view = self.source_function.view
+		for i in xrange(0, count.value):
+			result.append(MediumLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self))
+		core.BNFreeBasicBlockList(blocks, count.value)
+		return result
+
+	@property
+	def ssa_form(self):
+		"""Medium level IL in SSA form (read-only)"""
+		result = core.BNGetMediumLevelILSSAForm(self.handle)
+		if not result:
+			return None
+		return MediumLevelILFunction(self.arch, result, self.source_function)
+
+	@property
+	def non_ssa_form(self):
+		"""Medium level IL in non-SSA (default) form (read-only)"""
+		result = core.BNGetMediumLevelILNonSSAForm(self.handle)
+		if not result:
+			return None
+		return MediumLevelILFunction(self.arch, result, self.source_function)
+
+	@property
+	def low_level_il(self):
+		"""Low level IL for this function"""
+		result = core.BNGetLowLevelILForMediumLevelIL(self.handle)
+		if not result:
+			return None
+		return lowlevelil.LowLevelILFunction(self.arch, result, self.source_function)
+
+	def __setattr__(self, name, value):
+		try:
+			object.__setattr__(self, name, value)
+		except AttributeError:
+			raise AttributeError("attribute '%s' is read only" % name)
+
+	def __len__(self):
+		return int(core.BNGetMediumLevelILInstructionCount(self.handle))
+
+	def __getitem__(self, i):
+		if isinstance(i, slice) or isinstance(i, tuple):
+			raise IndexError("expected integer instruction index")
+		if isinstance(i, MediumLevelILExpr):
+			return MediumLevelILInstruction(self, i.index)
+		if (i < 0) or (i >= len(self)):
+			raise IndexError("index out of range")
+		return MediumLevelILInstruction(self, core.BNGetMediumLevelILIndexForInstruction(self.handle, i), i)
+
+	def __setitem__(self, i, j):
+		raise IndexError("instruction modification not implemented")
+
+	def __iter__(self):
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetMediumLevelILBasicBlockList(self.handle, count)
+		view = None
+		if self.source_function is not None:
+			view = self.source_function.view
+		try:
+			for i in xrange(0, count.value):
+				yield MediumLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self)
+		finally:
+			core.BNFreeBasicBlockList(blocks, count.value)
+
+	def get_instruction_start(self, addr, arch = None):
+		if arch is None:
+			arch = self.arch
+		result = core.BNMediumLevelILGetInstructionStart(self.handle, arch.handle, addr)
+		if result >= core.BNGetMediumLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def expr(self, operation, a = 0, b = 0, c = 0, d = 0, e = 0, size = 0):
+		if isinstance(operation, str):
+			operation = MediumLevelILOperation[operation]
+		elif isinstance(operation, MediumLevelILOperation):
+			operation = operation.value
+		return MediumLevelILExpr(core.BNMediumLevelILAddExpr(self.handle, operation, size, a, b, c, d, e))
+
+	def append(self, expr):
+		"""
+		``append`` adds the MediumLevelILExpr ``expr`` to the current MediumLevelILFunction.
+
+		:param MediumLevelILExpr expr: the MediumLevelILExpr to add to the current MediumLevelILFunction
+		:return: number of MediumLevelILExpr in the current function
+		:rtype: int
+		"""
+		return core.BNMediumLevelILAddInstruction(self.handle, expr.index)
+
+	def goto(self, label):
+		"""
+		``goto`` returns a goto expression which jumps to the provided MediumLevelILLabel.
+
+		:param MediumLevelILLabel label: Label to jump to
+		:return: the MediumLevelILExpr that jumps to the provided label
+		:rtype: MediumLevelILExpr
+		"""
+		return MediumLevelILExpr(core.BNMediumLevelILGoto(self.handle, label.handle))
+
+	def if_expr(self, operand, t, f):
+		"""
+		``if_expr`` returns the ``if`` expression which depending on condition ``operand`` jumps to the MediumLevelILLabel
+		``t`` when the condition expression ``operand`` is non-zero and ``f`` when it's zero.
+
+		:param MediumLevelILExpr operand: comparison expression to evaluate.
+		:param MediumLevelILLabel t: Label for the true branch
+		:param MediumLevelILLabel f: Label for the false branch
+		:return: the MediumLevelILExpr for the if expression
+		:rtype: MediumLevelILExpr
+		"""
+		return MediumLevelILExpr(core.BNMediumLevelILIf(self.handle, operand.index, t.handle, f.handle))
+
+	def mark_label(self, label):
+		"""
+		``mark_label`` assigns a MediumLevelILLabel to the current IL address.
+
+		:param MediumLevelILLabel label:
+		:rtype: None
+		"""
+		core.BNMediumLevelILMarkLabel(self.handle, label.handle)
+
+	def add_label_list(self, labels):
+		"""
+		``add_label_list`` returns a label list expression for the given list of MediumLevelILLabel objects.
+
+		:param list(MediumLevelILLabel) lables: the list of MediumLevelILLabel to get a label list expression from
+		:return: the label list expression
+		:rtype: MediumLevelILExpr
+		"""
+		label_list = (ctypes.POINTER(core.BNMediumLevelILLabel) * len(labels))()
+		for i in xrange(len(labels)):
+			label_list[i] = labels[i].handle
+		return MediumLevelILExpr(core.BNMediumLevelILAddLabelList(self.handle, label_list, len(labels)))
+
+	def add_operand_list(self, operands):
+		"""
+		``add_operand_list`` returns an operand list expression for the given list of integer operands.
+
+		:param list(int) operands: list of operand numbers
+		:return: an operand list expression
+		:rtype: MediumLevelILExpr
+		"""
+		operand_list = (ctypes.c_ulonglong * len(operands))()
+		for i in xrange(len(operands)):
+			operand_list[i] = operands[i]
+		return MediumLevelILExpr(core.BNMediumLevelILAddOperandList(self.handle, operand_list, len(operands)))
+
+	def operand(self, n, expr):
+		"""
+		``operand`` sets the operand number of the expression ``expr`` and passes back ``expr`` without modification.
+
+		:param int n:
+		:param MediumLevelILExpr expr:
+		:return: returns the expression ``expr`` unmodified
+		:rtype: MediumLevelILExpr
+		"""
+		core.BNMediumLevelILSetExprSourceOperand(self.handle, expr.index, n)
+		return expr
+
+	def finalize(self):
+		"""
+		``finalize`` ends the function and computes the list of basic blocks.
+
+		:rtype: None
+		"""
+		core.BNFinalizeMediumLevelILFunction(self.handle)
+
+	def get_ssa_instruction_index(self, instr):
+		return core.BNGetMediumLevelILSSAInstructionIndex(self.handle, instr)
+
+	def get_non_ssa_instruction_index(self, instr):
+		return core.BNGetMediumLevelILNonSSAInstructionIndex(self.handle, instr)
+
+	def get_ssa_var_definition(self, ssa_var):
+		var_data = core.BNVariable()
+		var_data.type = ssa_var.var.source_type
+		var_data.index = ssa_var.var.index
+		var_data.storage = ssa_var.var.storage
+		result = core.BNGetMediumLevelILSSAVarDefinition(self.handle, var_data, ssa_var.version)
+		if result >= core.BNGetMediumLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def get_ssa_memory_definition(self, version):
+		result = core.BNGetMediumLevelILSSAMemoryDefinition(self.handle, version)
+		if result >= core.BNGetMediumLevelILInstructionCount(self.handle):
+			return None
+		return result
+
+	def get_ssa_var_uses(self, ssa_var):
+		count = ctypes.c_ulonglong()
+		var_data = core.BNVariable()
+		var_data.type = ssa_var.var.source_type
+		var_data.index = ssa_var.var.index
+		var_data.storage = ssa_var.var.storage
+		instrs = core.BNGetMediumLevelILSSAVarUses(self.handle, var_data, ssa_var.version, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(instrs[i])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_ssa_memory_uses(self, version):
+		count = ctypes.c_ulonglong()
+		instrs = core.BNGetMediumLevelILSSAMemoryUses(self.handle, version, count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(instrs[i])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_ssa_var_value(self, ssa_var):
+		var_data = core.BNVariable()
+		var_data.type = ssa_var.var.source_type
+		var_data.index = ssa_var.var.index
+		var_data.storage = ssa_var.var.storage
+		value = core.BNGetMediumLevelILSSAVarValue(self.handle, var_data, ssa_var.version)
+		result = function.RegisterValue(self.arch, value)
+		return result
+
+	def get_low_level_il_instruction_index(self, instr):
+		low_il = self.low_level_il
+		if low_il is None:
+			return None
+		low_il = low_il.ssa_form
+		if low_il is None:
+			return None
+		result = core.BNGetLowLevelILInstructionIndex(self.handle, instr)
+		if result >= core.BNGetLowLevelILInstructionCount(low_il.handle):
+			return None
+		return result
+
+	def get_low_level_il_expr_index(self, expr):
+		low_il = self.low_level_il
+		if low_il is None:
+			return None
+		low_il = low_il.ssa_form
+		if low_il is None:
+			return None
+		result = core.BNGetLowLevelILExprIndex(self.handle, expr)
+		if result >= core.BNGetLowLevelILExprCount(low_il.handle):
+			return None
+		return result
+
+
+class MediumLevelILBasicBlock(basicblock.BasicBlock):
+	def __init__(self, view, handle, owner):
+		super(MediumLevelILBasicBlock, self).__init__(view, handle)
+		self.il_function = owner
+
+	def __iter__(self):
+		for idx in xrange(self.start, self.end):
+			yield self.il_function[idx]
+
+	def __getitem__(self, idx):
+		size = self.end - self.start
+		if idx > size or idx < -size:
+			raise IndexError("list index is out of range")
+		if idx >= 0:
+			return self.il_function[idx + self.start]
+		else:
+			return self.il_function[self.end + idx]
diff --git a/python/platform.py b/python/platform.py
index 04dce587..9ba7625f 100644
--- a/python/platform.py
+++ b/python/platform.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -25,6 +25,7 @@ import _binaryninjacore as core
 import startup
 import architecture
 import callingconvention
+import types
 
 
 class _PlatformMetaClass(type):
@@ -109,6 +110,16 @@ class Platform(object):
 	def __del__(self):
 		core.BNFreePlatform(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, Platform):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Platform):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def default_calling_convention(self):
 		"""
@@ -215,6 +226,55 @@ class Platform(object):
 		core.BNFreeCallingConventionList(cc, count.value)
 		return result
 
+	@property
+	def types(self):
+		"""List of platform-specific types (read-only)"""
+		count = ctypes.c_ulonglong(0)
+		type_list = core.BNGetPlatformTypes(self.handle, count)
+		result = {}
+		for i in xrange(0, count.value):
+			name = types.QualifiedName._from_core_struct(type_list[i].name)
+			result[name] = types.Type(core.BNNewTypeReference(type_list[i].type))
+		core.BNFreeTypeList(type_list, count.value)
+		return result
+
+	@property
+	def variables(self):
+		"""List of platform-specific variable definitions (read-only)"""
+		count = ctypes.c_ulonglong(0)
+		type_list = core.BNGetPlatformVariables(self.handle, count)
+		result = {}
+		for i in xrange(0, count.value):
+			name = types.QualifiedName._from_core_struct(type_list[i].name)
+			result[name] = types.Type(core.BNNewTypeReference(type_list[i].type))
+		core.BNFreeTypeList(type_list, count.value)
+		return result
+
+	@property
+	def functions(self):
+		"""List of platform-specific function definitions (read-only)"""
+		count = ctypes.c_ulonglong(0)
+		type_list = core.BNGetPlatformFunctions(self.handle, count)
+		result = {}
+		for i in xrange(0, count.value):
+			name = types.QualifiedName._from_core_struct(type_list[i].name)
+			result[name] = types.Type(core.BNNewTypeReference(type_list[i].type))
+		core.BNFreeTypeList(type_list, count.value)
+		return result
+
+	@property
+	def system_calls(self):
+		"""List of system calls for this platform (read-only)"""
+		count = ctypes.c_ulonglong(0)
+		call_list = core.BNGetPlatformSystemCalls(self.handle, count)
+		result = {}
+		for i in xrange(0, count.value):
+			name = types.QualifiedName._from_core_struct(call_list[i].name)
+			t = types.Type(core.BNNewTypeReference(call_list[i].type))
+			result[call_list[i].number] = (name, t)
+		core.BNFreeSystemCallList(call_list, count.value)
+		return result
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self, name, value)
@@ -259,3 +319,44 @@ class Platform(object):
 		new_addr.value = addr
 		result = core.BNGetAssociatedPlatformByAddress(self.handle, new_addr)
 		return Platform(None, handle = result), new_addr.value
+
+	def get_type_by_name(self, name):
+		name = types.QualifiedName(name)._get_core_struct()
+		obj = core.BNGetPlatformTypeByName(self.handle, name)
+		if not obj:
+			return None
+		return types.Type(obj)
+
+	def get_variable_by_name(self, name):
+		name = types.QualifiedName(name)._get_core_struct()
+		obj = core.BNGetPlatformVariableByName(self.handle, name)
+		if not obj:
+			return None
+		return types.Type(obj)
+
+	def get_function_by_name(self, name):
+		name = types.QualifiedName(name)._get_core_struct()
+		obj = core.BNGetPlatformFunctionByName(self.handle, name)
+		if not obj:
+			return None
+		return types.Type(obj)
+
+	def get_system_call_name(self, number):
+		return core.BNGetPlatformSystemCallName(self.handle, number)
+
+	def get_system_call_type(self, number):
+		obj = core.BNGetPlatformSystemCallType(self.handle, number)
+		if not obj:
+			return None
+		return types.Type(obj)
+
+	def generate_auto_platform_type_id(self, name):
+		name = types.QualifiedName(name)._get_core_struct()
+		return core.BNGenerateAutoPlatformTypeId(self.handle, name)
+
+	def generate_auto_platform_type_ref(self, type_class, name):
+		type_id = self.generate_auto_platform_type_id(name)
+		return types.NamedTypeReference(type_class, type_id, name)
+
+	def get_auto_platform_type_id_source(self):
+		return core.BNGetAutoPlatformTypeIdSource(self.handle)
diff --git a/python/plugin.py b/python/plugin.py
index 2632b5a9..f038d122 100644
--- a/python/plugin.py
+++ b/python/plugin.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/pluginmanager.py b/python/pluginmanager.py
new file mode 100644
index 00000000..c0f70260
--- /dev/null
+++ b/python/pluginmanager.py
@@ -0,0 +1,377 @@
+# Copyright (c) 2015-2017 Vector 35 LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import ctypes
+
+# Binary Ninja components
+import _binaryninjacore as core
+from .enums import PluginType, PluginUpdateStatus
+import startup
+
+
+class RepoPlugin(object):
+	"""
+	``RepoPlugin` is mostly read-only, however you can install/uninstall enable/disable plugins. RepoPlugins are
+	created by parsing the plugins.json in a plugin repository.
+	"""
+	def __init__(self, handle):
+		self.handle = core.handle_of_type(handle, core.BNRepoPlugin)
+
+	def __del__(self):
+		core.BNFreePlugin(self.handle)
+
+	def __repr__(self):
+		return "<{} {}/{}>".format(self.path, "installed" if self.installed else "not-installed", "enabled" if self.enabled else "disabled")
+
+	@property
+	def path(self):
+		"""Relative path from the base of the repository to the actual plugin"""
+		return core.BNPluginGetPath(self.handle)
+
+	@property
+	def installed(self):
+		"""Boolean True if the plugin is installed, False otherwise"""
+		return core.BNPluginIsInstalled(self.handle)
+
+	@installed.setter
+	def installed(self, state):
+		if state:
+			return core.BNPluginInstall(self.handle)
+		else:
+			return core.BNPluginUninstall(self.handle)
+
+	@property
+	def enabled(self):
+		"""Boolean True if the plugin is currently enabled, False otherwise"""
+		return core.BNPluginIsEnabled(self.handle)
+
+	@enabled.setter
+	def enabled(self, state):
+		if state:
+			return core.BNPluginEnable(self.handle)
+		else:
+			return core.BNPluginDisable(self.handle)
+
+	@property
+	def api(self):
+		"""string indicating the api used by the plugin"""
+		return core.BNPluginGetApi(self.handle)
+
+	@property
+	def description(self):
+		"""String short description of the plugin"""
+		return core.BNPluginGetDescription(self.handle)
+
+	@property
+	def license(self):
+		"""String short license description (ie MIT, BSD, GPLv2, etc)"""
+		return core.BNPluginGetLicense(self.handle)
+
+	@property
+	def license_text(self):
+		"""String complete license text for the given plugin"""
+		return core.BNPluginGetLicenseText(self.handle)
+
+	@property
+	def long_description(self):
+		"""String long description of the plugin"""
+		return core.BNPluginGetLongdescription(self.handle)
+
+	@property
+	def minimum_version(self):
+		"""String minimum version the plugin was tested on"""
+		return core.BNPluginGetMinimimVersions(self.handle)
+
+	@property
+	def name(self):
+		"""String name of the plugin"""
+		return core.BNPluginGetName(self.handle)
+
+	@property
+	def plugin_types(self):
+		"""List of PluginType enumeration objects indicating the plugin type(s)"""
+		result = []
+		count = ctypes.c_ulonglong(0)
+		plugintypes = core.BNPluginGetPluginTypes(self.handle, count)
+		for i in xrange(count.value):
+			result.append(PluginType(plugintypes[i]))
+		core.BNFreePluginTypes(plugintypes)
+		return result
+
+	@property
+	def url(self):
+		"""String url of the plugin's git repository"""
+		return core.BNPluginGetUrl(self.handle)
+
+	@property
+	def version(self):
+		"""String version of the plugin"""
+		return core.BNPluginGetVersion(self.handle)
+
+	@property
+	def update_status(self):
+		"""PluginUpdateStatus enumeration indicating if the plugin is up to date or not"""
+		return PluginUpdateStatus(core.BNPluginGetPluginUpdateStatus(self.handle))
+
+
+class Repository(object):
+	"""
+	``Repository`` is a read-only class. Use RepositoryManager to Enable/Disable/Install/Uninstall plugins.
+	"""
+	def __init__(self, handle):
+		self.handle = core.handle_of_type(handle, core.BNRepository)
+
+	def __del__(self):
+		core.BNFreeRepository(self.handle)
+
+	def __repr__(self):
+		return "<{} - {}/{}>".format(self.path, self.remote_reference, self.local_reference)
+
+	@property
+	def url(self):
+		"""String url of the git repository where the plugin repository's are stored"""
+		return core.BNRepositoryGetUrl(self.handle)
+
+	@property
+	def path(self):
+		"""String local path to store the given plugin repository"""
+		return core.BNRepositoryGetRepoPath(self.handle)
+
+	@property
+	def local_reference(self):
+		"""String for the local git reference (ie 'master')"""
+		return core.BNRepositoryGetLocalReference(self.handle)
+
+	@property
+	def remote_reference(self):
+		"""String for the remote git reference (ie 'origin')"""
+		return core.BNRepositoryGetRemoteReference(self.handle)
+
+	@property
+	def plugins(self):
+		"""List of RepoPlugin objects contained within this repository"""
+		pluginlist = []
+		count = ctypes.c_ulonglong(0)
+		result = core.BNRepositoryGetPlugins(self.handle, count)
+		for i in xrange(count.value):
+			pluginlist.append(RepoPlugin(handle=result[i]))
+		core.BNFreeRepositoryPluginList(result, count.value)
+		del result
+		return pluginlist
+
+	@property
+	def initialized(self):
+		"""Boolean True when the repository has been initialized"""
+		return core.BNRepositoryIsInitialized(self.handle)
+
+
+class RepositoryManager(object):
+	"""
+	``RepositoryManager`` Keeps track of all the repositories and keeps the enabled_plugins.json file coherent with
+	the plugins that are installed/unstalled enabled/disabled
+	"""
+	def __init__(self, handle=None):
+		self.handle = core.BNGetRepositoryManager()
+
+	def check_for_updates(self):
+		"""Check for updates for all managed Repository objects"""
+		return core.BNRepositoryManagerCheckForUpdates(self.handle)
+
+	@property
+	def repositories(self):
+		"""List of Repository objects being managed"""
+		result = []
+		count = ctypes.c_ulonglong(0)
+		repos = core.BNRepositoryManagerGetRepositories(self.handle, count)
+		for i in xrange(count.value):
+			result.append(Repository(handle=repos[i]))
+		core.BNFreeRepositoryManagerRepositoriesList(repos)
+		return result
+
+	@property
+	def plugins(self):
+		"""List of all RepoPlugins in each repository"""
+		plgs = {}
+		for repo in self.repositories:
+			plgs[repo.path] = repo.plugins
+		return plgs
+
+	@property
+	def default_repository(self):
+		"""Gets the default Repository"""
+		startup._init_plugins()
+		return Repository(handle=core.BNRepositoryManagerGetDefaultRepository(self.handle))
+
+	def enable_plugin(self, plugin, install=True, repo=None):
+		"""
+		``enable_plugin`` Enables the installed plugin 'plugin', optionally installing the plugin if `install` is set to
+		True (default), and optionally using the non-default repository.
+
+		:param str name: Name of the plugin to enable
+		:param Boolean install: Optionally install the repo, defaults to True.
+		:param str repo: Optional, specify a repository other than the default repository.
+		:return: Boolean value True if the plugin was successfully enabled, False otherwise
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.enable_plugin('binaryninja-bookmarks')
+			True
+			>>>
+		"""
+		if install:
+			if not self.install_plugin(plugin, repo):
+				return False
+
+		if repo is None:
+			repo = self.default_repository
+		repopath = repo
+		pluginpath = plugin
+		if not isinstance(repo, str):
+			repopath = repo.path
+		if not isinstance(plugin, str):
+			pluginpath = plugin.path
+		return core.BNRepositoryManagerEnablePlugin(self.handle, repopath, pluginpath)
+
+	def disable_plugin(self, plugin, repo=None):
+		"""
+		``disable_plugin`` Disable the specified plugin, pluginpath
+
+		:param Repository or str repo: Repository containing the plugin to disable
+		:param RepoPlugin or str plugin: RepoPlugin to disable
+		:return: Boolean value True if the plugin was successfully disabled, False otherwise
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.disable_plugin('binaryninja-bookmarks')
+			True
+			>>>
+		"""
+		if repo is None:
+			repo = self.default_repository
+		repopath = repo
+		pluginpath = plugin
+		if not isinstance(repo, str):
+			repopath = repo.path
+		if not isinstance(plugin, str):
+			pluginpath = plugin.path
+		return core.BNRepositoryManagerDisablePlugin(self.handle, repopath, pluginpath)
+
+	def install_plugin(self, plugin, repo=None):
+		"""
+		``install_plugin`` install the specified plugin, pluginpath
+
+		:param Repository or str repo: Repository containing the plugin to install
+		:param RepoPlugin or str plugin: RepoPlugin to install
+		:return: Boolean value True if the plugin was successfully installed, False otherwise
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.install_plugin('binaryninja-bookmarks')
+			True
+			>>>
+		"""
+		if repo is None:
+			repo = self.default_repository
+		repopath = repo
+		pluginpath = plugin
+		if not isinstance(repo, str):
+			repopath = repo.path
+		if not isinstance(plugin, str):
+			pluginpath = plugin.path
+		return core.BNRepositoryManagerInstallPlugin(self.handle, repopath, pluginpath)
+
+	def uninstall_plugin(self, plugin, repo=None):
+		"""
+		``uninstall_plugin`` uninstall the specified plugin, pluginpath
+
+		:param Repository or str repo: Repository containing the plugin to uninstall
+		:param RepoPlugin or str plugin: RepoPlugin to uninstall
+		:return: Boolean value True if the plugin was successfully uninstalled, False otherwise
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.uninstall_plugin('binaryninja-bookmarks')
+			True
+			>>>
+		"""
+		if repo is None:
+			repo = self.default_repository
+		repopath = repo
+		pluginpath = plugin
+		if not isinstance(repo, str):
+			repopath = repo.path
+		if not isinstance(plugin, str):
+			pluginpath = plugin.path
+		return core.BNRepositoryManagerUninstallPlugin(self.handle, repopath, pluginpath)
+
+	def update_plugin(self, plugin, repo=None):
+		"""
+		``update_plugin`` update the specified plugin, pluginpath
+
+		:param Repository or str repo: Repository containing the plugin to update
+		:param RepoPlugin or str plugin: RepoPlugin to update
+		:return: Boolean value True if the plugin was successfully updated, False otherwise
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.update_plugin('binaryninja-bookmarks')
+			True
+			>>>
+		"""
+		if repo is None:
+			repo = self.default_repository
+		repopath = repo
+		pluginpath = plugin
+		if not isinstance(repo, str):
+			repopath = repo.path
+		if not isinstance(plugin, str):
+			pluginpath = plugin.path
+		return core.BNRepositoryManagerUpdatePlugin(self.handle, repopath, pluginpath)
+
+	def add_repository(self, url=None, repopath=None, localreference="master", remotereference="origin"):
+		"""
+		``add_repository`` adds a new plugin repository for the manager to track.
+
+		:param str url: Url to the git repository where the plugins are stored.
+		:param str repopath: path to where the repository will be stored on disk locally
+		:param str localreference: Optional reference to the local tracking branch typically "master"
+		:param str remotereference: Optional reference to the remote tracking branch typically "origin"
+		:return: Boolean value True if the repository was successfully added, False otherwise.
+		:rtype: Boolean
+		:Example:
+
+			>>> mgr = RepositoryManager()
+			>>> mgr.add_repository(url="https://github.com/vector35/community-plugins.git",
+			                       repopath="myrepo",
+			                       repomanifest="plugins",
+			                       localreference="master", remotereference="origin")
+			True
+			>>>
+		"""
+		if not (isinstance(url, str) and isinstance(repopath, str) and
+			isinstance(localreference, str) and isinstance(remotereference, str)):
+			raise ValueError("Parameter is incorrect type")
+
+		return core.BNRepositoryManagerAddRepository(self.handle, url, repopath, localreference, remotereference)
diff --git a/python/scriptingprovider.py b/python/scriptingprovider.py
index 71402b1b..94616d59 100644
--- a/python/scriptingprovider.py
+++ b/python/scriptingprovider.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -35,8 +35,6 @@ import basicblock
 import startup
 import log
 
-_output_to_log = False
-
 
 class _ThreadActionContext(object):
 	_actions = []
@@ -379,14 +377,12 @@ class _PythonScriptingInstanceOutput(object):
 		return self.write('\n'.join(lines))
 
 	def write(self, data):
-		global _output_to_log
-
 		interpreter = None
 		if "value" in dir(PythonScriptingInstance._interpreter):
 			interpreter = PythonScriptingInstance._interpreter.value
 
 		if interpreter is None:
-			if _output_to_log:
+			if log.is_output_redirected_to_log():
 				self.buffer += data
 				while True:
 					i = self.buffer.find('\n')
diff --git a/python/startup.py b/python/startup.py
index 809f185b..0abc47cb 100644
--- a/python/startup.py
+++ b/python/startup.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -30,5 +30,6 @@ def _init_plugins():
 		_plugin_init = True
 		core.BNInitCorePlugins()
 		core.BNInitUserPlugins()
+		core.BNInitRepoPlugins()
 	if not core.BNIsLicenseValidated():
 		raise RuntimeError("License is not valid. Please supply a valid license.")
diff --git a/python/transform.py b/python/transform.py
index 0c003738..59d719e7 100644
--- a/python/transform.py
+++ b/python/transform.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -131,6 +131,16 @@ class Transform(object):
 	def __repr__(self):
 		return "<transform: %s>" % self.name
 
+	def __eq__(self, value):
+		if not isinstance(value, Transform):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Transform):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	def _get_parameters(self, ctxt, count):
 		try:
 			count[0] = len(self.parameters)
diff --git a/python/types.py b/python/types.py
index 62a441cd..f8e416f4 100644
--- a/python/types.py
+++ b/python/types.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -22,9 +22,92 @@ import ctypes
 
 # Binary Ninja components
 import _binaryninjacore as core
-from enums import SymbolType, TypeClass
+from enums import SymbolType, TypeClass, NamedTypeReferenceClass, InstructionTextTokenType, StructureType
 import callingconvention
-import demangle
+import function
+
+
+class QualifiedName(object):
+	def __init__(self, name = []):
+		if isinstance(name, str):
+			self.name = [name]
+		elif isinstance(name, QualifiedName):
+			self.name = name.name
+		else:
+			self.name = name
+
+	def __str__(self):
+		return "::".join(self.name)
+
+	def __repr__(self):
+		return repr(str(self))
+
+	def __len__(self):
+		return len(self.name)
+
+	def __hash__(self):
+		return hash(str(self))
+
+	def __eq__(self, other):
+		if isinstance(other, str):
+			return str(self) == other
+		elif isinstance(other, list):
+			return self.name == other
+		elif isinstance(other, QualifiedName):
+			return self.name == other.name
+		return False
+
+	def __ne__(self, other):
+		return not (self == other)
+
+	def __lt__(self, other):
+		if isinstance(other, QualifiedName):
+			return self.name < other.name
+		return False
+
+	def __le__(self, other):
+		if isinstance(other, QualifiedName):
+			return self.name <= other.name
+		return False
+
+	def __gt__(self, other):
+		if isinstance(other, QualifiedName):
+			return self.name > other.name
+		return False
+
+	def __ge__(self, other):
+		if isinstance(other, QualifiedName):
+			return self.name >= other.name
+		return False
+
+	def __cmp__(self, other):
+		if self == other:
+			return 0
+		if self < other:
+			return -1
+		return 1
+
+	def __getitem__(self, key):
+		return self.name[key]
+
+	def __iter__(self):
+		return iter(self.name)
+
+	def _get_core_struct(self):
+		result = core.BNQualifiedName()
+		name_list = (ctypes.c_char_p * len(self.name))()
+		for i in xrange(0, len(self.name)):
+			name_list[i] = self.name[i]
+		result.name = name_list
+		result.nameCount = len(self.name)
+		return result
+
+	@classmethod
+	def _from_core_struct(cls, name):
+		result = []
+		for i in xrange(0, name.nameCount):
+			result.append(name.name[i])
+		return QualifiedName(result)
 
 
 class Symbol(object):
@@ -56,6 +139,16 @@ class Symbol(object):
 	def __del__(self):
 		core.BNFreeSymbol(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, Symbol):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Symbol):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def type(self):
 		"""Symbol type (read-only)"""
@@ -111,6 +204,16 @@ class Type(object):
 	def __del__(self):
 		core.BNFreeType(self.handle)
 
+	def __eq__(self, value):
+		if not isinstance(value, Type):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, Type):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
 	@property
 	def type_class(self):
 		"""Type class (read-only)"""
@@ -210,6 +313,14 @@ class Type(object):
 			return None
 		return Enumeration(result)
 
+ 	@property
+	def named_type_reference(self):
+		"""Reference to a named type (read-only)"""
+		result = core.BNGetTypeNamedTypeReference(self.handle)
+		if result is None:
+			return None
+		return NamedTypeReference(handle = result)
+
 	@property
 	def count(self):
 		"""Type count (read-only)"""
@@ -227,6 +338,56 @@ class Type(object):
 	def get_string_after_name(self):
 		return core.BNGetTypeStringAfterName(self.handle)
 
+	@property
+	def tokens(self):
+		"""Type string as a list of tokens (read-only)"""
+		count = ctypes.c_ulonglong()
+		tokens = core.BNGetTypeTokens(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			token_type = InstructionTextTokenType(tokens[i].type)
+			text = tokens[i].text
+			value = tokens[i].value
+			size = tokens[i].size
+			operand = tokens[i].operand
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
+		core.BNFreeTokenList(tokens, count.value)
+		return result
+
+	def get_tokens_before_name(self):
+		count = ctypes.c_ulonglong()
+		tokens = core.BNGetTypeTokensBeforeName(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			token_type = InstructionTextTokenType(tokens[i].type)
+			text = tokens[i].text
+			value = tokens[i].value
+			size = tokens[i].size
+			operand = tokens[i].operand
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
+		core.BNFreeTokenList(tokens, count.value)
+		return result
+
+	def get_tokens_after_name(self):
+		count = ctypes.c_ulonglong()
+		tokens = core.BNGetTypeTokensAfterName(self.handle, count)
+		result = []
+		for i in xrange(0, count.value):
+			token_type = InstructionTextTokenType(tokens[i].type)
+			text = tokens[i].text
+			value = tokens[i].value
+			size = tokens[i].size
+			operand = tokens[i].operand
+			context = tokens[i].context
+			address = tokens[i].address
+			result.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address))
+		core.BNFreeTokenList(tokens, count.value)
+		return result
+
 	@classmethod
 	def void(cls):
 		return Type(core.BNCreateVoidType())
@@ -254,8 +415,27 @@ class Type(object):
 		return Type(core.BNCreateStructureType(structure_type.handle))
 
 	@classmethod
-	def unknown_type(self, unknown_type):
-		return Type(core.BNCreateUnknownType(unknown_type.handle))
+	def named_type(self, named_type, width = 0, align = 1):
+		return Type(core.BNCreateNamedTypeReference(named_type.handle, width, align))
+
+	@classmethod
+	def named_type_from_type_and_id(self, type_id, name, t):
+		name = QualifiedName(name)._get_core_struct()
+		if t is not None:
+			t = t.handle
+		return Type(core.BNCreateNamedTypeReferenceFromTypeAndId(type_id, name, t))
+
+	@classmethod
+	def named_type_from_type(self, name, t):
+		name = QualifiedName(name)._get_core_struct()
+		if t is not None:
+			t = t.handle
+		return Type(core.BNCreateNamedTypeReferenceFromTypeAndId("", name, t))
+
+	@classmethod
+	def named_type_from_registered_type(self, view, name):
+		name = QualifiedName(name)._get_core_struct()
+		return Type(core.BNCreateNamedTypeReferenceFromType(view.handle, name))
 
 	@classmethod
 	def enumeration_type(self, arch, e, width=None):
@@ -294,6 +474,20 @@ class Type(object):
 		return Type(core.BNCreateFunctionType(ret.handle, calling_convention, param_buf, len(params),
 			  variable_arguments))
 
+	@classmethod
+	def generate_auto_type_id(self, source, name):
+		name = QualifiedName(name)._get_core_struct()
+		return core.BNGenerateAutoTypeId(source, name)
+
+	@classmethod
+	def generate_auto_demangled_type_id(self, name):
+		name = QualifiedName(name)._get_core_struct()
+		return core.BNGenerateAutoDemangledTypeId(name)
+
+	@classmethod
+	def get_auto_demanged_type_id_source(self):
+		return core.BNGetAutoDemangledTypeIdSource()
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self, name, value)
@@ -301,28 +495,80 @@ class Type(object):
 			raise AttributeError("attribute '%s' is read only" % name)
 
 
-class UnknownType(object):
-	def __init__(self, handle=None):
+class NamedTypeReference(object):
+	def __init__(self, type_class = NamedTypeReferenceClass.UnknownNamedTypeClass, type_id = None, name = None, handle = None):
 		if handle is None:
-			self.handle = core.BNCreateUnknownType()
+			self.handle = core.BNCreateNamedType()
+			core.BNSetTypeReferenceClass(self.handle, type_class)
+			if type_id is not None:
+				core.BNSetTypeReferenceId(self.handle, type_id)
+			if name is not None:
+				name = QualifiedName(name)._get_core_struct()
+				core.BNSetTypeReferenceName(self.handle, name)
 		else:
 			self.handle = handle
 
 	def __del__(self):
-		core.BNFreeUnknownType(self.handle)
+		core.BNFreeNamedTypeReference(self.handle)
+
+	def __eq__(self, value):
+		if not isinstance(value, NamedTypeReference):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, NamedTypeReference):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
+	@property
+	def type_class(self):
+		return NamedTypeReferenceClass(core.BNGetTypeReferenceClass(self.handle))
+
+	@type_class.setter
+	def type_class(self, value):
+		core.BNSetTypeReferenceClass(self.handle, value)
+
+	@property
+	def type_id(self):
+		return core.BNGetTypeReferenceId(self.handle)
+
+	@type_id.setter
+	def type_id(self, value):
+		core.BNSetTypeReferenceId(self.handle, value)
 
 	@property
 	def name(self):
-		count = ctypes.c_ulonglong()
-		nameList = core.BNGetUnknownTypeName(self.handle, count)
-		result = []
-		for i in xrange(count.value):
-			result.append(nameList[i])
-		return demangle.get_qualified_name(result)
+		name = core.BNGetTypeReferenceName(self.handle)
+		result = QualifiedName._from_core_struct(name)
+		core.BNFreeQualifiedName(name)
+		return result
 
 	@name.setter
 	def name(self, value):
-		core.BNSetUnknownTypeName(self.handle, value)
+		value = QualifiedName(value)._get_core_struct()
+		core.BNSetTypeReferenceName(self.handle, value)
+
+	def __repr__(self):
+		if self.type_class == NamedTypeReferenceClass.TypedefNamedTypeClass:
+			return "<named type: typedef %s>" % str(self.name)
+		if self.type_class == NamedTypeReferenceClass.StructNamedTypeClass:
+			return "<named type: struct %s>" % str(self.name)
+		if self.type_class == NamedTypeReferenceClass.UnionNamedTypeClass:
+			return "<named type: union %s>" % str(self.name)
+		if self.type_class == NamedTypeReferenceClass.EnumNamedTypeClass:
+			return "<named type: enum %s>" % str(self.name)
+		return "<named type: unknown %s>" % str(self.name)
+
+	@classmethod
+	def generate_auto_type_ref(self, type_class, source, name):
+		type_id = Type.generate_auto_type_id(source, name)
+		return NamedTypeReference(type_class, type_id, name)
+
+	@classmethod
+	def generate_auto_demangled_type_ref(self, type_class, name):
+		type_id = Type.generate_auto_demangled_type_id(name)
+		return NamedTypeReference(type_class, type_id, name)
 
 
 class StructureMember(object):
@@ -348,18 +594,15 @@ class Structure(object):
 	def __del__(self):
 		core.BNFreeStructure(self.handle)
 
-	@property
-	def name(self):
-		count = ctypes.c_ulonglong()
-		nameList = core.BNGetStructureName(self.handle, count)
-		result = []
-		for i in xrange(count.value):
-			result.append(nameList[i])
-		return demangle.get_qualified_name(result)
+	def __eq__(self, value):
+		if not isinstance(value, Structure):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
 
-	@name.setter
-	def name(self, value):
-		core.BNSetStructureName(self.handle, value)
+	def __ne__(self, value):
+		if not isinstance(value, Structure):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
 	def members(self):
@@ -375,14 +618,22 @@ class Structure(object):
 
 	@property
 	def width(self):
-		"""Structure width (read-only)"""
+		"""Structure width"""
 		return core.BNGetStructureWidth(self.handle)
 
+	@width.setter
+	def width(self, new_width):
+		core.BNSetStructureWidth(self.handle, new_width)
+
 	@property
 	def alignment(self):
-		"""Structure alignment (read-only)"""
+		"""Structure alignment"""
 		return core.BNGetStructureAlignment(self.handle)
 
+	@alignment.setter
+	def alignment(self, align):
+		core.BNSetStructureAlignment(self.handle, align)
+
 	@property
 	def packed(self):
 		return core.BNIsStructurePacked(self.handle)
@@ -395,9 +646,13 @@ class Structure(object):
 	def union(self):
 		return core.BNIsStructureUnion(self.handle)
 
-	@union.setter
-	def union(self, value):
-		core.BNSetStructureUnion(self.handle, value)
+	@property
+	def type(self):
+		return StructureType(core.BNGetStructureType(self.handle))
+
+	@type.setter
+	def type(self, value):
+		core.BNSetStructureType(self.handle, value)
 
 	def __setattr__(self, name, value):
 		try:
@@ -406,8 +661,6 @@ class Structure(object):
 			raise AttributeError("attribute '%s' is read only" % name)
 
 	def __repr__(self):
-		if len(self.name) > 0:
-			return "<struct: %s>" % self.name
 		return "<struct: size %#x>" % self.width
 
 	def append(self, t, name = ""):
@@ -419,6 +672,9 @@ class Structure(object):
 	def remove(self, i):
 		core.BNRemoveStructureMember(self.handle, i)
 
+	def replace(self, i, t, name = ""):
+		core.BNReplaceStructureMember(self.handle, i, t.handle, name)
+
 
 class EnumerationMember(object):
 	def __init__(self, name, value, default):
@@ -440,13 +696,15 @@ class Enumeration(object):
 	def __del__(self):
 		core.BNFreeEnumeration(self.handle)
 
-	@property
-	def name(self):
-		return core.BNGetEnumerationName(self.handle)
+	def __eq__(self, value):
+		if not isinstance(value, Enumeration):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
 
-	@name.setter
-	def name(self, value):
-		core.BNSetEnumerationName(self.handle, value)
+	def __ne__(self, value):
+		if not isinstance(value, Enumeration):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
 	def members(self):
@@ -466,8 +724,6 @@ class Enumeration(object):
 			raise AttributeError("attribute '%s' is read only" % name)
 
 	def __repr__(self):
-		if len(self.name) > 0:
-			return "<enum: %s>" % self.name
 		return "<enum: %s>" % repr(self.members)
 
 	def append(self, name, value = None):
@@ -476,6 +732,12 @@ class Enumeration(object):
 		else:
 			core.BNAddEnumerationMemberWithValue(self.handle, name, value)
 
+	def remove(self, i):
+		core.BNRemoveEnumerationMember(self.handle, i)
+
+	def replace(self, i, name, value):
+		core.BNReplaceEnumerationMember(self.handle, i, name, value)
+
 
 class TypeParserResult(object):
 	def __init__(self, types, variables, functions):
diff --git a/python/undoaction.py b/python/undoaction.py
index 9f742e00..7e3c76a0 100644
--- a/python/undoaction.py
+++ b/python/undoaction.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
diff --git a/python/update.py b/python/update.py
index 6417e4a0..be6962d7 100644
--- a/python/update.py
+++ b/python/update.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2016 Vector 35 LLC
+# Copyright (c) 2015-2017 Vector 35 LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to