diff --git a/common/__init__.py b/common/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/common/channel.py b/common/channel.py
new file mode 100644
index 0000000..45e014d
--- /dev/null
+++ b/common/channel.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+'''
+KLL Channel Containers
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Channel:
+	'''
+	Pixel Channel Container
+	'''
+	def __init__( self, uid, width ):
+		self.uid = uid
+		self.width = width
+
+	def __repr__( self ):
+		return "{0}:{1}".format( self.uid, self.width )
+
+
+class ChannelList:
+	'''
+	Pixel Channel List Container
+	'''
+	def __init__( self ):
+		self.channels = []
+
+	def setChannels( self, channel_list ):
+		'''
+		Apply channels to Pixel
+		'''
+		for channel in channel_list:
+			self.channels.append( Channel( channel[0], channel[1] ) )
+
+	def strChannels( self ):
+		'''
+		__repr__ of Channel when multiple inheritance is used
+		'''
+		output = ""
+		for index, channel in enumerate( self.channels ):
+			if index > 0:
+				output += ","
+			output += "{0}".format( channel )
+
+		return output
+
+	def __repr__( self ):
+		return self.strChannels()
+
diff --git a/common/context.py b/common/context.py
new file mode 100644
index 0000000..f86dbc1
--- /dev/null
+++ b/common/context.py
@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+'''
+KLL Context Definitions
+* Generic (auto-detected)
+* Configuration
+* BaseMap
+* DefaultMap
+* PartialMap
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import copy
+import os
+
+import common.organization as organization
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Context:
+	'''
+	Base KLL Context Class
+	'''
+	def __init__( self ):
+		'''
+		Context initialization
+		'''
+		# Each context may have one or more included kll files
+		# And each of these files will have at least 1 Context
+		self.kll_files = []
+
+		# File data assigned to each context
+		# This info is populated during the PreprocessorStage
+		self.lines = []
+		self.data = ""
+		self.parent = None
+
+		# Tokenized data sets
+		self.classification_token_data = []
+		self.expressions = []
+
+		# Organized Expression Datastructure
+		self.organization = organization.Organization()
+
+	def __repr__( self ):
+		# Build list of all the info
+		return "(kll_files={0}, lines={1}, data='''{2}''')".format(
+			self.kll_files,
+			self.lines,
+			self.data,
+		)
+
+	def initial_context( self, lines, data, parent ):
+		'''
+		Used in the PreprocessorStage to update the initial line and kll file data
+
+		@param lines:  Data split per line
+		@param data:   Entire context in a single string
+		@param parent: Parent node, always a KLLFile
+		'''
+		self.lines = lines
+		self.data = data
+		self.parent = parent
+
+	def query( self, kll_expression, kll_type ):
+		'''
+		Query
+
+		Returns a dictionary of the specified property.
+		Most queries should use this.
+
+		See organization.py:Organization for property_type details.
+
+		@param kll_expression: String name of expression type
+		@param kll_type: String name of the expression sub-type
+
+		@return: context_name: (dictionary)
+		'''
+		return self.organization.data_mapping[ kll_expression ][ kll_type ]
+
+
+class GenericContext( Context ):
+	'''
+	Generic KLL Context Class
+	'''
+
+
+class ConfigurationContext( Context ):
+	'''
+	Configuration KLL Context Class
+	'''
+
+
+class BaseMapContext( Context ):
+	'''
+	Base Map KLL Context Class
+	'''
+
+
+class DefaultMapContext( Context ):
+	'''
+	Default Map KLL Context Class
+	'''
+
+
+class PartialMapContext( Context ):
+	'''
+	Partial Map KLL Context Class
+	'''
+	def __init__( self, layer ):
+		'''
+		Partial Map Layer Context Initialization
+
+		@param: Layer associated with Partial Map
+		'''
+		super().__init__()
+
+		self.layer = layer
+
+
+class MergeContext( Context ):
+	'''
+	Container class for a merged Context
+
+	Has references to the original contexts merged in
+	'''
+	def __init__( self, base_context ):
+		'''
+		Initialize the MergeContext with the base context
+		Another MergeContext can be used as the base_context
+
+		@param base_context: Context used to seed the MergeContext
+		'''
+		super().__init__()
+
+		# List of context, in the order of merging, starting from the base
+		self.contexts = [ base_context ]
+
+		# Copy the base context Organization into the MergeContext
+		self.organization = copy.copy( base_context.organization )
+
+		# Set the layer if the base is a PartialMapContext
+		if base_context.__class__.__name__ == 'PartialMapContext':
+			self.layer = base_context.layer
+
+	def merge( self, merge_in, debug ):
+		'''
+		Merge in context
+
+		Another MergeContext can be merged into a MergeContext
+
+		@param merge_in: Context to merge in to this one
+		@param debug:    Enable debug out
+		'''
+		# Append to context list
+		self.contexts.append( merge_in )
+
+		# Merge context
+		self.organization.merge(
+			merge_in.organization,
+			debug
+		)
+
+		# Set the layer if the base is a PartialMapContext
+		if merge_in.__class__.__name__ == 'PartialMapContext':
+			self.layer = merge_in.layer
+
+	def reduction( self ):
+		'''
+		Simplifies datastructure
+
+		NOTE: This will remove data, therefore, context is lost
+		'''
+		self.organization.reduction()
+
+	def paths( self ):
+		'''
+		Returns list of file paths used to generate this context
+		'''
+		file_paths = []
+
+		for kll_context in self.contexts:
+			# If context is a MergeContext then we have to recursively search
+			if kll_context.__class__.__name__ is 'MergeContext':
+				file_paths.extend( kll_context.paths() )
+			else:
+				file_paths.append( kll_context.parent.path )
+
+		return file_paths
+
+	def files( self ):
+		'''
+		Short form list of file paths used to generate this context
+		'''
+		file_paths = []
+		for file_path in self.paths():
+			file_paths.append( os.path.basename( file_path ) )
+
+		return file_paths
+
+	def __repr__( self ):
+		return "(kll_files={0}, organization={1})".format(
+			self.files(),
+			self.organization,
+		)
+
+	def query_contexts( self, kll_expression, kll_type ):
+		'''
+		Context Query
+
+		Returns a list of tuples (dictionary, kll_context) doing a deep search to the context leaf nodes.
+		This results in pre-merge data and is useful for querying information about files used during compilation.
+
+		See organization.py:Organization for property_type details.
+
+		@param kll_expression: String name of expression type
+		@param kll_type: String name of the expression sub-type
+
+		@return: context_name: (dictionary, kll_context)
+		'''
+		# Build list of leaf contexts
+		leaf_contexts = []
+		for kll_context in self.contexts:
+			# Recursively search if necessary
+			if kll_context.__class__.__name__ == 'MergeContext':
+				leaf_contexts.extend( kll_context.query_contexts( kll_expression, kll_type ) )
+			else:
+				leaf_contexts.append( ( kll_context.query( kll_expression, kll_type ), kll_context ) )
+
+		return leaf_contexts
+
diff --git a/common/emitter.py b/common/emitter.py
new file mode 100644
index 0000000..37bfcf4
--- /dev/null
+++ b/common/emitter.py
@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+'''
+KLL Emitter Base Classes
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import re
+import os
+import sys
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Emitter:
+	'''
+	KLL Emitter Base Class
+
+	NOTE: Emitter should do as little as possible in the __init__ function.
+	'''
+	def __init__( self, control ):
+		'''
+		Emitter initialization
+
+		@param control: ControlStage object, used to access data from other stages
+		'''
+		self.control = control
+		self.color = False
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.command_line_args.__name__,
+				type( self ).__name__
+			)
+		)
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.command_line_flags.__name__,
+				type( self ).__name__
+			)
+		)
+
+	def process( self ):
+		'''
+		Emitter Processing
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.process.__name__,
+				type( self ).__name__
+			)
+		)
+
+	def output( self ):
+		'''
+		Final Stage of Emitter
+
+		Generate desired outputs
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.output.__name__,
+				type( self ).__name__
+			)
+		)
+
+
+class TextEmitter:
+	'''
+	KLL Text Emitter Class
+
+	Base class for any text emitter that wants to use the templating functionality
+
+	If multiple files need to be generated, call load_template and generate multiple times.
+	e.g.
+	load_template('_myfile.h')
+	generate('/tmp/myfile.h')
+
+	load_template('_myfile2.h')
+	generate('/tmp/myfile2.h')
+
+	TODO
+	- Generate list of unused tags
+	'''
+	def __init__( self ):
+		'''
+		TextEmitter Initialization
+		'''
+		# Dictionary used to do template replacements
+		self.fill_dict = {}
+		self.tag_list = []
+
+		self.template = None
+
+	def load_template( self, template ):
+		'''
+		Loads template file
+
+		Looks for <|tags|> to replace in the template
+
+		@param template: Path to template
+		'''
+
+		# Does template exist?
+		if not os.path.isfile( template ):
+			print ( "{0} '{1}' does not exist...".format( ERROR, template ) )
+			sys.exit( 1 )
+
+		self.template = template
+
+		# Generate list of fill tags
+		with open( template, 'r' ) as openFile:
+			for line in openFile:
+				match = re.findall( r'<\|([^|>]+)\|>', line )
+				for item in match:
+					self.tag_list.append( item )
+
+	def generate( self, output_path ):
+		'''
+		Generates the output file from the template file
+
+		@param output_path: Path to the generated file
+		'''
+		# Make sure we've called load_template at least once
+		if self.template is None:
+			print ( "{0} TextEmitter template (load_template) has not been called.".format( ERROR ) )
+			sys.exit( 1 )
+
+		# Process each line of the template, outputting to the target path
+		with open( output_path, 'w' ) as outputFile:
+			with open( self.template, 'r' ) as templateFile:
+				for line in templateFile:
+					# TODO Support multiple replacements per line
+					# TODO Support replacement with other text inline
+					match = re.findall( r'<\|([^|>]+)\|>', line )
+
+					# If match, replace with processed variable
+					if match:
+						try:
+							outputFile.write( self.fill_dict[ match[0] ] )
+						except KeyError as err:
+							print( "{0} '{1}' not found, skipping...".format(
+								WARNING, match[0]
+							) )
+						outputFile.write("\n")
+
+					# Otherwise, just append template to output file
+					else:
+						outputFile.write( line )
+
diff --git a/common/expression.py b/common/expression.py
new file mode 100644
index 0000000..02da8e8
--- /dev/null
+++ b/common/expression.py
@@ -0,0 +1,630 @@
+#!/usr/bin/env python3
+'''
+KLL Expression Container
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import copy
+
+from common.id import CapId
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Expression:
+	'''
+	Container class for KLL expressions
+	'''
+	def __init__( self, lparam, operator, rparam, context ):
+		'''
+		Initialize expression container
+
+		@param lparam:   LOperatorData token
+		@param operator: Operator token
+		@param rparam:   ROperatorData token
+		@param context:  Parent context of expression
+		'''
+		# First stage/init
+		self.lparam_token = lparam
+		self.operator_token = operator
+		self.rparam_token = rparam
+		self.context = context # TODO, set multiple contexts for later stages
+
+		# Second stage
+		self.lparam_sub_tokens = []
+		self.rparam_sub_tokens = []
+
+		# Mutate class into the desired type
+		self.__class__ = {
+			'=>' : NameAssociationExpression,
+			'<=' : DataAssociationExpression,
+			'='  : AssignmentExpression,
+			':'  : MapExpression,
+		}[ self.operator_type() ]
+
+	def operator_type( self ):
+		'''
+		Determine which base operator this operator is of
+
+		All : (map) expressions are tokenized/parsed the same way
+
+		@return Base string representation of the operator
+		'''
+		if ':' in self.operator_token.value:
+			return ':'
+
+		return self.operator_token.value
+
+
+	def final_tokens( self, no_filter=False ):
+		'''
+		Return the final list of tokens, must complete the second stage first
+
+		@param no_filter: If true, do not filter out Space tokens
+
+		@return Finalized list of tokens
+		'''
+		ret = self.lparam_sub_tokens + [ self.operator_token ] + self.rparam_sub_tokens
+
+		if not no_filter:
+			ret = [ x for x in ret if x.type != 'Space' ]
+		return ret
+
+	def regen_str( self ):
+		'''
+		Re-construct the string based off the original set of tokens
+
+		<lparam><operator><rparam>;
+		'''
+		return "{0}{1}{2};".format(
+			self.lparam_token.value,
+			self.operator_token.value,
+			self.rparam_token.value,
+		)
+
+	def point_chars( self, pos_list ):
+		'''
+		Using the regenerated string, point to a given list of characters
+		Used to indicate where a possible issue/syntax error is
+
+		@param pos_list: List of character indices
+
+		i.e.
+		> U"A" : : U"1";
+		>        ^
+		'''
+		out = "\t{0}\n\t".format( self.regen_str() )
+
+		# Place a ^ character at the given locations
+		curpos = 1
+		for pos in sorted( pos_list ):
+			# Pad spaces, then add a ^
+			out += ' ' * (pos - curpos)
+			out += '^'
+			curpos += pos
+
+		return out
+
+	def rparam_start( self ):
+		'''
+		Starting positing char of rparam_token in a regen_str
+		'''
+		return len( self.lparam_token.value ) + len( self.operator_token.value )
+
+	def __repr__( self ):
+		# Build string representation based off of what has been set
+		# lparam, operator and rparam are always set
+		out = "Expression: {0}{1}{2}".format(
+			self.lparam_token.value,
+			self.operator_token.value,
+			self.rparam_token.value,
+		)
+
+		# TODO - Add more depending on what has been set
+		return out
+
+	def unique_keys( self ):
+		'''
+		Generates a list of unique identifiers for the expression that is mergeable
+		with other functional equivalent expressions.
+
+		This method should never get called directly as a generic Expression
+		'''
+		return [ ('UNKNOWN KEY', 'UNKNOWN EXPRESSION') ]
+
+
+class AssignmentExpression( Expression ):
+	'''
+	Container class for assignment KLL expressions
+	'''
+	type = None
+	name = None
+	pos = None
+	value = None
+
+	## Setters ##
+	def array( self, name, pos, value ):
+		'''
+		Assign array assignment parameters to expression
+
+		@param name:  Name of variable
+		@param pos:   Array position of the value (if None, overwrite the entire array)
+		@param value: Value of the array, if pos is specified, this is the value of an element
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Array'
+		self.name = name
+		self.pos = pos
+		self.value = value
+
+		# If pos is not none, flatten
+		if pos is not None:
+			self.value = "".join( str( x ) for x in self.value )
+
+		return True
+
+	def variable( self, name, value ):
+		'''
+		Assign variable assignment parameters to expression
+
+		@param name: Name of variable
+		@param value: Value of variable
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Variable'
+		self.name = name
+		self.value = value
+
+		# Flatten value, often a list of various token types
+		self.value = "".join( str( x ) for x in self.value )
+
+		return True
+
+	def __repr__( self ):
+		if self.type == 'Variable':
+			return "{0} = {1};".format( self.name, self.value )
+		elif self.type == 'Array':
+			return "{0}[{1}] = {2};".format( self.name, self.pos, self.value )
+
+		return "ASSIGNMENT UNKNOWN"
+
+	def unique_keys( self ):
+		'''
+		Generates a list of unique identifiers for the expression that is mergeable
+		with other functional equivalent expressions.
+		'''
+		return [ ( self.name, self ) ]
+
+
+class NameAssociationExpression( Expression ):
+	'''
+	Container class for name association KLL expressions
+	'''
+	type = None
+	name = None
+	association = None
+
+	## Setters ##
+	def capability( self, name, association, parameters ):
+		'''
+		Assign a capability C function name association
+
+		@param name: Name of capability
+		@param association: Name of capability in target backend output
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Capability'
+		self.name = name
+		self.association = CapId( association, 'Definition', parameters )
+
+		return True
+
+	def define( self, name, association ):
+		'''
+		Assign a define C define name association
+
+		@param name: Name of variable
+		@param association: Name of association in target backend output
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Define'
+		self.name = name
+		self.association = association
+
+		return True
+
+	def __repr__( self ):
+		return "{0} <= {1};".format( self.name, self.association )
+
+	def unique_keys( self ):
+		'''
+		Generates a list of unique identifiers for the expression that is mergeable
+		with other functional equivalent expressions.
+		'''
+		return [ ( self.name, self ) ]
+
+
+class DataAssociationExpression( Expression ):
+	'''
+	Container class for data association KLL expressions
+	'''
+	type = None
+	association = None
+	value = None
+
+	## Setters ##
+	def animation( self, animations, animation_modifiers ):
+		'''
+		Animation definition and configuration
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Animation'
+		self.association = animations
+		self.value = animation_modifiers
+
+		return True
+
+	def animationFrame( self, animation_frames, pixel_modifiers ):
+		'''
+		Pixel composition of an Animation Frame
+
+		@return: True if parsing was successful
+		'''
+
+		self.type = 'AnimationFrame'
+		self.association = animation_frames
+		self.value = pixel_modifiers
+
+		return True
+
+	def pixelPosition( self, pixels, position ):
+		'''
+		Pixel Positioning
+
+		@return: True if parsing was successful
+		'''
+		for pixel in pixels:
+			pixel.setPosition( position )
+
+		self.type = 'PixelPosition'
+		self.association = pixels
+
+		return True
+
+	def scanCodePosition( self, scancodes, position ):
+		'''
+		Scan Code to Position Mapping
+
+		Note: Accepts lists of scan codes
+		Alone this isn't useful, but you can assign rows and columns using ranges instead of individually
+
+		@return: True if parsing was successful
+		'''
+		for scancode in scancodes:
+			scancode.setPosition( position )
+
+		self.type = 'ScanCodePosition'
+		self.association = scancodes
+
+		return True
+
+	def __repr__( self ):
+		if self.type in ['PixelPosition', 'ScanCodePosition']:
+			output = ""
+			for index, association in enumerate( self.association ):
+				if index > 0:
+					output += "; "
+				output += "{0}".format( association )
+			return "{0};".format( output )
+		return "{0} <= {1};".format( self.association, self.value )
+
+	def unique_keys( self ):
+		'''
+		Generates a list of unique identifiers for the expression that is mergeable
+		with other functional equivalent expressions.
+		'''
+		keys = []
+
+		# Positions require a bit more introspection to get the unique keys
+		if self.type in ['PixelPosition', 'ScanCodePosition']:
+			for index, key in enumerate( self.association ):
+				uniq_expr = self
+
+				# If there is more than one key, copy the expression
+				# and remove the non-related variants
+				if len( self.association ) > 1:
+					uniq_expr = copy.copy( self )
+
+					# Isolate variant by index
+					uniq_expr.association = [ uniq_expr.association[ index ] ]
+
+				keys.append( ( "{0}".format( key.unique_key() ), uniq_expr ) )
+
+		# AnimationFrames are already list of keys
+		# TODO Reorder frame assignments to dedup function equivalent mappings
+		elif self.type in ['AnimationFrame']:
+			for index, key in enumerate( self.association ):
+				uniq_expr = self
+
+				# If there is more than one key, copy the expression
+				# and remove the non-related variants
+				if len( self.association ) > 1:
+					uniq_expr = copy.copy( self )
+
+					# Isolate variant by index
+					uniq_expr.association = [ uniq_expr.association[ index ] ]
+
+				keys.append( ( "{0}".format( key ), uniq_expr ) )
+
+		# Otherwise treat as a single element
+		else:
+			keys = [ ( "{0}".format( self.association ), self ) ]
+
+		# Remove any duplicate keys
+		# TODO Stat? Might be at neat report about how many duplicates were squashed
+		keys = list( set( keys ) )
+
+		return keys
+
+
+class MapExpression( Expression ):
+	'''
+	Container class for KLL map expressions
+	'''
+	type = None
+	triggers = None
+	operator = None
+	results = None
+	animation = None
+	animation_frame = None
+	pixels = None
+	position = None
+
+	## Setters ##
+	def scanCode( self, triggers, operator, results ):
+		'''
+		Scan Code mapping
+
+		@param triggers: Sequence of combos of ranges of namedtuples
+		@param operator: Type of map operation
+		@param results: Sequence of combos of ranges of namedtuples
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'ScanCode'
+		self.triggers = triggers
+		self.operator = operator
+		self.results = results
+
+		return True
+
+	def usbCode( self, triggers, operator, results ):
+		'''
+		USB Code mapping
+
+		@param triggers: Sequence of combos of ranges of namedtuples
+		@param operator: Type of map operation
+		@param results: Sequence of combos of ranges of namedtuples
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'USBCode'
+		self.triggers = triggers
+		self.operator = operator
+		self.results = results
+
+		return True
+
+	def animationTrigger( self, animation, operator, results ):
+		'''
+		Animation Trigger mapping
+
+		@param animation: Animation trigger of result
+		@param operator: Type of map operation
+		@param results: Sequence of combos of ranges of namedtuples
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'Animation'
+		self.animation = animation
+		self.triggers = animation
+		self.operator = operator
+		self.results = results
+
+		return True
+
+	def pixelChannels( self, pixelmap, trigger ):
+		'''
+		Pixel Channel Composition
+
+		@return: True if parsing was successful
+		'''
+		self.type = 'PixelChannel'
+		self.pixel = pixelmap
+		self.position = trigger
+
+		return True
+
+	def sequencesOfCombosOfIds( self, expression_param ):
+		'''
+		Prettified Sequence of Combos of Identifiers
+
+		@param expression_param: Trigger or Result parameter of an expression
+
+		Scan Code Example
+		[[[S10, S16], [S42]], [[S11, S16], [S42]]] -> (S10 + S16, S42)|(S11 + S16, S42)
+		'''
+		output = ""
+
+		# Sometimes during error cases, might be None
+		if expression_param is None:
+			return output
+
+		# Iterate over each trigger/result variants (expanded from ranges), each one is a sequence
+		for index, sequence in enumerate( expression_param ):
+			if index > 0:
+				output += "|"
+			output += "("
+
+			# Iterate over each combo (element of the sequence)
+			for index, combo in enumerate( sequence ):
+				if index > 0:
+					output += ", "
+
+				# Iterate over each trigger identifier
+				for index, identifier in enumerate( combo ):
+					if index > 0:
+						output += " + "
+					output += "{0}".format( identifier )
+
+			output += ")"
+
+		return output
+
+	def elems( self ):
+		'''
+		Return number of trigger and result elements
+
+		Useful for determining if this is a trigger macro (2+)
+		Should always return at least (1,1) unless it's an invalid calculation
+
+		@return: ( triggers, results )
+		'''
+		elems = [ 0, 0 ]
+
+		# XXX Needed?
+		if self.type == 'PixelChannel':
+			return tuple( elems )
+
+		# Iterate over each trigger variant (expanded from ranges), each one is a sequence
+		for sequence in self.triggers:
+			# Iterate over each combo (element of the sequence)
+			for combo in sequence:
+				# Just measure the size of the combo
+				elems[0] += len( combo )
+
+		# Iterate over each result variant (expanded from ranges), each one is a sequence
+		for sequence in self.results:
+			# Iterate over each combo (element of the sequence)
+			for combo in sequence:
+				# Just measure the size of the combo
+				elems[1] += len( combo )
+
+		return tuple( elems )
+
+	def trigger_str( self ):
+		'''
+		String version of the trigger
+		Used for sorting
+		'''
+		# Pixel Channel Mapping doesn't follow the same pattern
+		if self.type == 'PixelChannel':
+			return "{0}".format( self.pixel )
+
+		return "{0}".format(
+			self.sequencesOfCombosOfIds( self.triggers ),
+		)
+
+	def result_str( self ):
+		'''
+		String version of the result
+		Used for sorting
+		'''
+		# Pixel Channel Mapping doesn't follow the same pattern
+		if self.type == 'PixelChannel':
+			return "{0}".format( self.position )
+
+		return "{0}".format(
+			self.sequencesOfCombosOfIds( self.results ),
+		)
+
+	def __repr__( self ):
+		# Pixel Channel Mapping doesn't follow the same pattern
+		if self.type == 'PixelChannel':
+			return "{0} : {1};".format( self.pixel, self.position )
+
+		return "{0} {1} {2};".format(
+			self.sequencesOfCombosOfIds( self.triggers ),
+			self.operator,
+			self.sequencesOfCombosOfIds( self.results ),
+		)
+
+	def unique_keys( self ):
+		'''
+		Generates a list of unique identifiers for the expression that is mergeable
+		with other functional equivalent expressions.
+
+		TODO: This function should re-order combinations to generate the key.
+		The final generated combo will be in the original order.
+		'''
+		keys = []
+
+		# Pixel Channel only has key per mapping
+		if self.type == 'PixelChannel':
+			keys = [ ( "{0}".format( self.pixel ), self ) ]
+
+		# Split up each of the keys
+		else:
+			# Iterate over each trigger/result variants (expanded from ranges), each one is a sequence
+			for index, sequence in enumerate( self.triggers ):
+				key = ""
+				uniq_expr = self
+
+				# If there is more than one key, copy the expression
+				# and remove the non-related variants
+				if len( self.triggers ) > 1:
+					uniq_expr = copy.copy( self )
+
+					# Isolate variant by index
+					uniq_expr.triggers = [ uniq_expr.triggers[ index ] ]
+
+				# Iterate over each combo (element of the sequence)
+				for index, combo in enumerate( sequence ):
+					if index > 0:
+						key += ", "
+
+					# Iterate over each trigger identifier
+					for index, identifier in enumerate( combo ):
+						if index > 0:
+							key += " + "
+						key += "{0}".format( identifier )
+
+				# Add key to list
+				keys.append( ( key, uniq_expr ) )
+
+		# Remove any duplicate keys
+		# TODO Stat? Might be at neat report about how many duplicates were squashed
+		keys = list( set( keys ) )
+
+		return keys
+
diff --git a/common/file.py b/common/file.py
new file mode 100644
index 0000000..8450f90
--- /dev/null
+++ b/common/file.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+'''
+KLL File Container
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import os
+
+import common.context as context
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class KLLFile:
+	'''
+	Container class for imported KLL files
+	'''
+	def __init__( self, path, file_context ):
+		'''
+		Initialize file container
+
+		@param path:    Path to filename, if relative, relative to the execution environment
+		@param context: KLL Context object
+		'''
+		self.path = path
+		self.context = file_context
+		self.lines = []
+		self.data = ""
+
+	def __repr__( self ):
+		context_str = type( self.context ).__name__
+
+		# Show layer info if this is a PartialMap
+		if isinstance( self.context, context.PartialMapContext ):
+			context_str = "{0}({1})".format( context_str, self.context.layer )
+
+		return "({0}, {1})".format( self.path, context_str )
+
+	def check( self ):
+		'''
+		Make sure that the file exists at the initialized path
+		'''
+		exists = os.path.isfile( self.path )
+
+		# Display error message, will exit later
+		if not exists:
+			print( "{0} {1} does not exist...".format( ERROR, self.path ) )
+
+		return exists
+
+	def read( self ):
+		'''
+		Read the contents of the file path into memory
+		Reads both per line and complete copies
+		'''
+		try:
+			# Read file into memory, removing newlines
+			with open( self.path ) as f:
+				self.data  = f.read()
+				self.lines = self.data.splitlines()
+
+		except:
+			print( "{0} Failed to read '{1}' into memory...".format( ERROR, self.path ) )
+			return False
+
+		return True
+
+
+
diff --git a/common/hid_dict.py b/common/hid_dict.py
new file mode 100644
index 0000000..d9e5b7f
--- /dev/null
+++ b/common/hid_dict.py
@@ -0,0 +1,1583 @@
+#!/usr/bin/env python3
+'''
+KLL Compiler - HID Dictionary Lookup
+
+USB Code Lookup Dictionary
+'''
+
+# Copyright (C) 2014-2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+# Rather than generating tables of hex USB codes for the keymapping tables,
+#  readable defines are used (which correspond to usb_hid.h)
+hid_lookup_dictionary = dict([
+	# Fall-through block
+	( ('NONE', 0), '' ), # Special case, there are no arguments
+
+	# USB HID Keyboard Codes
+	( ('USB', 0x00), 'KEY_NOEVENT' ), # Event, not a physical key
+	( ('USB', 0x01), 'KEY_ERRORROLLOVER' ), # Event, not a physical key
+	( ('USB', 0x02), 'KEY_POSTFAIL' ), # Event, not a physical key
+	( ('USB', 0x03), 'KEY_ERRORUNDEFINED' ), # Event, not a physical key
+	( ('USB', 0x04), 'KEY_A' ),
+	( ('USB', 0x05), 'KEY_B' ),
+	( ('USB', 0x06), 'KEY_C' ),
+	( ('USB', 0x07), 'KEY_D' ),
+	( ('USB', 0x08), 'KEY_E' ),
+	( ('USB', 0x09), 'KEY_F' ),
+	( ('USB', 0x0A), 'KEY_G' ),
+	( ('USB', 0x0B), 'KEY_H' ),
+	( ('USB', 0x0C), 'KEY_I' ),
+	( ('USB', 0x0D), 'KEY_J' ),
+	( ('USB', 0x0E), 'KEY_K' ),
+	( ('USB', 0x0F), 'KEY_L' ),
+	( ('USB', 0x10), 'KEY_M' ),
+	( ('USB', 0x11), 'KEY_N' ),
+	( ('USB', 0x12), 'KEY_O' ),
+	( ('USB', 0x13), 'KEY_P' ),
+	( ('USB', 0x14), 'KEY_Q' ),
+	( ('USB', 0x15), 'KEY_R' ),
+	( ('USB', 0x16), 'KEY_S' ),
+	( ('USB', 0x17), 'KEY_T' ),
+	( ('USB', 0x18), 'KEY_U' ),
+	( ('USB', 0x19), 'KEY_V' ),
+	( ('USB', 0x1A), 'KEY_W' ),
+	( ('USB', 0x1B), 'KEY_X' ),
+	( ('USB', 0x1C), 'KEY_Y' ),
+	( ('USB', 0x1D), 'KEY_Z' ),
+	( ('USB', 0x1E), 'KEY_1' ),
+	( ('USB', 0x1F), 'KEY_2' ),
+	( ('USB', 0x20), 'KEY_3' ),
+	( ('USB', 0x21), 'KEY_4' ),
+	( ('USB', 0x22), 'KEY_5' ),
+	( ('USB', 0x23), 'KEY_6' ),
+	( ('USB', 0x24), 'KEY_7' ),
+	( ('USB', 0x25), 'KEY_8' ),
+	( ('USB', 0x26), 'KEY_9' ),
+	( ('USB', 0x27), 'KEY_0' ),
+	( ('USB', 0x28), 'KEY_ENTER' ),
+	( ('USB', 0x29), 'KEY_ESC' ),
+	( ('USB', 0x2A), 'KEY_BACKSPACE' ),
+	( ('USB', 0x2B), 'KEY_TAB' ),
+	( ('USB', 0x2C), 'KEY_SPACE' ),
+	( ('USB', 0x2D), 'KEY_MINUS' ),
+	( ('USB', 0x2E), 'KEY_EQUAL' ),
+	( ('USB', 0x2F), 'KEY_LEFT_BRACKET' ),
+	( ('USB', 0x30), 'KEY_RIGHT_BRACKET' ),
+	( ('USB', 0x31), 'KEY_BACKSLASH' ),
+	( ('USB', 0x32), 'KEY_NUMBER' ),
+	( ('USB', 0x33), 'KEY_SEMICOLON' ),
+	( ('USB', 0x34), 'KEY_QUOTE' ),
+	( ('USB', 0x35), 'KEY_BACKTICK' ),
+	( ('USB', 0x36), 'KEY_COMMA' ),
+	( ('USB', 0x37), 'KEY_PERIOD' ),
+	( ('USB', 0x38), 'KEY_SLASH' ),
+	( ('USB', 0x39), 'KEY_CAPS_LOCK' ),
+	( ('USB', 0x3A), 'KEY_F1' ),
+	( ('USB', 0x3B), 'KEY_F2' ),
+	( ('USB', 0x3C), 'KEY_F3' ),
+	( ('USB', 0x3D), 'KEY_F4' ),
+	( ('USB', 0x3E), 'KEY_F5' ),
+	( ('USB', 0x3F), 'KEY_F6' ),
+	( ('USB', 0x40), 'KEY_F7' ),
+	( ('USB', 0x41), 'KEY_F8' ),
+	( ('USB', 0x42), 'KEY_F9' ),
+	( ('USB', 0x43), 'KEY_F10' ),
+	( ('USB', 0x44), 'KEY_F11' ),
+	( ('USB', 0x45), 'KEY_F12' ),
+	( ('USB', 0x46), 'KEY_PRINTSCREEN' ),
+	( ('USB', 0x47), 'KEY_SCROLL_LOCK' ),
+	( ('USB', 0x48), 'KEY_PAUSE' ),
+	( ('USB', 0x49), 'KEY_INSERT' ),
+	( ('USB', 0x4A), 'KEY_HOME' ),
+	( ('USB', 0x4B), 'KEY_PAGE_UP' ),
+	( ('USB', 0x4C), 'KEY_DELETE' ),
+	( ('USB', 0x4D), 'KEY_END' ),
+	( ('USB', 0x4E), 'KEY_PAGE_DOWN' ),
+	( ('USB', 0x4F), 'KEY_RIGHT' ),
+	( ('USB', 0x50), 'KEY_LEFT' ),
+	( ('USB', 0x51), 'KEY_DOWN' ),
+	( ('USB', 0x52), 'KEY_UP' ),
+	( ('USB', 0x53), 'KEY_NUM_LOCK' ),
+	( ('USB', 0x54), 'KEYPAD_SLASH' ),
+	( ('USB', 0x55), 'KEYPAD_ASTERISK' ),
+	( ('USB', 0x56), 'KEYPAD_MINUS' ),
+	( ('USB', 0x57), 'KEYPAD_PLUS' ),
+	( ('USB', 0x58), 'KEYPAD_ENTER' ),
+	( ('USB', 0x59), 'KEYPAD_1' ),
+	( ('USB', 0x5A), 'KEYPAD_2' ),
+	( ('USB', 0x5B), 'KEYPAD_3' ),
+	( ('USB', 0x5C), 'KEYPAD_4' ),
+	( ('USB', 0x5D), 'KEYPAD_5' ),
+	( ('USB', 0x5E), 'KEYPAD_6' ),
+	( ('USB', 0x5F), 'KEYPAD_7' ),
+	( ('USB', 0x60), 'KEYPAD_8' ),
+	( ('USB', 0x61), 'KEYPAD_9' ),
+	( ('USB', 0x62), 'KEYPAD_0' ),
+	( ('USB', 0x63), 'KEYPAD_PERIOD' ),
+	( ('USB', 0x64), 'KEY_ISO_SLASH' ),
+	( ('USB', 0x65), 'KEY_APP' ),
+	( ('USB', 0x66), 'KEYBOARD_STATUS' ), # Used for indicating status or errors, not a key
+	( ('USB', 0x67), 'KEYPAD_EQUAL' ),
+	( ('USB', 0x68), 'KEY_F13' ),
+	( ('USB', 0x69), 'KEY_F14' ),
+	( ('USB', 0x6A), 'KEY_F15' ),
+	( ('USB', 0x6B), 'KEY_F16' ),
+	( ('USB', 0x6C), 'KEY_F17' ),
+	( ('USB', 0x6D), 'KEY_F18' ),
+	( ('USB', 0x6E), 'KEY_F19' ),
+	( ('USB', 0x6F), 'KEY_F20' ),
+	( ('USB', 0x70), 'KEY_F21' ),
+	( ('USB', 0x71), 'KEY_F22' ),
+	( ('USB', 0x72), 'KEY_F23' ),
+	( ('USB', 0x73), 'KEY_F24' ),
+	( ('USB', 0x74), 'KEY_EXEC' ),
+	( ('USB', 0x75), 'KEY_HELP' ),
+	( ('USB', 0x76), 'KEY_MENU' ),
+	( ('USB', 0x77), 'KEY_SELECT' ),
+	( ('USB', 0x78), 'KEY_STOP' ),
+	( ('USB', 0x79), 'KEY_AGAIN' ),
+	( ('USB', 0x7A), 'KEY_UNDO' ),
+	( ('USB', 0x7B), 'KEY_CUT' ),
+	( ('USB', 0x7C), 'KEY_COPY' ),
+	( ('USB', 0x7D), 'KEY_PASTE' ),
+	( ('USB', 0x7E), 'KEY_FIND' ),
+	( ('USB', 0x7F), 'KEY_MUTE' ),
+	( ('USB', 0x80), 'KEY_VOL_UP' ),
+	( ('USB', 0x81), 'KEY_VOL_DOWN' ),
+	( ('USB', 0x82), 'KEY_CAPS_TLOCK' ), # Toggle "Locking" Scroll Lock (Old keyboards with Locking Caps Lock)
+	( ('USB', 0x83), 'KEY_NUM_TLOCK' ),
+	( ('USB', 0x84), 'KEY_SCROLL_TLOCK' ),
+	( ('USB', 0x85), 'KEYPAD_COMMA' ), # Brazillian (See spec)
+	( ('USB', 0x86), 'KEYPAD_EQUAL_AS' ), # AS/400 Keyboard (See spec)
+	( ('USB', 0x87), 'KEY_INTER1' ), # KANJI1 - Brazillian and Japanese "Ru" and "-"
+	( ('USB', 0x88), 'KEY_INTER2' ), # KANJI2 - Japanese Katakana/Hiragana
+	( ('USB', 0x89), 'KEY_INTER3' ), # KANJI3 - Japanese Yen
+	( ('USB', 0x8A), 'KEY_INTER4' ), # KANJI4 - Japanese Henkan
+	( ('USB', 0x8B), 'KEY_INTER5' ), # KANJI5 - Japanese Muhenkan
+	( ('USB', 0x8C), 'KEY_INTER6' ), # KANJI6 - PC('USB', 0x62) Comma (Ka-m-ma)
+	( ('USB', 0x8D), 'KEY_INTER7' ), # KANJI7 - Double-Byte/Single-Byte Toggle
+	( ('USB', 0x8E), 'KEY_INTER8' ), # KANJI8 - Undefined
+	( ('USB', 0x8F), 'KEY_INTER9' ), # KANJI9 - Undefined
+	( ('USB', 0x90), 'KEY_LANG1' ), # Korean Hangul/English Toggle
+	( ('USB', 0x91), 'KEY_LANG2' ), # Korean Hanja Conversion - Japanese Eisu
+	( ('USB', 0x92), 'KEY_LANG3' ), # Japanese Katakana Key (USB)
+	( ('USB', 0x93), 'KEY_LANG4' ), # Japanese Hiragana Key (USB)
+	( ('USB', 0x94), 'KEY_LANG5' ), # Japanese Zenkaku/Hankaku Key (USB)
+	( ('USB', 0x95), 'KEY_LANG6' ), # Reserved (Application Specific)
+	( ('USB', 0x96), 'KEY_LANG7' ), # Reserved (Application Specific)
+	( ('USB', 0x97), 'KEY_LANG8' ), # Reserved (Application Specific)
+	( ('USB', 0x98), 'KEY_LANG9' ), # Reserved (Application Specific)
+	( ('USB', 0x99), 'KEY_ALT_ERASE' ), # Special Erase (See Spec)
+	( ('USB', 0x9A), 'KEY_SYSREQ_ATT' ), # Modifier Type
+	( ('USB', 0x9B), 'KEY_CANCEL' ),
+	( ('USB', 0x9C), 'KEY_CLEAR' ),
+	( ('USB', 0x9D), 'KEY_PRIOR' ),
+	( ('USB', 0x9E), 'KEY_RETURN' ),
+	( ('USB', 0x9F), 'KEY_SEPARATOR' ),
+	( ('USB', 0xA0), 'KEY_OUT' ),
+	( ('USB', 0xA1), 'KEY_OPER' ),
+	( ('USB', 0xA2), 'KEY_CLEAR_AGAIN' ),
+	( ('USB', 0xA3), 'KEY_CRSEL_PROPS' ),
+	( ('USB', 0xA4), 'KEY_EXSEL' ),
+# ('USB', 0xA5) - ('USB', 0xAF) Reserved
+	( ('USB', 0xB0), 'KEYPAD_00' ),
+	( ('USB', 0xB1), 'KEYPAD_000' ),
+	( ('USB', 0xB2), 'KEY_1000_SEP' ),
+	( ('USB', 0xB3), 'KEY_DECIMAL_SEP' ),
+	( ('USB', 0xB4), 'KEY_CURRENCY_MAIN' ),
+	( ('USB', 0xB5), 'KEY_CURRENCY_SUB' ),
+	( ('USB', 0xB6), 'KEYPAD_LPAREN' ),
+	( ('USB', 0xB7), 'KEYPAD_RPAREN' ),
+	( ('USB', 0xB8), 'KEYPAD_LBRACKET' ),
+	( ('USB', 0xB9), 'KEYPAD_RBRACKET' ),
+	( ('USB', 0xBA), 'KEYPAD_TAB' ),
+	( ('USB', 0xBB), 'KEYPAD_BACKSPACE' ),
+	( ('USB', 0xBC), 'KEYPAD_A' ),
+	( ('USB', 0xBD), 'KEYPAD_B' ),
+	( ('USB', 0xBE), 'KEYPAD_C' ),
+	( ('USB', 0xBF), 'KEYPAD_D' ),
+	( ('USB', 0xC0), 'KEYPAD_E' ),
+	( ('USB', 0xC1), 'KEYPAD_F' ),
+	( ('USB', 0xC2), 'KEYPAD_XOR' ),
+	( ('USB', 0xC3), 'KEYPAD_CHEVRON' ),
+	( ('USB', 0xC4), 'KEYPAD_PERCENT' ),
+	( ('USB', 0xC5), 'KEYPAD_LTHAN' ),
+	( ('USB', 0xC6), 'KEYPAD_GTHAN' ),
+	( ('USB', 0xC7), 'KEYPAD_BITAND' ),
+	( ('USB', 0xC8), 'KEYPAD_AND' ),
+	( ('USB', 0xC9), 'KEYPAD_BITOR' ),
+	( ('USB', 0xCA), 'KEYPAD_OR' ),
+	( ('USB', 0xCB), 'KEYPAD_COLON' ),
+	( ('USB', 0xCC), 'KEYPAD_POUND' ),
+	( ('USB', 0xCD), 'KEYPAD_SPACE' ),
+	( ('USB', 0xCE), 'KEYPAD_AT' ),
+	( ('USB', 0xCF), 'KEYPAD_EXCLAIM' ),
+	( ('USB', 0xD0), 'KEYPAD_MEM_STORE' ),
+	( ('USB', 0xD1), 'KEYPAD_MEM_RECALL' ),
+	( ('USB', 0xD2), 'KEYPAD_MEM_CLEAR' ),
+	( ('USB', 0xD3), 'KEYPAD_MEM_ADD' ),
+	( ('USB', 0xD4), 'KEYPAD_MEM_SUB' ),
+	( ('USB', 0xD5), 'KEYPAD_MEM_MULT' ),
+	( ('USB', 0xD6), 'KEYPAD_MEM_DIV' ),
+	( ('USB', 0xD7), 'KEYPAD_PLUS_MINUS' ),
+	( ('USB', 0xD8), 'KEYPAD_CLEAR' ),
+	( ('USB', 0xD9), 'KEYPAD_CLEAR_ENTRY' ),
+	( ('USB', 0xDA), 'KEYPAD_BINARY' ),
+	( ('USB', 0xDB), 'KEYPAD_OCTAL' ),
+	( ('USB', 0xDC), 'KEYPAD_DECIMAL' ),
+	( ('USB', 0xDD), 'KEYPAD_HEX' ),
+# ('USB', 0xDE) - ('USB', 0xDF) Reserved
+	( ('USB', 0xE0), 'KEY_LCTRL' ),
+	( ('USB', 0xE1), 'KEY_LSHIFT' ),
+	( ('USB', 0xE2), 'KEY_LALT' ),
+	( ('USB', 0xE3), 'KEY_LGUI' ),
+	( ('USB', 0xE4), 'KEY_RCTRL' ),
+	( ('USB', 0xE5), 'KEY_RSHIFT' ),
+	( ('USB', 0xE6), 'KEY_RALT' ),
+	( ('USB', 0xE7), 'KEY_RGUI' ),
+# ('USB', 0xE8) - ('USB', 0xFF)FF Reserved, using ('USB', 0xF0) to ('USB', 0xFF) for function key placeholders
+	( ('USB', 0xF0), 'KEY_FUN1' ),
+	( ('USB', 0xF1), 'KEY_FUN2' ),
+	( ('USB', 0xF2), 'KEY_FUN3' ),
+	( ('USB', 0xF3), 'KEY_FUN4' ),
+	( ('USB', 0xF4), 'KEY_FUN5' ),
+	( ('USB', 0xF5), 'KEY_FUN6' ),
+	( ('USB', 0xF6), 'KEY_FUN7' ),
+	( ('USB', 0xF7), 'KEY_FUN8' ),
+	( ('USB', 0xF8), 'KEY_FUN9' ),
+	( ('USB', 0xF9), 'KEY_FUN10' ),
+	( ('USB', 0xFA), 'KEY_FUN11' ),
+	( ('USB', 0xFB), 'KEY_FUN12' ),
+	( ('USB', 0xFC), 'KEY_FUN13' ),
+	( ('USB', 0xFD), 'KEY_FUN14' ),
+	( ('USB', 0xFE), 'KEY_FUN15' ),
+	( ('USB', 0xFF), 'KEY_FUN16' ),
+# ('USB', 0x100) to ('USB', 0x121) for function key placeholders, not valid usb codes (must use a translation .kll file before firmware compilation)
+	( ('USB', 0x100), 'KEY_LCK1' ),
+	( ('USB', 0x101), 'KEY_LCK2' ),
+	( ('USB', 0x102), 'KEY_LCK3' ),
+	( ('USB', 0x103), 'KEY_LCK4' ),
+	( ('USB', 0x104), 'KEY_LCK5' ),
+	( ('USB', 0x105), 'KEY_LCK6' ),
+	( ('USB', 0x106), 'KEY_LCK7' ),
+	( ('USB', 0x107), 'KEY_LCK8' ),
+	( ('USB', 0x108), 'KEY_LCK9' ),
+	( ('USB', 0x109), 'KEY_LCK10' ),
+	( ('USB', 0x10A), 'KEY_LCK11' ),
+	( ('USB', 0x10B), 'KEY_LCK12' ),
+	( ('USB', 0x10C), 'KEY_LCK13' ),
+	( ('USB', 0x10D), 'KEY_LCK14' ),
+	( ('USB', 0x10E), 'KEY_LCK15' ),
+	( ('USB', 0x10F), 'KEY_LCK16' ),
+	( ('USB', 0x110), 'KEY_LAT1' ),
+	( ('USB', 0x111), 'KEY_LAT2' ),
+	( ('USB', 0x112), 'KEY_LAT3' ),
+	( ('USB', 0x113), 'KEY_LAT4' ),
+	( ('USB', 0x114), 'KEY_LAT5' ),
+	( ('USB', 0x115), 'KEY_LAT6' ),
+	( ('USB', 0x116), 'KEY_LAT7' ),
+	( ('USB', 0x117), 'KEY_LAT8' ),
+	( ('USB', 0x118), 'KEY_LAT9' ),
+	( ('USB', 0x119), 'KEY_LAT10' ),
+	( ('USB', 0x11A), 'KEY_LAT11' ),
+	( ('USB', 0x11B), 'KEY_LAT12' ),
+	( ('USB', 0x11C), 'KEY_LAT13' ),
+	( ('USB', 0x11D), 'KEY_LAT14' ),
+	( ('USB', 0x11E), 'KEY_LAT15' ),
+	( ('USB', 0x11F), 'KEY_LAT16' ),
+	( ('USB', 0x120), 'KEY_NEXT_LAYER' ),
+	( ('USB', 0x121), 'KEY_PREV_LAYER' ),
+
+	# USB HID Consumer Control Codes
+# List of Consumer Codes - USB HID 1.12v2
+# Only listing relevant ones, let me know if you need more -HaaTa
+# NKRO HID Supports 0x020 - 0x29C
+	( ('CONS', 0x020), 'CONSUMER_10' ),
+	( ('CONS', 0x021), 'CONSUMER_100' ),
+	( ('CONS', 0x022), 'CONSUMER_AM_PM' ),
+# 0x023 - 0x03F Reserved
+	( ('CONS', 0x030), 'CONSUMER_POWER' ),
+	( ('CONS', 0x031), 'CONSUMER_RESET' ),
+	( ('CONS', 0x032), 'CONSUMER_SLEEP' ),
+	( ('CONS', 0x033), 'CONSUMER_SLEEP_AFTER' ),
+	( ('CONS', 0x034), 'CONSUMER_SLEEP_MODE' ),
+	( ('CONS', 0x035), 'CONSUMER_ILLUMINATION' ),
+
+# 0x037 - 0x03F Reserved
+	( ('CONS', 0x040), 'CONSUMER_MENU' ),
+	( ('CONS', 0x041), 'CONSUMER_MENU_PICK' ),
+	( ('CONS', 0x042), 'CONSUMER_MENU_UP' ),
+	( ('CONS', 0x043), 'CONSUMER_MENU_DOWN' ),
+	( ('CONS', 0x044), 'CONSUMER_MENU_LEFT' ),
+	( ('CONS', 0x045), 'CONSUMER_MENU_RIGHT' ),
+	( ('CONS', 0x046), 'CONSUMER_MENU_ESCAPE' ),
+	( ('CONS', 0x047), 'CONSUMER_MENU_VALUE_INCREASE' ),
+	( ('CONS', 0x048), 'CONSUMER_MENU_VALUE_DECREASE' ),
+# 0x049 - 0x05F Reserved
+	( ('CONS', 0x060), 'CONSUMER_DATA_ON_SCREEN' ),
+	( ('CONS', 0x061), 'CONSUMER_CLOSED_CAPTION' ),
+	( ('CONS', 0x062), 'CONSUMER_CLOSED_CAPTION_SELECT' ),
+	( ('CONS', 0x063), 'CONSUMER_VCR_TV' ),
+	( ('CONS', 0x064), 'CONSUMER_BROADCAST_MODE' ),
+	( ('CONS', 0x065), 'CONSUMER_SNAPSHOT' ),
+	( ('CONS', 0x066), 'CONSUMER_STILL' ),
+# 0x067 - 0x06E Reserved?
+	( ('CONS', 0x06F), 'CONSUMER_BRIGHTNESS_INCREMENT' ),
+	( ('CONS', 0x070), 'CONSUMER_BRIGHTNESS_DECREMENT' ),
+
+	( ('CONS', 0x072), 'CONSUMER_BACKLIGHT_TOGGLE' ),
+	( ('CONS', 0x073), 'CONSUMER_BRIGHTNESS_MIN' ),
+	( ('CONS', 0x074), 'CONSUMER_BRIGHTNESS_MAX' ),
+	( ('CONS', 0x075), 'CONSUMER_BRIGHTNESS_AUTO' ),
+# 0x076 - 0x07F Reserved
+
+	( ('CONS', 0x081), 'CONSUMER_ASSIGN_SELECTION' ),
+	( ('CONS', 0x082), 'CONSUMER_MODE_STEP' ),
+	( ('CONS', 0x083), 'CONSUMER_RECALL_LAST' ),
+	( ('CONS', 0x084), 'CONSUMER_ENTER_CHANNEL' ),
+	( ('CONS', 0x085), 'CONSUMER_ORDER_MOVIE' ),
+
+	( ('CONS', 0x088), 'CONSUMER_MEDIA_COMPUTER' ),
+	( ('CONS', 0x089), 'CONSUMER_MEDIA_TV' ),
+	( ('CONS', 0x08A), 'CONSUMER_MEDIA_WWW' ),
+	( ('CONS', 0x08B), 'CONSUMER_MEDIA_DVD' ),
+	( ('CONS', 0x08C), 'CONSUMER_MEDIA_TELEPHONE' ),
+	( ('CONS', 0x08D), 'CONSUMER_MEDIA_PROGRAM_GUIDE' ),
+	( ('CONS', 0x08E), 'CONSUMER_MEDIA_VIDEO_PHONE' ),
+	( ('CONS', 0x08F), 'CONSUMER_MEDIA_SELECT_GAMES' ),
+	( ('CONS', 0x090), 'CONSUMER_MEDIA_SELECT_MESSAGES' ),
+	( ('CONS', 0x091), 'CONSUMER_MEDIA_SELECT_CD' ),
+	( ('CONS', 0x092), 'CONSUMER_MEDIA_SELECT_VCR' ),
+	( ('CONS', 0x093), 'CONSUMER_MEDIA_SELECT_TUNER' ),
+	( ('CONS', 0x094), 'CONSUMER_QUIT' ),
+	( ('CONS', 0x095), 'CONSUMER_HELP' ),
+	( ('CONS', 0x096), 'CONSUMER_MEDIA_SELECT_TAPE' ),
+	( ('CONS', 0x097), 'CONSUMER_MEDIA_SELECT_CABLE' ),
+	( ('CONS', 0x098), 'CONSUMER_MEDIA_SELECT_SATELLITE' ),
+	( ('CONS', 0x099), 'CONSUMER_MEDIA_SELECT_SECURITY' ),
+	( ('CONS', 0x09A), 'CONSUMER_MEDIA_SELECT_HOME' ),
+	( ('CONS', 0x09B), 'CONSUMER_MEDIA_SELECT_CALL' ),
+	( ('CONS', 0x09C), 'CONSUMER_CHANNEL_INCREMENT' ),
+	( ('CONS', 0x09D), 'CONSUMER_CAHNNEL_DECREMENT' ),
+	( ('CONS', 0x09E), 'CONSUMER_MEDIA_SELECT_SAP' ),
+# 0x09F Reserved
+	( ('CONS', 0x0A0), 'CONSUMER_VCR_PLUS' ),
+	( ('CONS', 0x0A1), 'CONSUMER_ONCE' ),
+	( ('CONS', 0x0A2), 'CONSUMER_DAILY' ),
+	( ('CONS', 0x0A3), 'CONSUMER_WEEKLY' ),
+	( ('CONS', 0x0A4), 'CONSUMER_MONTHLY' ),
+# 0x0A5 - 0x0AF Reserved
+	( ('CONS', 0x0B0), 'CONSUMER_PLAY' ),
+	( ('CONS', 0x0B1), 'CONSUMER_PAUSE' ),
+	( ('CONS', 0x0B2), 'CONSUMER_RECORD' ),
+	( ('CONS', 0x0B3), 'CONSUMER_FAST_FORWARD' ),
+	( ('CONS', 0x0B4), 'CONSUMER_REWIND' ),
+	( ('CONS', 0x0B5), 'CONSUMER_SCAN_NEXT_TRACK' ),
+	( ('CONS', 0x0B6), 'CONSUMER_SCAN_PREVIOUS_TRACK' ),
+	( ('CONS', 0x0B7), 'CONSUMER_STOP' ),
+	( ('CONS', 0x0B8), 'CONSUMER_EJECT' ),
+	( ('CONS', 0x0B9), 'CONSUMER_RANDOM_PLAY' ),
+
+	( ('CONS', 0x0BC), 'CONSUMER_REPEAT' ),
+
+	( ('CONS', 0x0BE), 'CONSUMER_TRACK_NORMAL' ),
+
+	( ('CONS', 0x0C0), 'CONSUMER_FRAME_FORWARD' ),
+	( ('CONS', 0x0C1), 'CONSUMER_FRAME_BACK' ),
+	( ('CONS', 0x0C2), 'CONSUMER_MARK' ),
+	( ('CONS', 0x0C3), 'CONSUMER_CLEAR_MARK' ),
+	( ('CONS', 0x0C4), 'CONSUMER_REPEAT_FROM_MARK' ),
+	( ('CONS', 0x0C5), 'CONSUMER_RETURN_TO_MARK' ),
+	( ('CONS', 0x0C6), 'CONSUMER_SEARCH_MARK_FORWARDS' ),
+	( ('CONS', 0x0C7), 'CONSUMER_SEARCH_MARK_BACKWARDS' ),
+	( ('CONS', 0x0C8), 'CONSUMER_COUNTER_RESET' ),
+	( ('CONS', 0x0C9), 'CONSUMER_SHOW_COUNTER' ),
+	( ('CONS', 0x0CA), 'CONSUMER_TRACKING_INCREMENT' ),
+	( ('CONS', 0x0CB), 'CONSUMER_TRACKING_DECREMENT' ),
+	( ('CONS', 0x0CC), 'CONSUMER_STOP_EJECT' ),
+	( ('CONS', 0x0CD), 'CONSUMER_PAUSE_PLAY' ),
+	( ('CONS', 0x0CE), 'CONSUMER_PLAY_SKIP' ),
+# 0x0CF - 0x0DF Reserved
+
+	( ('CONS', 0x0E2), 'CONSUMER_MUTE' ),
+
+	( ('CONS', 0x0E5), 'CONSUMER_BASS_BOOST' ),
+	( ('CONS', 0x0E6), 'CONSUMER_SURROUND_MODE' ),
+	( ('CONS', 0x0E7), 'CONSUMER_LOUDNESS' ),
+	( ('CONS', 0x0E8), 'CONSUMER_MPX' ),
+	( ('CONS', 0x0E9), 'CONSUMER_VOLUME_UP' ),
+	( ('CONS', 0x0EA), 'CONSUMER_VOLUME_DOWN' ),
+# 0x0EB - 0x0EF Reserved
+	( ('CONS', 0x0F0), 'CONSUMER_SPEED_SELECT' ),
+	( ('CONS', 0x0F2), 'CONSUMER_STANDARD_PLAY' ),
+	( ('CONS', 0x0F3), 'CONSUMER_LONG_PLAY' ),
+	( ('CONS', 0x0F4), 'CONSUMER_EXTENDED_PLAY' ),
+	( ('CONS', 0x0F5), 'CONSUMER_SLOW' ),
+# 0x0F6 - 0x0FF
+	( ('CONS', 0x100), 'CONSUMER_FAN_ENABLE' ),
+
+	( ('CONS', 0x102), 'CONSUMER_LIGHT_ENABLE' ),
+
+	( ('CONS', 0x104), 'CONSUMER_CLIMATE_CONTROL_ENABLE' ),
+
+	( ('CONS', 0x106), 'CONSUMER_SECURITY_ENABLE' ),
+	( ('CONS', 0x107), 'CONSUMER_FIRE_ALARM' ),
+
+	( ('CONS', 0x10A), 'CONSUMER_MOTION' ),
+	( ('CONS', 0x10B), 'CONSUMER_DURESS_ALARM' ),
+	( ('CONS', 0x10C), 'CONSUMER_HOLDUP_ALARM' ),
+	( ('CONS', 0x10D), 'CONSUMER_MEDICAL_ALARM' ),
+# 0x10E - 0x14F Reserved
+	( ('CONS', 0x150), 'CONSUMER_BALANCE_RIGHT' ),
+	( ('CONS', 0x151), 'CONSUMER_BALANCE_LEFT' ),
+	( ('CONS', 0x152), 'CONSUMER_BASS_INCR' ),
+	( ('CONS', 0x153), 'CONSUMER_BASS_DECR' ),
+	( ('CONS', 0x154), 'CONSUMER_TREBLE_INCR' ),
+	( ('CONS', 0x155), 'CONSUMER_TREBLE_DECR' ),
+# 0x156 - 0x15F Reserved
+
+	( ('CONS', 0x171), 'CONSUMER_SUB_CHANNEL_INCREMENT' ),
+	( ('CONS', 0x172), 'CONSUMER_SUB_CHANNEL_DECREMENT' ),
+	( ('CONS', 0x173), 'CONSUMER_ALT_AUDIO_INCREMENT' ),
+	( ('CONS', 0x174), 'CONSUMER_ALT_AUDIO_DECREMENT' ),
+
+# List of Consumer Codes - USB HID 1.12v2
+# Application Launch Buttons pg 79
+	( ('CONS', 0x181), 'AL_LAUNCH_BUTTON_CONFIG_TOOL' ),
+	( ('CONS', 0x182), 'AL_PROGRAMMABLE_BUTTON_CONFIG' ),
+	( ('CONS', 0x183), 'AL_CONSUMER_CONTROL_CONFIG' ),
+	( ('CONS', 0x184), 'AL_WORD_PROCESSOR' ),
+	( ('CONS', 0x185), 'AL_TEXT_EDITOR' ),
+	( ('CONS', 0x186), 'AL_SPREADSHEET' ),
+	( ('CONS', 0x187), 'AL_GRAPHICS_EDITOR' ),
+	( ('CONS', 0x188), 'AL_PRESENTATION_APP' ),
+	( ('CONS', 0x189), 'AL_DATABASE_APP' ),
+	( ('CONS', 0x18A), 'AL_EMAIL_READER' ),
+	( ('CONS', 0x18B), 'AL_NEWSREADER' ),
+	( ('CONS', 0x18C), 'AL_VOICEMAIL' ),
+	( ('CONS', 0x18D), 'AL_CONTACTS_ADDRESS_BOOK' ),
+	( ('CONS', 0x18E), 'AL_CALENDAR_SCHEDULE' ),
+	( ('CONS', 0x18F), 'AL_TASK_PROJECT_MANAGER' ),
+	( ('CONS', 0x190), 'AL_LOG_JOURNAL_TIMECARD' ),
+	( ('CONS', 0x191), 'AL_CHECKBOOK_FINANCE' ),
+	( ('CONS', 0x192), 'AL_CALCULATOR' ),
+	( ('CONS', 0x193), 'AL_A_V_CAPTURE_PLAYBACK' ),
+	( ('CONS', 0x194), 'AL_LOCAL_MACHINE_BROWSER' ),
+	( ('CONS', 0x195), 'AL_LAN_WAN_BROWSER' ),
+	( ('CONS', 0x196), 'AL_INTERNET_BROWSER' ),
+	( ('CONS', 0x197), 'AL_REMOTE_NETWORKING_ISP_CONNECT' ),
+	( ('CONS', 0x198), 'AL_NETWORK_CONFERENCE' ),
+	( ('CONS', 0x199), 'AL_NETWORK_CHAT' ),
+	( ('CONS', 0x19A), 'AL_TELEPHONY_DIALER' ),
+	( ('CONS', 0x19B), 'AL_LOGON' ),
+	( ('CONS', 0x19C), 'AL_LOGOFF' ),
+	( ('CONS', 0x19D), 'AL_LOGON_LOGOFF' ),
+	( ('CONS', 0x19E), 'AL_TERMINAL_LOCK_SCREENSAVER' ),
+	( ('CONS', 0x19F), 'AL_CONTROL_PANEL' ),
+	( ('CONS', 0x1A0), 'AL_COMMAND_LINE_PROCESSOR_RUN' ),
+	( ('CONS', 0x1A1), 'AL_PROCESS_TASK_MANAGER' ),
+	( ('CONS', 0x1A2), 'AL_SELECT_TAST_APP' ),
+	( ('CONS', 0x1A3), 'AL_NEXT_TASK_APP' ),
+	( ('CONS', 0x1A4), 'AL_PREVIOUS_TASK_APP' ),
+	( ('CONS', 0x1A5), 'AL_PREEMPTIVE_HALT_TASK_APP' ),
+	( ('CONS', 0x1A6), 'AL_INTEGRATED_HELP_CENTER' ),
+	( ('CONS', 0x1A7), 'AL_DOCUMENTS' ),
+	( ('CONS', 0x1A8), 'AL_THESAURUS' ),
+	( ('CONS', 0x1A9), 'AL_DICTIONARY' ),
+	( ('CONS', 0x1AA), 'AL_DESKTOP' ),
+	( ('CONS', 0x1AB), 'AL_SPELL_CHECK' ),
+	( ('CONS', 0x1AC), 'AL_GRAMMAR_CHECK' ),
+	( ('CONS', 0x1AD), 'AL_WIRELESS_STATUS' ),
+	( ('CONS', 0x1AE), 'AL_KEYBOARD_LAYOUT' ),
+	( ('CONS', 0x1AF), 'AL_VIRUS_PROTECTION' ),
+	( ('CONS', 0x1B0), 'AL_ENCRYPTION' ),
+	( ('CONS', 0x1B1), 'AL_SCREEN_SAVER' ),
+	( ('CONS', 0x1B2), 'AL_ALARMS' ),
+	( ('CONS', 0x1B3), 'AL_CLOCK' ),
+	( ('CONS', 0x1B4), 'AL_FILE_BROWSER' ),
+	( ('CONS', 0x1B5), 'AL_POWER_STATUS' ),
+	( ('CONS', 0x1B6), 'AL_IMAGE_BROWSER' ),
+	( ('CONS', 0x1B7), 'AL_AUDIO_BROWSER' ),
+	( ('CONS', 0x1B8), 'AL_MOVIE_BROWSER' ),
+	( ('CONS', 0x1B9), 'AL_DIGITAL_RIGHTS_MANAGER' ),
+	( ('CONS', 0x1BA), 'AL_DIGITAL_WALLET' ),
+# 0x1BB Reserved
+	( ('CONS', 0x1BC), 'AL_INSTANT_MESSAGING' ),
+	( ('CONS', 0x1BD), 'AL_OEM_FEATURES_TIPS_TUTORIAL' ),
+	( ('CONS', 0x1BE), 'AL_OEM_HELP' ),
+	( ('CONS', 0x1BF), 'AL_ONLINE_COMMUNITY' ),
+	( ('CONS', 0x1C0), 'AL_ENTERTAINMENT_CONTENT' ),
+	( ('CONS', 0x1C1), 'AL_ONLINE_SHOPPING' ),
+	( ('CONS', 0x1C2), 'AL_SMARTCARD_INFO_HELP' ),
+	( ('CONS', 0x1C3), 'AL_MARKET_MONITOR' ),
+	( ('CONS', 0x1C4), 'AL_CUSTOMIZED_CORP_NEWS' ),
+	( ('CONS', 0x1C5), 'AL_ONLINE_ACTIVITY' ),
+	( ('CONS', 0x1C6), 'AL_SEARCH_BROWSER' ),
+	( ('CONS', 0x1C7), 'AL_AUDIO_PLAYER' ),
+
+# List of Consumer Codes - USB HID 1.12v2
+# Generic GUI Application Controls pg 82
+	( ('CONS', 0x201), 'AC_NEW' ),
+	( ('CONS', 0x202), 'AC_OPEN' ),
+	( ('CONS', 0x203), 'AC_CLOSE' ),
+	( ('CONS', 0x204), 'AC_EXIT' ),
+	( ('CONS', 0x205), 'AC_MAXIMIZE' ),
+	( ('CONS', 0x206), 'AC_MINIMIZE' ),
+	( ('CONS', 0x207), 'AC_SAVE' ),
+	( ('CONS', 0x208), 'AC_PRINT' ),
+	( ('CONS', 0x209), 'AC_PROPERTIES' ),
+	( ('CONS', 0x21A), 'AC_UNDO' ),
+	( ('CONS', 0x21B), 'AC_COPY' ),
+	( ('CONS', 0x21C), 'AC_CUT' ),
+	( ('CONS', 0x21D), 'AC_PASTE' ),
+	( ('CONS', 0x21E), 'AC_SELECT_ALL' ),
+	( ('CONS', 0x21F), 'AC_FIND' ),
+	( ('CONS', 0x220), 'AC_FIND_AND_REPLACE' ),
+	( ('CONS', 0x221), 'AC_SEARCH' ),
+	( ('CONS', 0x222), 'AC_GO_TO' ),
+	( ('CONS', 0x223), 'AC_HOME' ),
+	( ('CONS', 0x224), 'AC_BACK' ),
+	( ('CONS', 0x225), 'AC_FORWARD' ),
+	( ('CONS', 0x226), 'AC_STOP' ),
+	( ('CONS', 0x227), 'AC_REFRESH' ),
+	( ('CONS', 0x228), 'AC_PREVIOUS_LINK' ),
+	( ('CONS', 0x229), 'AC_NEXT_LINK' ),
+	( ('CONS', 0x22A), 'AC_BOOKMARKS' ),
+	( ('CONS', 0x22B), 'AC_HISTORY' ),
+	( ('CONS', 0x22C), 'AC_SUBSCRIPTIONS' ),
+	( ('CONS', 0x22D), 'AC_ZOOM_IN' ),
+	( ('CONS', 0x22E), 'AC_ZOOM_OUT' ),
+	( ('CONS', 0x22F), 'AC_ZOOM' ),
+	( ('CONS', 0x230), 'AC_FULL_SCREEN_VIEW' ),
+	( ('CONS', 0x231), 'AC_NORMAL_VIEW' ),
+	( ('CONS', 0x232), 'AC_VIEW_TOGGLE' ),
+	( ('CONS', 0x233), 'AC_SCROLL_UP' ),
+	( ('CONS', 0x234), 'AC_SCROLL_DOWN' ),
+	( ('CONS', 0x235), 'AC_SCROLL' ),
+	( ('CONS', 0x236), 'AC_PAN_LEFT' ),
+	( ('CONS', 0x237), 'AC_PAN_RIGHT' ),
+	( ('CONS', 0x238), 'AC_PAN' ),
+	( ('CONS', 0x239), 'AC_NEW_WINDOW' ),
+	( ('CONS', 0x23A), 'AC_TILE_HORIZONTALLY' ),
+	( ('CONS', 0x23B), 'AC_TILE_VERTICALLY' ),
+	( ('CONS', 0x23C), 'AC_FORMAT' ),
+	( ('CONS', 0x23D), 'AC_EDIT' ),
+	( ('CONS', 0x23E), 'AC_BOLD' ),
+	( ('CONS', 0x23F), 'AC_ITALICS' ),
+	( ('CONS', 0x240), 'AC_UNDERLINE' ),
+	( ('CONS', 0x241), 'AC_STRIKETHROUGH' ),
+	( ('CONS', 0x242), 'AC_SUBSCRIPT' ),
+	( ('CONS', 0x243), 'AC_SUPERSCRIPT' ),
+	( ('CONS', 0x244), 'AC_ALL_CAPS' ),
+	( ('CONS', 0x245), 'AC_ROTATE' ),
+	( ('CONS', 0x246), 'AC_RESIZE' ),
+	( ('CONS', 0x247), 'AC_FILP_HORIZONTAL' ),
+	( ('CONS', 0x248), 'AC_FILP_VERTICAL' ),
+	( ('CONS', 0x249), 'AC_MIRROR_HORIZONTAL' ),
+	( ('CONS', 0x24A), 'AC_MIRROR_VERTICAL' ),
+	( ('CONS', 0x24B), 'AC_FONT_SELECT' ),
+	( ('CONS', 0x24C), 'AC_FONT_COLOR' ),
+	( ('CONS', 0x24D), 'AC_FONT_SIZE' ),
+	( ('CONS', 0x24E), 'AC_JUSTIFY_LEFT' ),
+	( ('CONS', 0x24F), 'AC_JUSTIFY_CENTER_H' ),
+	( ('CONS', 0x250), 'AC_JUSTIFY_RIGHT' ),
+	( ('CONS', 0x251), 'AC_JUSTIFY_BLOCK_H' ),
+	( ('CONS', 0x252), 'AC_JUSTIFY_TOP' ),
+	( ('CONS', 0x253), 'AC_JUSTIFY_CENTER_V' ),
+	( ('CONS', 0x254), 'AC_JUSTIFY_BOTTOM' ),
+	( ('CONS', 0x255), 'AC_JUSTIFY_BLOCK_V' ),
+	( ('CONS', 0x256), 'AC_INDENT_DECREASE' ),
+	( ('CONS', 0x257), 'AC_INDENT_INCREASE' ),
+	( ('CONS', 0x258), 'AC_NUMBERED_LIST' ),
+	( ('CONS', 0x259), 'AC_RESTART_NUMBERING' ),
+	( ('CONS', 0x25A), 'AC_BULLETED_LIST' ),
+	( ('CONS', 0x25B), 'AC_PROMOTE' ),
+	( ('CONS', 0x25C), 'AC_DEMOTE' ),
+	( ('CONS', 0x25D), 'AC_YES' ),
+	( ('CONS', 0x25E), 'AC_NO' ),
+	( ('CONS', 0x25F), 'AC_CANCEL' ),
+	( ('CONS', 0x260), 'AC_CATALOG' ),
+	( ('CONS', 0x261), 'AC_BUY_CHECKOUT' ),
+	( ('CONS', 0x262), 'AC_ADD_TO_CART' ),
+	( ('CONS', 0x263), 'AC_EXPAND' ),
+	( ('CONS', 0x264), 'AC_EXPAND_ALL' ),
+	( ('CONS', 0x265), 'AC_COLLAPSE' ),
+	( ('CONS', 0x266), 'AC_COLLAPSE_ALL' ),
+	( ('CONS', 0x267), 'AC_PRINT_PREVIEW' ),
+	( ('CONS', 0x268), 'AC_PASTE_SPECIAL' ),
+	( ('CONS', 0x269), 'AC_INSERT_MODE' ),
+	( ('CONS', 0x26A), 'AC_DELETE' ),
+	( ('CONS', 0x26B), 'AC_LOCK' ),
+	( ('CONS', 0x26C), 'AC_UNLOCK' ),
+	( ('CONS', 0x26D), 'AC_PROTECT' ),
+	( ('CONS', 0x26E), 'AC_UNPROTECT' ),
+	( ('CONS', 0x26F), 'AC_ATTACH_COMMENT' ),
+	( ('CONS', 0x270), 'AC_DELETE_COMMENT' ),
+	( ('CONS', 0x271), 'AC_VIEW_COMMENT' ),
+	( ('CONS', 0x272), 'AC_SELECT_WORD' ),
+	( ('CONS', 0x273), 'AC_SELECT_SENTENCE' ),
+	( ('CONS', 0x274), 'AC_SELECT_PARAGRAPH' ),
+	( ('CONS', 0x275), 'AC_SELECT_COLUMN' ),
+	( ('CONS', 0x276), 'AC_SELECT_ROW' ),
+	( ('CONS', 0x277), 'AC_SELECT_TABLE' ),
+	( ('CONS', 0x278), 'AC_SELECT_OBJECT' ),
+	( ('CONS', 0x279), 'AC_REDO_REPEAT' ),
+	( ('CONS', 0x27A), 'AC_SORT' ),
+	( ('CONS', 0x27B), 'AC_SORT_ASCENDING' ),
+	( ('CONS', 0x27C), 'AC_SORT_DESCENDING' ),
+	( ('CONS', 0x27D), 'AC_FILTER' ),
+	( ('CONS', 0x27E), 'AC_SET_CLOCK' ),
+	( ('CONS', 0x27F), 'AC_VIEW_CLOCK' ),
+	( ('CONS', 0x280), 'AC_SELECT_TIME_ZONE' ),
+	( ('CONS', 0x281), 'AC_EDIT_TIME_ZONE' ),
+	( ('CONS', 0x282), 'AC_SET_ALARM' ),
+	( ('CONS', 0x283), 'AC_CLEAR_ALARM' ),
+	( ('CONS', 0x284), 'AC_SNOOZE_ALARM' ),
+	( ('CONS', 0x285), 'AC_RESET_ALARM' ),
+	( ('CONS', 0x286), 'AC_SYNCHRONIZE' ),
+	( ('CONS', 0x287), 'AC_SEND_RECEIVE' ),
+	( ('CONS', 0x288), 'AC_SEND_TO' ),
+	( ('CONS', 0x289), 'AC_REPLY' ),
+	( ('CONS', 0x28A), 'AC_REPLY_ALL' ),
+	( ('CONS', 0x28B), 'AC_FORWARD_MSG' ),
+	( ('CONS', 0x28C), 'AC_SEND' ),
+	( ('CONS', 0x28D), 'AC_ATTACH_FILE' ),
+	( ('CONS', 0x28E), 'AC_UPLOAD' ),
+	( ('CONS', 0x28F), 'AC_DOWNLOAD' ),
+	( ('CONS', 0x290), 'AC_SET_BORDERS' ),
+	( ('CONS', 0x291), 'AC_INSERT_ROW' ),
+	( ('CONS', 0x292), 'AC_INSERT_COLUMN' ),
+	( ('CONS', 0x293), 'AC_INSERT_FILE' ),
+	( ('CONS', 0x294), 'AC_INSERT_PICTURE' ),
+	( ('CONS', 0x295), 'AC_INSERT_OBJECT' ),
+	( ('CONS', 0x296), 'AC_INSERT_SYMBOL' ),
+	( ('CONS', 0x297), 'AC_SAVE_AND_CLOSE' ),
+	( ('CONS', 0x298), 'AC_RENAME' ),
+	( ('CONS', 0x299), 'AC_MERGE' ),
+	( ('CONS', 0x29A), 'AC_SPLIT' ),
+	( ('CONS', 0x29B), 'AC_DISTRIBUTE_HORIZONTALLY' ),
+	( ('CONS', 0x29C), 'AC_DISTRIBUTE_VERTICALLY' ),
+	( ('CONS', 0x29D), 'AC_NEXT_KEYBOARD_LAYOUT_SEL' ),
+# 0x29E-0xFFFF Reserved
+
+	# USB HID LED Codes
+	( ('IND', 0x00), 'LED_UNDEFINED' ),
+	( ('IND', 0x01), 'LED_NUM_LOCK' ),
+	( ('IND', 0x02), 'LED_CAPS_LOCK' ),
+	( ('IND', 0x03), 'LED_SCROLL_LOCK' ),
+	( ('IND', 0x04), 'LED_COMPOSE' ),
+	( ('IND', 0x05), 'LED_KANA' ),
+	( ('IND', 0x06), 'LED_POWER' ),
+	( ('IND', 0x07), 'LED_SHIFT' ),
+	( ('IND', 0x08), 'LED_DO_NOT_DISTURB' ),
+	( ('IND', 0x09), 'LED_MUTE' ),
+	( ('IND', 0x0A), 'LED_TONE_ENABLE' ),
+	( ('IND', 0x0B), 'LED_HIGHCUT_FILTER' ),
+	( ('IND', 0x0C), 'LED_LOWCUT_FILTER' ),
+	( ('IND', 0x0D), 'LED_EQL_ENABLE' ),
+	( ('IND', 0x0E), 'LED_SND_FLD_ON' ),
+	( ('IND', 0x0F), 'LED_SURROUND_ON' ),
+	( ('IND', 0x10), 'LED_REPEAT' ),
+	( ('IND', 0x11), 'LED_STEREO' ),
+	( ('IND', 0x12), 'LED_SAMPLE_RT_DET' ),
+	( ('IND', 0x13), 'LED_SPINNING' ),
+	( ('IND', 0x14), 'LED_CAV' ),
+	( ('IND', 0x15), 'LED_CLV' ),
+	( ('IND', 0x16), 'LED_REC_FMT_DET' ),
+	( ('IND', 0x17), 'LED_OFF_HOOK' ),
+	( ('IND', 0x18), 'LED_RING' ),
+	( ('IND', 0x19), 'LED_MSG_WAITING' ),
+	( ('IND', 0x1A), 'LED_DATA_MODE' ),
+	( ('IND', 0x1B), 'LED_BAT_OPERATION' ),
+	( ('IND', 0x1C), 'LED_BAT_OK' ),
+	( ('IND', 0x1D), 'LED_BAT_LOW' ),
+	( ('IND', 0x1E), 'LED_SPEAKER' ),
+	( ('IND', 0x1F), 'LED_HEAD_SET' ),
+	( ('IND', 0x20), 'LED_HOLD' ),
+	( ('IND', 0x21), 'LED_MICROPHONE' ),
+	( ('IND', 0x22), 'LED_COVERAGE' ),
+	( ('IND', 0x23), 'LED_NIGHT_MODE' ),
+	( ('IND', 0x24), 'LED_SEND_CALLS' ),
+	( ('IND', 0x25), 'LED_CALL_PICKUP' ),
+	( ('IND', 0x26), 'LED_CONFERENCE' ),
+	( ('IND', 0x27), 'LED_STAND_BY' ),
+	( ('IND', 0x28), 'LED_CAMERA_ON' ),
+	( ('IND', 0x29), 'LED_CAMERA_OFF' ),
+	( ('IND', 0x2A), 'LED_ON_LINE' ),
+	( ('IND', 0x2B), 'LED_OFF_LINE' ),
+	( ('IND', 0x2C), 'LED_BUSY' ),
+	( ('IND', 0x2D), 'LED_READY' ),
+	( ('IND', 0x2E), 'LED_PAPER_OUT' ),
+	( ('IND', 0x2F), 'LED_PAPER_JAM' ),
+	( ('IND', 0x30), 'LED_REMOTE' ),
+	( ('IND', 0x31), 'LED_FORWARD' ),
+	( ('IND', 0x32), 'LED_REVERSE' ),
+	( ('IND', 0x33), 'LED_STOP' ),
+	( ('IND', 0x34), 'LED_REWIND' ),
+	( ('IND', 0x35), 'LED_FAST_FORWARD' ),
+	( ('IND', 0x36), 'LED_PLAY' ),
+	( ('IND', 0x37), 'LED_PAUSE' ),
+	( ('IND', 0x38), 'LED_RECORD' ),
+	( ('IND', 0x39), 'LED_ERROR' ),
+	( ('IND', 0x3A), 'LED_USI' ),
+	( ('IND', 0x3B), 'LED_UIUI' ),
+	( ('IND', 0x3C), 'LED_UMMI' ),
+	( ('IND', 0x3D), 'LED_IND_ON' ),
+	( ('IND', 0x3E), 'LED_IND_FLASH' ),
+	( ('IND', 0x3F), 'LED_IND_SLOW_BLNK' ),
+	( ('IND', 0x40), 'LED_IND_FAST_BLNK' ),
+	( ('IND', 0x41), 'LED_IND_OFF' ),
+	( ('IND', 0x42), 'LED_FLASH_ON_TIME' ),
+	( ('IND', 0x43), 'LED_SLW_B_ON_TIME' ),
+	( ('IND', 0x44), 'LED_SLW_B_OFF_TIME' ),
+	( ('IND', 0x45), 'LED_FST_B_ON_TIME' ),
+	( ('IND', 0x46), 'LED_FST_B_OFF_TIME' ),
+	( ('IND', 0x47), 'LED_UIC' ),
+	( ('IND', 0x48), 'LED_IND_RED' ),
+	( ('IND', 0x49), 'LED_IND_GREEN' ),
+	( ('IND', 0x4A), 'LED_IND_AMBER' ),
+	( ('IND', 0x4B), 'LED_GENERIC_IND' ),
+	( ('IND', 0x4C), 'LED_SYS_SUSPEND' ),
+	( ('IND', 0x4D), 'LED_EXT_PWR_CONN' ),
+# 0x4E - 0xFFFF Reserved
+
+	# USB HID System Control Codes
+# List of System Controls - USB HID 1.12v2 pg 32
+# NKRO HID Supports 0x81 - 0xB7
+	( ('SYS', 0x81), 'SYS_POWER_DOWN' ),
+	( ('SYS', 0x82), 'SYS_SLEEP' ),
+	( ('SYS', 0x83), 'SYS_WAKE_UP' ),
+	( ('SYS', 0x84), 'SYS_CONTEXT_MENU' ),
+	( ('SYS', 0x85), 'SYS_MAIN_MENU' ),
+	( ('SYS', 0x86), 'SYS_APP_MENU' ),
+	( ('SYS', 0x87), 'SYS_MENU_HELP' ),
+	( ('SYS', 0x88), 'SYS_MENU_EXIT' ),
+	( ('SYS', 0x89), 'SYS_MENU_SELECT' ),
+	( ('SYS', 0x8A), 'SYS_MENU_RIGHT' ),
+	( ('SYS', 0x8B), 'SYS_MENU_LEFT' ),
+	( ('SYS', 0x8C), 'SYS_MENU_UP' ),
+	( ('SYS', 0x8D), 'SYS_MENU_DOWN' ),
+	( ('SYS', 0x8E), 'SYS_COLD_RESTART' ),
+	( ('SYS', 0x8F), 'SYS_WARM_RESTART' ),
+	( ('SYS', 0x90), 'SYS_DPAD_UP' ),
+	( ('SYS', 0x91), 'SYS_DPAD_DOWN' ),
+	( ('SYS', 0x92), 'SYS_DPAD_RIGHT' ),
+	( ('SYS', 0x93), 'SYS_DPAD_LEFT' ),
+# 0x94 - 0x9F Reserved
+	( ('SYS', 0xA0), 'SYS_DOCK' ),
+	( ('SYS', 0xA1), 'SYS_UNDOCK' ),
+	( ('SYS', 0xA2), 'SYS_SETUP' ),
+	( ('SYS', 0xA3), 'SYS_BREAK' ),
+	( ('SYS', 0xA4), 'SYS_DEBUGGER_BREAK' ),
+	( ('SYS', 0xA5), 'SYS_APP_BREAK' ),
+	( ('SYS', 0xA6), 'SYS_APP_DEBUGGER_BREAK' ),
+	( ('SYS', 0xA7), 'SYS_SPEAKER_MUTE' ),
+	( ('SYS', 0xA8), 'SYS_HIBERNATE' ),
+# 0xA9 - 0xAF Reserved
+	( ('SYS', 0xB0), 'SYS_DISP_INVERT' ),
+	( ('SYS', 0xB1), 'SYS_DISP_INTERNAL' ),
+	( ('SYS', 0xB2), 'SYS_DISP_EXTERNAL' ),
+	( ('SYS', 0xB3), 'SYS_DISP_BOTH' ),
+	( ('SYS', 0xB4), 'SYS_DISP_DUAL' ),
+	( ('SYS', 0xB5), 'SYS_DISP_TOGGLE_INT_EXT' ),
+	( ('SYS', 0xB6), 'SYS_DISP_SWAP_PRI_SEC' ),
+	( ('SYS', 0xB7), 'SYS_DISP_LCD_AUTOSCALE' ),
+# 0xB8 - 0xFFFF Reserved
+])
+
+
+
+# Lookup for KLL defined HID values, internally the compiler uses numbers to combine the keymaps
+kll_hid_lookup_dictionary = dict()
+kll_hid_lookup_dictionary['USBCode'] = dict([
+	# USB HID Keyboard Codes
+	( 'A', ('USB', 0x04) ),
+	( 'B', ('USB', 0x05) ),
+	( 'C', ('USB', 0x06) ),
+	( 'D', ('USB', 0x07) ),
+	( 'E', ('USB', 0x08) ),
+	( 'F', ('USB', 0x09) ),
+	( 'G', ('USB', 0x0A) ),
+	( 'H', ('USB', 0x0B) ),
+	( 'I', ('USB', 0x0C) ),
+	( 'J', ('USB', 0x0D) ),
+	( 'K', ('USB', 0x0E) ),
+	( 'L', ('USB', 0x0F) ),
+	( 'M', ('USB', 0x10) ),
+	( 'N', ('USB', 0x11) ),
+	( 'O', ('USB', 0x12) ),
+	( 'P', ('USB', 0x13) ),
+	( 'Q', ('USB', 0x14) ),
+	( 'R', ('USB', 0x15) ),
+	( 'S', ('USB', 0x16) ),
+	( 'T', ('USB', 0x17) ),
+	( 'U', ('USB', 0x18) ),
+	( 'V', ('USB', 0x19) ),
+	( 'W', ('USB', 0x1A) ),
+	( 'X', ('USB', 0x1B) ),
+	( 'Y', ('USB', 0x1C) ),
+	( 'Z', ('USB', 0x1D) ),
+	( '1', ('USB', 0x1E) ),
+	( '2', ('USB', 0x1F) ),
+	( '3', ('USB', 0x20) ),
+	( '4', ('USB', 0x21) ),
+	( '5', ('USB', 0x22) ),
+	( '6', ('USB', 0x23) ),
+	( '7', ('USB', 0x24) ),
+	( '8', ('USB', 0x25) ),
+	( '9', ('USB', 0x26) ),
+	( '0', ('USB', 0x27) ),
+	( 'ENTER', ('USB', 0x28) ),
+	( 'ESC', ('USB', 0x29) ), ( 'ESCAPE', ('USB', 0x29) ),
+	( 'BACKSPACE', ('USB', 0x2A) ),
+	( 'TAB', ('USB', 0x2B) ),
+	( 'SPACE', ('USB', 0x2C) ), ( 'SPACEBAR', ('USB', 0x2C) ),
+	( '-', ('USB', 0x2D) ), ( 'MINUS', ('USB', 0x2D) ),
+	( '=', ('USB', 0x2E) ), ( 'EQUALS', ('USB', 0x2E) ), ( 'EQUAL', ('USB', 0x2E) ),
+	( '[', ('USB', 0x2F) ), ( 'LEFT BRACKET', ('USB', 0x2F) ), ( 'LBRACKET', ('USB', 0x2F) ), ( 'LEFT BRACE', ('USB', 0x2F) ), ( 'LBRACE', ('USB', 0x2F) ),
+	( ']', ('USB', 0x30) ), ( 'RIGHT BRACKET', ('USB', 0x30) ), ( 'RBRACKET', ('USB', 0x30) ), ( 'RIGHT BRACE', ('USB', 0x30) ), ( 'RBRACE', ('USB', 0x30) ),
+	( '\\', ('USB', 0x31) ), ( 'BACKSLASH', ('USB', 0x31) ),
+	( '#', ('USB', 0x32) ), ( 'NUMBER', ('USB', 0x32) ), ( 'HASH', ('USB', 0x32) ),
+	( ';', ('USB', 0x33) ), ( 'SEMICOLON', ('USB', 0x33) ),
+	( "'", ('USB', 0x34) ), ( 'QUOTE', ('USB', 0x34) ), ( 'SINGLE QUOTE', ('USB', 0x34) ),
+	( '`', ('USB', 0x35) ), ( 'BACKTICK', ('USB', 0x35) ),
+	( ',', ('USB', 0x36) ), ( 'COMMA', ('USB', 0x36) ),
+	( '.', ('USB', 0x37) ), ( 'PERIOD', ('USB', 0x37) ),
+	( '/', ('USB', 0x38) ), ( 'SLASH', ('USB', 0x38) ),
+	( 'CAPSLOCK', ('USB', 0x39) ), { 'CAPS LOCK', ('USB', 0x39) },
+	( 'F1', ('USB', 0x3A) ),
+	( 'F2', ('USB', 0x3B) ),
+	( 'F3', ('USB', 0x3C) ),
+	( 'F4', ('USB', 0x3D) ),
+	( 'F5', ('USB', 0x3E) ),
+	( 'F6', ('USB', 0x3F) ),
+	( 'F7', ('USB', 0x40) ),
+	( 'F8', ('USB', 0x41) ),
+	( 'F9', ('USB', 0x42) ),
+	( 'F10', ('USB', 0x43) ),
+	( 'F11', ('USB', 0x44) ),
+	( 'F12', ('USB', 0x45) ),
+	( 'PRINTSCREEN', ('USB', 0x46) ), ( 'PRINT SCREEN', ('USB', 0x46) ),
+	( 'SCROLLLOCK', ('USB', 0x47) ), ( 'SCROLL LOCK', ('USB', 0x47) ),
+	( 'PAUSE', ('USB', 0x48) ),
+	( 'INSERT', ('USB', 0x49) ),
+	( 'HOME', ('USB', 0x4A) ),
+	( 'PAGEUP', ('USB', 0x4B) ), ( 'PAGE UP', ('USB', 0x4B) ),
+	( 'DELETE', ('USB', 0x4C) ),
+	( 'END', ('USB', 0x4D) ),
+	( 'PAGEDOWN', ('USB', 0x4E) ), ( 'PAGE DOWN', ('USB', 0x4E) ),
+	( 'RIGHT', ('USB', 0x4F) ),
+	( 'LEFT', ('USB', 0x50) ),
+	( 'DOWN', ('USB', 0x51) ),
+	( 'UP', ('USB', 0x52) ),
+	( 'NUMLOCK', ('USB', 0x53) ), ( 'NUM LOCK', ('USB', 0x53) ),
+	( 'P/', ('USB', 0x54) ), ( 'KEYPAD SLASH', ('USB', 0x54) ),
+	( 'P*', ('USB', 0x55) ), ( 'KEYPAD ASTERIX', ('USB', 0x55) ), ( 'KEYPAD ASTERISK', ('USB', 0x55) ),
+	( 'P-', ('USB', 0x56) ), ( 'KEYPAD MINUS', ('USB', 0x56) ),
+	( 'P+', ('USB', 0x57) ), ( 'KEYPAD PLUS', ('USB', 0x57) ),
+	( 'PENTER', ('USB', 0x58) ), ( 'KEYPAD ENTER', ('USB', 0x58) ),
+	( 'P1', ('USB', 0x59) ), ( 'KEYPAD 1', ('USB', 0x59) ),
+	( 'P2', ('USB', 0x5A) ), ( 'KEYPAD 2', ('USB', 0x5A) ),
+	( 'P3', ('USB', 0x5B) ), ( 'KEYPAD 3', ('USB', 0x5B) ),
+	( 'P4', ('USB', 0x5C) ), ( 'KEYPAD 4', ('USB', 0x5C) ),
+	( 'P5', ('USB', 0x5D) ), ( 'KEYPAD 5', ('USB', 0x5D) ),
+	( 'P6', ('USB', 0x5E) ), ( 'KEYPAD 6', ('USB', 0x5E) ),
+	( 'P7', ('USB', 0x5F) ), ( 'KEYPAD 7', ('USB', 0x5F) ),
+	( 'P8', ('USB', 0x60) ), ( 'KEYPAD 8', ('USB', 0x60) ),
+	( 'P9', ('USB', 0x61) ), ( 'KEYPAD 9', ('USB', 0x61) ),
+	( 'P0', ('USB', 0x62) ), ( 'KEYPAD 0', ('USB', 0x62) ),
+	( 'P.', ('USB', 0x63) ), ( 'KEYPAD PERIOD', ('USB', 0x63) ),
+	( 'ISO/', ('USB', 0x64) ), ( 'ISO SLASH', ('USB', 0x64) ),
+	( 'APP', ('USB', 0x65) ),
+
+	( 'P=', ('USB', 0x67) ), ( 'KEYPAD EQUAL', ('USB', 0x67) ),
+	( 'F13', ('USB', 0x68) ),
+	( 'F14', ('USB', 0x69) ),
+	( 'F15', ('USB', 0x6A) ),
+	( 'F16', ('USB', 0x6B) ),
+	( 'F17', ('USB', 0x6C) ),
+	( 'F18', ('USB', 0x6D) ),
+	( 'F19', ('USB', 0x6E) ),
+	( 'F20', ('USB', 0x6F) ),
+	( 'F21', ('USB', 0x70) ),
+	( 'F22', ('USB', 0x71) ),
+	( 'F23', ('USB', 0x72) ),
+	( 'F24', ('USB', 0x73) ),
+	( 'EXEC', ('USB', 0x74) ),
+	( 'HELP', ('USB', 0x75) ),
+	( 'MENU', ('USB', 0x76) ),
+	( 'SELECT', ('USB', 0x77) ),
+	( 'STOP', ('USB', 0x78) ),
+	( 'AGAIN', ('USB', 0x79) ),
+	( 'UNDO', ('USB', 0x7A) ),
+	( 'CUT', ('USB', 0x7B) ),
+	( 'COPY', ('USB', 0x7C) ),
+	( 'PASTE', ('USB', 0x7D) ),
+	( 'FIND', ('USB', 0x7E) ),
+	( 'MUTE', ('USB', 0x7F) ),
+	( 'VOLUMEUP', ('USB', 0x80) ), ( 'VOLUME UP', ('USB', 0x80) ),
+	( 'VOLUMEDOWN', ('USB', 0x81) ), ( 'VOLUME DOWN', ('USB', 0x81) ),
+	( 'CAPSTOGGLELOCK', ('USB', 0x82) ), ( 'CAPS TOGGLE LOCK', ('USB', 0x82) ),
+	( 'NUMTOGGLELOCK', ('USB', 0x83) ), ( 'NUM TOGGLE LOCK', ('USB', 0x83) ),
+	( 'SCROLLTOGGLELOCK', ('USB', 0x84) ), ( 'SCROLL TOGGLE LOCK', ('USB', 0x84) ),
+	( 'P,', ('USB', 0x85) ),
+	( 'KEYPAD AS400 EQUAL', ('USB', 0x86) ),
+	( 'INTER1', ('USB', 0x87) ), ( 'KANJI1', ('USB', 0x87) ),
+	( 'INTER2', ('USB', 0x88) ), ( 'KANJI2', ('USB', 0x88) ), ( 'KANA', ('USB', 0x88) ), ( 'カナ', ('USB', 0x88) ),
+	( 'INTER3', ('USB', 0x89) ), ( 'KANJI3', ('USB', 0x89) ), ( 'YEN', ('USB', 0x89) ), ( '¥', ('USB', 0x89) ),
+	( 'INTER4', ('USB', 0x8A) ), ( 'KANJI4', ('USB', 0x8A) ), ( 'HENKAN', ('USB', 0x8A) ), ( '変換', ('USB', 0x8A) ),
+	( 'INTER5', ('USB', 0x8B) ), ( 'KANJI5', ('USB', 0x8B) ), ( 'MUHENKAN', ('USB', 0x8B) ), ( '無変換', ('USB', 0x8B) ),
+	( 'INTER6', ('USB', 0x8C) ), ( 'KANJI6', ('USB', 0x8C) ),
+	( 'INTER7', ('USB', 0x8D) ), ( 'KANJI7', ('USB', 0x8D) ), ( 'BYTETOGGLE', ('USB', 0x8D) ),
+	( 'INTER8', ('USB', 0x8E) ), ( 'KANJI8', ('USB', 0x8E) ),
+	( 'INTER9', ('USB', 0x8F) ), ( 'KANJI9', ('USB', 0x8F) ),
+	( 'LANG1', ('USB', 0x90) ), ( 'HANGULENGLISH', ('USB', 0x90) ), ( 'HANGUL ENGLISH', ('USB', 0x90) ), ( '한/영', ('USB', 0x90) ),
+	( 'LANG2', ('USB', 0x91) ), ( 'HANJA', ('USB', 0x91) ), ( 'EISU', ('USB', 0x91) ), ( '英数/한자', ('USB', 0x91) ),
+	( 'LANG3', ('USB', 0x92) ), ( 'KATAKANA', ('USB', 0x92) ), ( 'カタカナ', ('USB', 0x92) ),
+	( 'LANG4', ('USB', 0x93) ), ( 'HIRAGANA', ('USB', 0x93) ), ( 'ひらがな', ('USB', 0x92) ),
+	( 'LANG5', ('USB', 0x94) ), ( 'ZENKAKUHANKAKU', ('USB', 0x94) ), ( 'ZENKAKU HANKAKU', ('USB', 0x94) ), ( '半角/全角', ('USB', 0x94) ),
+	( 'LANG6', ('USB', 0x95) ),
+	( 'LANG7', ('USB', 0x96) ),
+	( 'LANG8', ('USB', 0x97) ),
+	( 'LANG9', ('USB', 0x98) ),
+	( 'ALTERASE', ('USB', 0x99) ), ( 'ALT ERASE', ('USB', 0x99) ),
+	( 'SYSREQATT', ('USB', 0x9A) ), ( 'SYSREQ', ('USB', 0x9A) ), ( 'SYSTEM REQUEST', ('USB', 0x9A) ),
+	( 'CANCEL', ('USB', 0x9B) ),
+	( 'CLEAR', ('USB', 0x9C) ),
+	( 'PRIOR', ('USB', 0x9D) ),
+	( 'RETURN', ('USB', 0x9E) ),
+	( 'SEP', ('USB', 0x9F) ), ( 'SEPARATOR', ('USB', 0x9F) ),
+	( 'OUT', ('USB', 0xA0) ),
+	( 'OPER', ('USB', 0xA1) ),
+	( 'CLEAR AGAIN', ('USB', 0xA2) ),
+	( 'CRSEL PROPS', ('USB', 0xA3) ),
+	( 'EXSEL', ('USB', 0xA4) ),
+
+	( 'P00', ('USB', 0xB0) ), ( 'KEYPAD 00', ('USB', 0xB0) ),
+	( 'P000', ('USB', 0xB1) ), ( 'KEYPAD 000', ('USB', 0xB1) ),
+	( '1000SEP', ('USB', 0xB2) ), ( 'THOUSANDSEPARATOR', ('USB', 0xB2) ), ( 'THOUSAND SEPARATOR', ('USB', 0xB2) ),
+	( 'DECIMALSEP', ('USB', 0xB3) ), ( 'DECIMALSEPARATOR', ('USB', 0xB3) ), ( 'DECIMAL SEPARATOR', ('USB', 0xB3) ),
+	( 'CURRENCY', ('USB', 0xB4) ), ( 'CURRENCYUNIT', ('USB', 0xB4) ), ( 'CURRENCY UNIT', ('USB', 0xB4) ),
+	( 'CURRENCYSUB', ('USB', 0xB5) ), ( 'CURRENCYSUBUNIT', ('USB', 0xB5) ), ( 'CURRENCY SUB UNIT', ('USB', 0xB5) ),
+	( 'P(', ('USB', 0xB6) ), ( 'KEYPAD LEFT PARENTHESES', ('USB', 0xB6) ),
+	( 'P)', ('USB', 0xB7) ), ( 'KEYPAD RIGHT PARENTHESES', ('USB', 0xB7) ),
+	( 'P{', ('USB', 0xB8) ), ( 'KEYPAD LEFT BRACE', ('USB', 0xB8) ),
+	( 'P}', ('USB', 0xB9) ), ( 'KEYPAD RIGHT BRACE', ('USB', 0xB9) ),
+	( 'PTAB', ('USB', 0xBA) ), ( 'KEYPAD TAB', ('USB', 0xBA) ),
+	( 'PBACKSPACE', ('USB', 0xBB) ), ( 'KEYPAD BACKSPACE', ('USB', 0xBB) ),
+	( 'PA', ('USB', 0xBC) ), ( 'KEYPAD A', ('USB', 0xBC) ),
+	( 'PB', ('USB', 0xBD) ), ( 'KEYPAD B', ('USB', 0xBD) ),
+	( 'PC', ('USB', 0xBE) ), ( 'KEYPAD C', ('USB', 0xBE) ),
+	( 'PD', ('USB', 0xBF) ), ( 'KEYPAD D', ('USB', 0xBF) ),
+	( 'PE', ('USB', 0xC0) ), ( 'KEYPAD E', ('USB', 0xC0) ),
+	( 'PF', ('USB', 0xC1) ), ( 'KEYPAD F', ('USB', 0xC1) ),
+	( 'PXOR', ('USB', 0xC2) ), ( 'KEYPAD XOR', ('USB', 0xC2) ),
+	( 'P^', ('USB', 0xC3) ), ( 'KEYPAD CHEVRON', ('USB', 0xC3) ),
+	( 'P%', ('USB', 0xC4) ), ( 'KEYPAD PERCENT', ('USB', 0xC4) ),
+	( 'P<', ('USB', 0xC5) ), ( 'KEYPAD LESSTHAN', ('USB', 0xC5) ), ( 'KEYPAD LESS THAN', ('USB', 0xC5) ),
+	( 'P>', ('USB', 0xC6) ), ( 'KEYPAD GREATERTHAN', ('USB', 0xC6) ), ( 'KEYPAD GREATER THAN', ('USB', 0xC6) ),
+	( 'P&', ('USB', 0xC7) ), ( 'KEYPAD BITAND', ('USB', 0xC7) ), ( 'KEYPAD BIT AND', ('USB', 0xC7) ),
+	( 'P&&', ('USB', 0xC8) ), ( 'KEYPAD AND', ('USB', 0xC8) ),
+	( 'P|', ('USB', 0xC9) ), ( 'KEYPAD BITOR', ('USB', 0xC9) ), ( 'KEYPAD BIT OR', ('USB', 0xC9) ),
+	( 'P||', ('USB', 0xCA) ), ( 'KEYPAD OR', ('USB', 0xCA) ),
+	( 'P:', ('USB', 0xCB) ), ( 'KEYPAD COLON', ('USB', 0xCB) ),
+	( 'P#', ('USB', 0xCC) ), ( 'KEYPAD NUMBER', ('USB', 0xCC) ), ( 'KEYPAD HASH', ('USB', 0xCC) ),
+	( 'PSPACE', ('USB', 0xCD) ), ( 'KEYPAD SPACE', ('USB', 0xCD) ),
+	( 'P@', ('USB', 0xCE) ), ( 'KEYPAD AT', ('USB', 0xCE) ),
+	( 'P!', ('USB', 0xCF) ), ( 'KEYPAD EXCLAIM', ('USB', 0xCF) ),
+	( 'PMEMSTORE', ('USB', 0xD0) ), ( 'KEYPAD MEMSTORE', ('USB', 0xD0) ), ( 'KEYPAD MEMORY STORE', ('USB', 0xD0) ),
+	( 'PMEMRECALL', ('USB', 0xD1) ), ( 'KEYPAD MEMRECALL', ('USB', 0xD1) ), ( 'KEYPAD MEMORY RECALL', ('USB', 0xD1) ),
+	( 'PMEMCLEAR', ('USB', 0xD2) ), ( 'KEYPAD MEMCLEAR', ('USB', 0xD2) ), ( 'KEYPAD MEMORY CLEAR', ('USB', 0xD2) ),
+	( 'PMEMADD', ('USB', 0xD3) ), ( 'KEYPAD MEMADD', ('USB', 0xD3) ), ( 'KEYPAD MEMORY ADD', ('USB', 0xD3) ),
+	( 'PMEMSUB', ('USB', 0xD4) ), ( 'KEYPAD MEMSUB', ('USB', 0xD4) ), ( 'KEYPAD MEMORY SUB', ('USB', 0xD4) ),
+	( 'PMEMMULT', ('USB', 0xD5) ), ( 'KEYPAD MEMMULT', ('USB', 0xD5) ), ( 'KEYPAD MEMORY MULTIPLY', ('USB', 0xD5) ),
+	( 'PMEMDIV', ('USB', 0xD6) ), ( 'KEYPAD MEMDIV', ('USB', 0xD6) ), ( 'KEYPAD MEMORY DIVIDE', ('USB', 0xD6) ),
+	( 'P+/-', ('USB', 0xD7) ), ( 'KEYPAD PLUSMINUS', ('USB', 0xD7) ), ( 'KEYPAD PLUS MINUS', ('USB', 0xD7) ),
+	( 'PCLEAR', ('USB', 0xD8) ), ( 'KEYPAD CLEAR', ('USB', 0xD8) ),
+	( 'PCLEARENTRY', ('USB', 0xD9) ), ( 'KEYPAD CLEARENTRY', ('USB', 0xD9) ), ( 'KEYPAD CLEAR ENTRY', ('USB', 0xD9) ),
+	( 'PBINARY', ('USB', 0xDA) ), ( 'KEYPAD BINARY', ('USB', 0xDA) ),
+	( 'POCTAL', ('USB', 0xDB) ), ( 'KEYPAD OCTAL', ('USB', 0xDB) ),
+	( 'PDECIMAL', ('USB', 0xDC) ), ( 'KEYPAD DECIMAL', ('USB', 0xDC) ),
+	( 'PHEX', ('USB', 0xDD) ), ( 'KEYPAD HEX', ('USB', 0xDD) ),
+
+	( 'LCTRL', ('USB', 0xE0) ), ( 'LEFT CTRL', ('USB', 0xE0) ), ( 'CTRL', ('USB', 0xE0) ), ( 'CONTROL', ('USB', 0xE0) ), ( 'LEFT CONTROL', ('USB', 0xE0) ),
+	( 'LSHIFT', ('USB', 0xE1) ), ( 'LEFT SHIFT', ('USB', 0xE1) ), ( 'SHIFT', ('USB', 0xE1) ),
+	( 'LALT', ('USB', 0xE2) ), ( 'LEFT ALT', ('USB', 0xE2) ), ( 'ALT', ('USB', 0xE2) ), ( 'ALTERNATE', ('USB', 0xE2) ), ( 'LEFT ALTERNATE', ('USB', 0xE2) ),
+	( 'LGUI', ('USB', 0xE3) ), ( 'LEFT GUI', ('USB', 0xE3) ), ( 'GUI', ('USB', 0xE3) ), ( 'SUPER', ('USB', 0xE3) ), ( 'LEFT SUPER', ('USB', 0xE3) ), ( 'WINDOWS', ('USB', 0xE3) ), ( 'LEFT WINDOWS', ('USB', 0xE3) ), ( 'WIN', ('USB', 0xE3) ), ( 'LEFT WIN', ('USB', 0xE3) ),
+	( 'RCTRL', ('USB', 0xE4) ), ( 'RIGHT CTRL', ('USB', 0xE4) ), ( 'RIGHT CONTROL', ('USB', 0xE4) ),
+	( 'RSHIFT', ('USB', 0xE5) ), ( 'RIGHT SHIFT', ('USB', 0xE5) ),
+	( 'RALT', ('USB', 0xE6) ), ( 'RIGHT ALT', ('USB', 0xE6) ), ( 'RIGHT ALTERNATE', ('USB', 0xE6) ),
+	( 'RGUI', ('USB', 0xE7) ), ( 'RIGHT GUI', ('USB', 0xE7) ), ( 'RIGHT SUPER', ('USB', 0xE7) ), ( 'RIGHT WINDOWS', ('USB', 0xE7) ), ( 'RIGHT WIN', ('USB', 0xE7) ),
+
+# Special Function Shift/Lock/Latch symbolic names (not part of the USB HID spec)
+	( 'FUN1', ('USB', 0xF0) ), ( 'FUNCTION1', ('USB', 0xF0) ), ( 'FUN', ('USB', 0xF0) ),
+	( 'FUN2', ('USB', 0xF1) ), ( 'FUNCTION2', ('USB', 0xF1) ),
+	( 'FUN3', ('USB', 0xF2) ), ( 'FUNCTION3', ('USB', 0xF2) ),
+	( 'FUN4', ('USB', 0xF3) ), ( 'FUNCTION4', ('USB', 0xF3) ),
+	( 'FUN5', ('USB', 0xF4) ), ( 'FUNCTION5', ('USB', 0xF4) ),
+	( 'FUN6', ('USB', 0xF5) ), ( 'FUNCTION6', ('USB', 0xF5) ),
+	( 'FUN7', ('USB', 0xF6) ), ( 'FUNCTION7', ('USB', 0xF6) ),
+	( 'FUN8', ('USB', 0xF7) ), ( 'FUNCTION8', ('USB', 0xF7) ),
+	( 'FUN9', ('USB', 0xF8) ), ( 'FUNCTION9', ('USB', 0xF8) ),
+	( 'FUN10', ('USB', 0xF9) ), ( 'FUNCTION10', ('USB', 0xF9) ),
+	( 'FUN11', ('USB', 0xFA) ), ( 'FUNCTION11', ('USB', 0xFA) ),
+	( 'FUN12', ('USB', 0xFB) ), ( 'FUNCTION12', ('USB', 0xFB) ),
+	( 'FUN13', ('USB', 0xFC) ), ( 'FUNCTION13', ('USB', 0xFC) ),
+	( 'FUN14', ('USB', 0xFD) ), ( 'FUNCTION14', ('USB', 0xFD) ),
+	( 'FUN15', ('USB', 0xFE) ), ( 'FUNCTION15', ('USB', 0xFE) ),
+	( 'FUN16', ('USB', 0xFF) ), ( 'FUNCTION16', ('USB', 0xFF) ),
+	( 'LCK1', ('USB', 0x100) ), ( 'LOCK1', ('USB', 0x100) ), ( 'LCK', ('USB', 0x100) ),
+	( 'LCK2', ('USB', 0x101) ), ( 'LOCK2', ('USB', 0x101) ),
+	( 'LCK3', ('USB', 0x102) ), ( 'LOCK3', ('USB', 0x102) ),
+	( 'LCK4', ('USB', 0x103) ), ( 'LOCK4', ('USB', 0x103) ),
+	( 'LCK5', ('USB', 0x104) ), ( 'LOCK5', ('USB', 0x104) ),
+	( 'LCK6', ('USB', 0x105) ), ( 'LOCK6', ('USB', 0x105) ),
+	( 'LCK7', ('USB', 0x106) ), ( 'LOCK7', ('USB', 0x106) ),
+	( 'LCK8', ('USB', 0x107) ), ( 'LOCK8', ('USB', 0x107) ),
+	( 'LCK9', ('USB', 0x108) ), ( 'LOCK9', ('USB', 0x108) ),
+	( 'LCK10', ('USB', 0x109) ), ( 'LOCK10', ('USB', 0x109) ),
+	( 'LCK11', ('USB', 0x10A) ), ( 'LOCK11', ('USB', 0x10A) ),
+	( 'LCK12', ('USB', 0x10B) ), ( 'LOCK12', ('USB', 0x10B) ),
+	( 'LCK13', ('USB', 0x10C) ), ( 'LOCK13', ('USB', 0x10C) ),
+	( 'LCK14', ('USB', 0x10D) ), ( 'LOCK14', ('USB', 0x10D) ),
+	( 'LCK15', ('USB', 0x10E) ), ( 'LOCK15', ('USB', 0x10E) ),
+	( 'LCK16', ('USB', 0x10F) ), ( 'LOCK16', ('USB', 0x10F) ),
+	( 'LAT1', ('USB', 0x110) ), ( 'LATCH1', ('USB', 0x110) ), ( 'LAT', ('USB', 0x110) ),
+	( 'LAT2', ('USB', 0x111) ), ( 'LATCH2', ('USB', 0x111) ),
+	( 'LAT3', ('USB', 0x112) ), ( 'LATCH3', ('USB', 0x112) ),
+	( 'LAT4', ('USB', 0x113) ), ( 'LATCH4', ('USB', 0x113) ),
+	( 'LAT5', ('USB', 0x114) ), ( 'LATCH5', ('USB', 0x114) ),
+	( 'LAT6', ('USB', 0x115) ), ( 'LATCH6', ('USB', 0x115) ),
+	( 'LAT7', ('USB', 0x116) ), ( 'LATCH7', ('USB', 0x116) ),
+	( 'LAT8', ('USB', 0x117) ), ( 'LATCH8', ('USB', 0x117) ),
+	( 'LAT9', ('USB', 0x118) ), ( 'LATCH9', ('USB', 0x118) ),
+	( 'LAT10', ('USB', 0x119) ), ( 'LATCH10', ('USB', 0x119) ),
+	( 'LAT11', ('USB', 0x11A) ), ( 'LATCH11', ('USB', 0x11A) ),
+	( 'LAT12', ('USB', 0x11B) ), ( 'LATCH12', ('USB', 0x11B) ),
+	( 'LAT13', ('USB', 0x11C) ), ( 'LATCH13', ('USB', 0x11C) ),
+	( 'LAT14', ('USB', 0x11D) ), ( 'LATCH14', ('USB', 0x11D) ),
+	( 'LAT15', ('USB', 0x11E) ), ( 'LATCH15', ('USB', 0x11E) ),
+	( 'LAT16', ('USB', 0x11F) ), ( 'LATCH16', ('USB', 0x11F) ),
+	( 'NLAYER', ('USB', 0x120) ), ( 'NEXT LAYER', ('USB', 0x120) ),
+	( 'PLAYER', ('USB', 0x121) ), ( 'PREV LAYER', ('USB', 0x121) ),
+])
+
+
+	# USB HID LED Codes
+kll_hid_lookup_dictionary['IndCode'] = dict([
+	( 'UNDEFINED', ('IND', 0x00) ),
+	( 'NUMLOCK', ('IND', 0x01) ),
+	( 'CAPSLOCK', ('IND', 0x02) ),
+	( 'SCROLLLOCK', ('IND', 0x03) ),
+	( 'COMPOSE', ('IND', 0x04) ),
+	( 'KANA', ('IND', 0x05) ),
+	( 'POWER', ('IND', 0x06) ),
+	( 'SHIFT', ('IND', 0x07) ),
+	( 'DONOT_DISTURB', ('IND', 0x08) ),
+	( 'MUTE', ('IND', 0x09) ),
+	( 'TONEENABLE', ('IND', 0x0A) ),
+	( 'HIGHCUTFILTER', ('IND', 0x0B) ),
+	( 'LOWCUTFILTER', ('IND', 0x0C) ),
+	( 'EQLENABLE', ('IND', 0x0D) ),
+	( 'SNDFLD_ON', ('IND', 0x0E) ),
+	( 'SURROUNDON', ('IND', 0x0F) ),
+	( 'REPEAT', ('IND', 0x10) ),
+	( 'STEREO', ('IND', 0x11) ),
+	( 'SAMPLERT_DET', ('IND', 0x12) ),
+	( 'SPINNING', ('IND', 0x13) ),
+	( 'CAV', ('IND', 0x14) ),
+	( 'CLV', ('IND', 0x15) ),
+	( 'RECFMT_DET', ('IND', 0x16) ),
+	( 'OFFHOOK', ('IND', 0x17) ),
+	( 'RING', ('IND', 0x18) ),
+	( 'MSGWAITING', ('IND', 0x19) ),
+	( 'DATAMODE', ('IND', 0x1A) ),
+	( 'BATOPERATION', ('IND', 0x1B) ),
+	( 'BATOK', ('IND', 0x1C) ),
+	( 'BATLOW', ('IND', 0x1D) ),
+	( 'SPEAKER', ('IND', 0x1E) ),
+	( 'HEADSET', ('IND', 0x1F) ),
+	( 'HOLD', ('IND', 0x20) ),
+	( 'MICROPHONE', ('IND', 0x21) ),
+	( 'COVERAGE', ('IND', 0x22) ),
+	( 'NIGHTMODE', ('IND', 0x23) ),
+	( 'SENDCALLS', ('IND', 0x24) ),
+	( 'CALLPICKUP', ('IND', 0x25) ),
+	( 'CONFERENCE', ('IND', 0x26) ),
+	( 'STANDBY', ('IND', 0x27) ),
+	( 'CAMERAON', ('IND', 0x28) ),
+	( 'CAMERAOFF', ('IND', 0x29) ),
+	( 'ONLINE', ('IND', 0x2A) ),
+	( 'OFFLINE', ('IND', 0x2B) ),
+	( 'BUSY', ('IND', 0x2C) ),
+	( 'READY', ('IND', 0x2D) ),
+	( 'PAPEROUT', ('IND', 0x2E) ),
+	( 'PAPERJAM', ('IND', 0x2F) ),
+	( 'REMOTE', ('IND', 0x30) ),
+	( 'FORWARD', ('IND', 0x31) ),
+	( 'REVERSE', ('IND', 0x32) ),
+	( 'STOP', ('IND', 0x33) ),
+	( 'REWIND', ('IND', 0x34) ),
+	( 'FASTFORWARD', ('IND', 0x35) ),
+	( 'PLAY', ('IND', 0x36) ),
+	( 'PAUSE', ('IND', 0x37) ),
+	( 'RECORD', ('IND', 0x38) ),
+	( 'ERROR', ('IND', 0x39) ),
+	( 'USI', ('IND', 0x3A) ),
+	( 'UIUI', ('IND', 0x3B) ),
+	( 'UMMI', ('IND', 0x3C) ),
+	( 'INDON', ('IND', 0x3D) ),
+	( 'INDFLASH', ('IND', 0x3E) ),
+	( 'INDSLOW_BLNK', ('IND', 0x3F) ),
+	( 'INDFAST_BLNK', ('IND', 0x40) ),
+	( 'INDOFF', ('IND', 0x41) ),
+	( 'FLASHON_TIME', ('IND', 0x42) ),
+	( 'SLWB_ON_TIME', ('IND', 0x43) ),
+	( 'SLWB_OFF_TIME', ('IND', 0x44) ),
+	( 'FSTB_ON_TIME', ('IND', 0x45) ),
+	( 'FSTB_OFF_TIME', ('IND', 0x46) ),
+	( 'UIC', ('IND', 0x47) ),
+	( 'INDRED', ('IND', 0x48) ),
+	( 'INDGREEN', ('IND', 0x49) ),
+	( 'INDAMBER', ('IND', 0x4A) ),
+	( 'GENERICIND', ('IND', 0x4B) ),
+	( 'SYSSUSPEND', ('IND', 0x4C) ),
+	( 'EXTPWR_CONN', ('IND', 0x4D) ),
+# 0x4E - 0xFFFF Reserved
+])
+
+
+# List of System Controls - USB HID 1.12v2 pg 32
+# NKRO HID Supports 0x81 - 0xB7
+kll_hid_lookup_dictionary['SysCode'] = dict([
+	( 'POWERDOWN', ('SYS', 0x81) ),
+	( 'SLEEP', ('SYS', 0x82) ),
+	( 'WAKEUP', ('SYS', 0x83) ),
+	( 'CONTEXTMENU', ('SYS', 0x84) ),
+	( 'MAINMENU', ('SYS', 0x85) ),
+	( 'APPMENU', ('SYS', 0x86) ),
+	( 'MENUHELP', ('SYS', 0x87) ),
+	( 'MENUEXIT', ('SYS', 0x88) ),
+	( 'MENUSELECT', ('SYS', 0x89) ),
+	( 'MENURIGHT', ('SYS', 0x8A) ),
+	( 'MENULEFT', ('SYS', 0x8B) ),
+	( 'MENUUP', ('SYS', 0x8C) ),
+	( 'MENUDOWN', ('SYS', 0x8D) ),
+	( 'COLDRESTART', ('SYS', 0x8E) ),
+	( 'WARMRESTART', ('SYS', 0x8F) ),
+	( 'DPADUP', ('SYS', 0x90) ),
+	( 'DPADDOWN', ('SYS', 0x91) ),
+	( 'DPADRIGHT', ('SYS', 0x92) ),
+	( 'DPADLEFT', ('SYS', 0x93) ),
+# 0x94 - 0x9F Reserved
+	( 'DOCK', ('SYS', 0xA0) ),
+	( 'UNDOCK', ('SYS', 0xA1) ),
+	( 'SETUP', ('SYS', 0xA2) ),
+	( 'BREAK', ('SYS', 0xA3) ),
+	( 'DEBUGGERBREAK', ('SYS', 0xA4) ),
+	( 'APPBREAK', ('SYS', 0xA5) ),
+	( 'APPDEBUGGER_BREAK', ('SYS', 0xA6) ),
+	( 'SPEAKERMUTE', ('SYS', 0xA7) ),
+	( 'HIBERNATE', ('SYS', 0xA8) ),
+# 0xA9 - 0xAF Reserved
+	( 'DISPINVERT', ('SYS', 0xB0) ),
+	( 'DISPINTERNAL', ('SYS', 0xB1) ),
+	( 'DISPEXTERNAL', ('SYS', 0xB2) ),
+	( 'DISPBOTH', ('SYS', 0xB3) ),
+	( 'DISPDUAL', ('SYS', 0xB4) ),
+	( 'DISPTOGGLE_INT_EXT', ('SYS', 0xB5) ),
+	( 'DISPSWAP_PRI_SEC', ('SYS', 0xB6) ),
+	( 'DISPLCD_AUTOSCALE', ('SYS', 0xB7) ),
+# 0xB8 - 0xFFFF Reserved
+])
+
+
+	# USB HID Consumer Control Codes
+# List of Consumer Codes - USB HID 1.12v2
+# Only listing relevant ones, let me know if you need more -HaaTa
+# NKRO HID Supports 0x020 - 0x29C
+kll_hid_lookup_dictionary['ConsCode'] = dict([
+	( '10', ('CONS', 0x020) ),
+	( '100', ('CONS', 0x021) ),
+	( 'AMPM', ('CONS', 0x022) ),
+# 0x023 - 0x03F Reserved
+	( 'POWER', ('CONS', 0x030) ),
+	( 'RESET', ('CONS', 0x031) ),
+	( 'SLEEP', ('CONS', 0x032) ),
+	( 'SLEEPAFTER', ('CONS', 0x033) ),
+	( 'SLEEPMODE', ('CONS', 0x034) ),
+	( 'ILLUMINATION', ('CONS', 0x035) ),
+
+# 0x037 - 0x03F Reserved
+	( 'MENU', ('CONS', 0x040) ),
+	( 'MENUPICK', ('CONS', 0x041) ),
+	( 'MENUUP', ('CONS', 0x042) ),
+	( 'MENUDOWN', ('CONS', 0x043) ),
+	( 'MENULEFT', ('CONS', 0x044) ),
+	( 'MENURIGHT', ('CONS', 0x045) ),
+	( 'MENUESCAPE', ('CONS', 0x046) ),
+	( 'MENUVALUE_INCREASE', ('CONS', 0x047) ),
+	( 'MENUVALUE_DECREASE', ('CONS', 0x048) ),
+# 0x049 - 0x05F Reserved
+	( 'DATAON_SCREEN', ('CONS', 0x060) ),
+	( 'CLOSEDCAPTION', ('CONS', 0x061) ),
+	( 'CLOSEDCAPTION_SELECT', ('CONS', 0x062) ),
+	( 'VCRTV', ('CONS', 0x063) ),
+	( 'BROADCASTMODE', ('CONS', 0x064) ),
+	( 'SNAPSHOT', ('CONS', 0x065) ),
+	( 'STILL', ('CONS', 0x066) ),
+# 0x067 - 0x06E Reserved?
+	( 'BRIGHTNESSINCREMENT', ('CONS', 0x06F) ),
+	( 'BRIGHTNESSDECREMENT', ('CONS', 0x070) ),
+
+	( 'BACKLIGHTTOGGLE', ('CONS', 0x072) ),
+	( 'BRIGHTNESSMIN', ('CONS', 0x073) ),
+	( 'BRIGHTNESSMAX', ('CONS', 0x074) ),
+	( 'BRIGHTNESSAUTO', ('CONS', 0x075) ),
+# 0x076 - 0x07F Reserved
+
+	( 'ASSIGNSELECTION', ('CONS', 0x081) ),
+	( 'MODESTEP', ('CONS', 0x082) ),
+	( 'RECALLLAST', ('CONS', 0x083) ),
+	( 'ENTERCHANNEL', ('CONS', 0x084) ),
+	( 'ORDERMOVIE', ('CONS', 0x085) ),
+
+	( 'MEDIACOMPUTER', ('CONS', 0x088) ),
+	( 'MEDIATV', ('CONS', 0x089) ),
+	( 'MEDIAWWW', ('CONS', 0x08A) ),
+	( 'MEDIADVD', ('CONS', 0x08B) ),
+	( 'MEDIATELEPHONE', ('CONS', 0x08C) ),
+	( 'MEDIAPROGRAM_GUIDE', ('CONS', 0x08D) ),
+	( 'MEDIAVIDEO_PHONE', ('CONS', 0x08E) ),
+	( 'MEDIASELECTGAMES', ('CONS', 0x08F) ),
+	( 'MEDIASELECTMESSAGES', ('CONS', 0x090) ),
+	( 'MEDIASELECTCD', ('CONS', 0x091) ),
+	( 'MEDIASELECTVCR', ('CONS', 0x092) ),
+	( 'MEDIASELECTTUNER', ('CONS', 0x093) ),
+	( 'QUIT', ('CONS', 0x094) ),
+	( 'HELP', ('CONS', 0x095) ),
+	( 'MEDIASELECT_TAPE', ('CONS', 0x096) ),
+	( 'MEDIASELECT_CABLE', ('CONS', 0x097) ),
+	( 'MEDIASELECT_SATELLITE', ('CONS', 0x098) ),
+	( 'MEDIASELECT_SECURITY', ('CONS', 0x099) ),
+	( 'MEDIASELECT_HOME', ('CONS', 0x09A) ),
+	( 'MEDIASELECT_CALL', ('CONS', 0x09B) ),
+	( 'CHANNELINCREMENT', ('CONS', 0x09C) ),
+	( 'CAHNNELDECREMENT', ('CONS', 0x09D) ),
+	( 'MEDIASELECT_SAP', ('CONS', 0x09E) ),
+# 0x09F Reserved
+	( 'VCRPLUS', ('CONS', 0x0A0) ),
+	( 'ONCE', ('CONS', 0x0A1) ),
+	( 'DAILY', ('CONS', 0x0A2) ),
+	( 'WEEKLY', ('CONS', 0x0A3) ),
+	( 'MONTHLY', ('CONS', 0x0A4) ),
+# 0x0A5 - 0x0AF Reserved
+	( 'PLAY', ('CONS', 0x0B0) ),
+	( 'PAUSE', ('CONS', 0x0B1) ),
+	( 'RECORD', ('CONS', 0x0B2) ),
+	( 'FASTFORWARD', ('CONS', 0x0B3) ),
+	( 'REWIND', ('CONS', 0x0B4) ),
+	( 'SCANNEXTTRACK', ('CONS', 0x0B5) ),
+	( 'SCANPREVIOUSTRACK', ('CONS', 0x0B6) ),
+	( 'STOP', ('CONS', 0x0B7) ),
+	( 'EJECT', ('CONS', 0x0B8) ),
+	( 'RANDOMPLAY', ('CONS', 0x0B9) ),
+
+	( 'REPEAT', ('CONS', 0x0BC) ),
+
+	( 'TRACKNORMAL', ('CONS', 0x0BE) ),
+
+	( 'FRAMEFORWARD', ('CONS', 0x0C0) ),
+	( 'FRAMEBACK', ('CONS', 0x0C1) ),
+	( 'MARK', ('CONS', 0x0C2) ),
+	( 'CLEARMARK', ('CONS', 0x0C3) ),
+	( 'REPEATFROM_MARK', ('CONS', 0x0C4) ),
+	( 'RETURNTO_MARK', ('CONS', 0x0C5) ),
+	( 'SEARCHMARK_FORWARDS', ('CONS', 0x0C6) ),
+	( 'SEARCHMARK_BACKWARDS', ('CONS', 0x0C7) ),
+	( 'COUNTERRESET', ('CONS', 0x0C8) ),
+	( 'SHOWCOUNTER', ('CONS', 0x0C9) ),
+	( 'TRACKINGINCREMENT', ('CONS', 0x0CA) ),
+	( 'TRACKINGDECREMENT', ('CONS', 0x0CB) ),
+	( 'STOPEJECT', ('CONS', 0x0CC) ),
+	( 'PAUSEPLAY', ('CONS', 0x0CD) ),
+	( 'PLAYSKIP', ('CONS', 0x0CE) ),
+# 0x0CF - 0x0DF Reserved
+
+	( 'MUTE', ('CONS', 0x0E2) ),
+
+	( 'BASSBOOST', ('CONS', 0x0E5) ),
+	( 'SURROUNDMODE', ('CONS', 0x0E6) ),
+	( 'LOUDNESS', ('CONS', 0x0E7) ),
+	( 'MPX', ('CONS', 0x0E8) ),
+	( 'VOLUMEUP', ('CONS', 0x0E9) ),
+	( 'VOLUMEDOWN', ('CONS', 0x0EA) ),
+# 0x0EB - 0x0EF Reserved
+	( 'SPEEDSELECT', ('CONS', 0x0F0) ),
+	( 'STANDARDPLAY', ('CONS', 0x0F2) ),
+	( 'LONGPLAY', ('CONS', 0x0F3) ),
+	( 'EXTENDEDPLAY', ('CONS', 0x0F4) ),
+	( 'SLOW', ('CONS', 0x0F5) ),
+# 0x0F6 - 0x0FF
+	( 'FANENABLE', ('CONS', 0x100) ),
+
+	( 'LIGHTENABLE', ('CONS', 0x102) ),
+
+	( 'CLIMATECONTROL_ENABLE', ('CONS', 0x104) ),
+
+	( 'SECURITYENABLE', ('CONS', 0x106) ),
+	( 'FIREALARM', ('CONS', 0x107) ),
+
+	( 'MOTION', ('CONS', 0x10A) ),
+	( 'DURESSALARM', ('CONS', 0x10B) ),
+	( 'HOLDUPALARM', ('CONS', 0x10C) ),
+	( 'MEDICALALARM', ('CONS', 0x10D) ),
+# 0x10E - 0x14F Reserved
+	( 'BALANCERIGHT', ('CONS', 0x150) ),
+	( 'BALANCELEFT', ('CONS', 0x151) ),
+	( 'BASSINCR', ('CONS', 0x152) ),
+	( 'BASSDECR', ('CONS', 0x153) ),
+	( 'TREBLEINCR', ('CONS', 0x154) ),
+	( 'TREBLEDECR', ('CONS', 0x155) ),
+# 0x156 - 0x15F Reserved
+
+	( 'SUBCHANNEL_INCREMENT', ('CONS', 0x171) ),
+	( 'SUBCHANNEL_DECREMENT', ('CONS', 0x172) ),
+	( 'ALTAUDIO_INCREMENT', ('CONS', 0x173) ),
+	( 'ALTAUDIO_DECREMENT', ('CONS', 0x174) ),
+
+
+# List of Consumer Codes - USB HID 1.12v2
+# Application Launch Buttons pg 79
+	( 'LAUNCHBUTTON_CONFIG_TOOL', ('CONS', 0x181) ),
+	( 'PROGRAMMABLEBUTTON_CONFIG', ('CONS', 0x182) ),
+	( 'CONSUMERCONTROL_CONFIG', ('CONS', 0x183) ),
+	( 'WORDPROCESSOR', ('CONS', 0x184) ),
+	( 'TEXTEDITOR', ('CONS', 0x185) ),
+	( 'SPREADSHEET', ('CONS', 0x186) ),
+	( 'GRAPHICSEDITOR', ('CONS', 0x187) ),
+	( 'PRESENTATIONAPP', ('CONS', 0x188) ),
+	( 'DATABASEAPP', ('CONS', 0x189) ),
+	( 'EMAILREADER', ('CONS', 0x18A) ),
+	( 'NEWSREADER', ('CONS', 0x18B) ),
+	( 'VOICEMAIL', ('CONS', 0x18C) ),
+	( 'CONTACTSADDRESS_BOOK', ('CONS', 0x18D) ),
+	( 'CALENDARSCHEDULE', ('CONS', 0x18E) ),
+	( 'TASKPROJECT_MANAGER', ('CONS', 0x18F) ),
+	( 'LOGJOURNAL_TIMECARD', ('CONS', 0x190) ),
+	( 'CHECKBOOKFINANCE', ('CONS', 0x191) ),
+	( 'CALCULATOR', ('CONS', 0x192) ),
+	( 'AV_CAPTURE_PLAYBACK', ('CONS', 0x193) ),
+	( 'LOCALMACHINE_BROWSER', ('CONS', 0x194) ),
+	( 'LANWAN_BROWSER', ('CONS', 0x195) ),
+	( 'INTERNETBROWSER', ('CONS', 0x196) ),
+	( 'REMOTENETWORKING_ISP_CONNECT', ('CONS', 0x197) ),
+	( 'NETWORKCONFERENCE', ('CONS', 0x198) ),
+	( 'NETWORKCHAT', ('CONS', 0x199) ),
+	( 'TELEPHONYDIALER', ('CONS', 0x19A) ),
+	( 'LOGON', ('CONS', 0x19B) ),
+	( 'LOGOFF', ('CONS', 0x19C) ),
+	( 'LOGONLOGOFF', ('CONS', 0x19D) ),
+	( 'TERMINALLOCK_SCREENSAVER', ('CONS', 0x19E) ),
+	( 'CONTROLPANEL', ('CONS', 0x19F) ),
+	( 'COMMANDLINE_PROCESSOR_RUN', ('CONS', 0x1A0) ),
+	( 'PROCESSTASK_MANAGER', ('CONS', 0x1A1) ),
+	( 'SELECTTAST_APP', ('CONS', 0x1A2) ),
+	( 'NEXTTASK_APP', ('CONS', 0x1A3) ),
+	( 'PREVIOUSTASK_APP', ('CONS', 0x1A4) ),
+	( 'PREEMPTIVEHALT_TASK_APP', ('CONS', 0x1A5) ),
+	( 'INTEGRATEDHELP_CENTER', ('CONS', 0x1A6) ),
+	( 'DOCUMENTS', ('CONS', 0x1A7) ),
+	( 'THESAURUS', ('CONS', 0x1A8) ),
+	( 'DICTIONARY', ('CONS', 0x1A9) ),
+	( 'DESKTOP', ('CONS', 0x1AA) ),
+	( 'SPELLCHECK', ('CONS', 0x1AB) ),
+	( 'GRAMMARCHECK', ('CONS', 0x1AC) ),
+	( 'WIRELESSSTATUS', ('CONS', 0x1AD) ),
+	( 'KEYBOARDLAYOUT', ('CONS', 0x1AE) ),
+	( 'VIRUSPROTECTION', ('CONS', 0x1AF) ),
+	( 'ENCRYPTION', ('CONS', 0x1B0) ),
+	( 'SCREENSAVER', ('CONS', 0x1B1) ),
+	( 'ALARMS', ('CONS', 0x1B2) ),
+	( 'CLOCK', ('CONS', 0x1B3) ),
+	( 'FILEBROWSER', ('CONS', 0x1B4) ),
+	( 'POWERSTATUS', ('CONS', 0x1B5) ),
+	( 'IMAGEBROWSER', ('CONS', 0x1B6) ),
+	( 'AUDIOBROWSER', ('CONS', 0x1B7) ),
+	( 'MOVIEBROWSER', ('CONS', 0x1B8) ),
+	( 'DIGITALRIGHTS_MANAGER', ('CONS', 0x1B9) ),
+	( 'DIGITALWALLET', ('CONS', 0x1BA) ),
+# 0x1BB Reserved
+	( 'INSTANTMESSAGING', ('CONS', 0x1BC) ),
+	( 'OEMFEATURES_TIPS_TUTORIAL', ('CONS', 0x1BD) ),
+	( 'OEMHELP', ('CONS', 0x1BE) ),
+	( 'ONLINECOMMUNITY', ('CONS', 0x1BF) ),
+	( 'ENTERTAINMENTCONTENT', ('CONS', 0x1C0) ),
+	( 'ONLINESHOPPING', ('CONS', 0x1C1) ),
+	( 'SMARTCARDINFO_HELP', ('CONS', 0x1C2) ),
+	( 'MARKETMONITOR', ('CONS', 0x1C3) ),
+	( 'CUSTOMIZEDCORP_NEWS', ('CONS', 0x1C4) ),
+	( 'ONLINEACTIVITY', ('CONS', 0x1C5) ),
+	( 'SEARCHBROWSER', ('CONS', 0x1C6) ),
+	( 'AUDIOPLAYER', ('CONS', 0x1C7) ),
+
+
+# List of Consumer Codes - USB HID 1.12v2
+# Generic GUI Application Controls pg 82
+	( 'NEW', ('CONS', 0x201) ),
+	( 'OPEN', ('CONS', 0x202) ),
+	( 'CLOSE', ('CONS', 0x203) ),
+	( 'EXIT', ('CONS', 0x204) ),
+	( 'MAXIMIZE', ('CONS', 0x205) ),
+	( 'MINIMIZE', ('CONS', 0x206) ),
+	( 'SAVE', ('CONS', 0x207) ),
+	( 'PRINT', ('CONS', 0x208) ),
+	( 'PROPERTIES', ('CONS', 0x209) ),
+	( 'UNDO', ('CONS', 0x21A) ),
+	( 'COPY', ('CONS', 0x21B) ),
+	( 'CUT', ('CONS', 0x21C) ),
+	( 'PASTE', ('CONS', 0x21D) ),
+	( 'SELECTALL', ('CONS', 0x21E) ),
+	( 'FIND', ('CONS', 0x21F) ),
+	( 'FINDANDREPLACE', ('CONS', 0x220) ),
+	( 'SEARCH', ('CONS', 0x221) ),
+	( 'GOTO', ('CONS', 0x222) ),
+	( 'HOME', ('CONS', 0x223) ),
+	( 'BACK', ('CONS', 0x224) ),
+	( 'FORWARD', ('CONS', 0x225) ),
+	( 'STOP', ('CONS', 0x226) ),
+	( 'REFRESH', ('CONS', 0x227) ),
+	( 'PREVIOUSLINK', ('CONS', 0x228) ),
+	( 'NEXTLINK', ('CONS', 0x229) ),
+	( 'BOOKMARKS', ('CONS', 0x22A) ),
+	( 'HISTORY', ('CONS', 0x22B) ),
+	( 'SUBSCRIPTIONS', ('CONS', 0x22C) ),
+	( 'ZOOMIN', ('CONS', 0x22D) ),
+	( 'ZOOMOUT', ('CONS', 0x22E) ),
+	( 'ZOOM', ('CONS', 0x22F) ),
+	( 'FULLSCREEN_VIEW', ('CONS', 0x230) ),
+	( 'NORMALVIEW', ('CONS', 0x231) ),
+	( 'VIEWTOGGLE', ('CONS', 0x232) ),
+	( 'SCROLLUP', ('CONS', 0x233) ),
+	( 'SCROLLDOWN', ('CONS', 0x234) ),
+	( 'SCROLL', ('CONS', 0x235) ),
+	( 'PANLEFT', ('CONS', 0x236) ),
+	( 'PANRIGHT', ('CONS', 0x237) ),
+	( 'PAN', ('CONS', 0x238) ),
+	( 'NEWWINDOW', ('CONS', 0x239) ),
+	( 'TILEHORIZONTALLY', ('CONS', 0x23A) ),
+	( 'TILEVERTICALLY', ('CONS', 0x23B) ),
+	( 'FORMAT', ('CONS', 0x23C) ),
+	( 'EDIT', ('CONS', 0x23D) ),
+	( 'BOLD', ('CONS', 0x23E) ),
+	( 'ITALICS', ('CONS', 0x23F) ),
+	( 'UNDERLINE', ('CONS', 0x240) ),
+	( 'STRIKETHROUGH', ('CONS', 0x241) ),
+	( 'SUBSCRIPT', ('CONS', 0x242) ),
+	( 'SUPERSCRIPT', ('CONS', 0x243) ),
+	( 'ALLCAPS', ('CONS', 0x244) ),
+	( 'ROTATE', ('CONS', 0x245) ),
+	( 'RESIZE', ('CONS', 0x246) ),
+	( 'FILPHORIZONTAL', ('CONS', 0x247) ),
+	( 'FILPVERTICAL', ('CONS', 0x248) ),
+	( 'MIRRORHORIZONTAL', ('CONS', 0x249) ),
+	( 'MIRRORVERTICAL', ('CONS', 0x24A) ),
+	( 'FONTSELECT', ('CONS', 0x24B) ),
+	( 'FONTCOLOR', ('CONS', 0x24C) ),
+	( 'FONTSIZE', ('CONS', 0x24D) ),
+	( 'JUSTIFYLEFT', ('CONS', 0x24E) ),
+	( 'JUSTIFYCENTER_H', ('CONS', 0x24F) ),
+	( 'JUSTIFYRIGHT', ('CONS', 0x250) ),
+	( 'JUSTIFYBLOCK_H', ('CONS', 0x251) ),
+	( 'JUSTIFYTOP', ('CONS', 0x252) ),
+	( 'JUSTIFYCENTER_V', ('CONS', 0x253) ),
+	( 'JUSTIFYBOTTOM', ('CONS', 0x254) ),
+	( 'JUSTIFYBLOCK_V', ('CONS', 0x255) ),
+	( 'INDENTDECREASE', ('CONS', 0x256) ),
+	( 'INDENTINCREASE', ('CONS', 0x257) ),
+	( 'NUMBEREDLIST', ('CONS', 0x258) ),
+	( 'RESTARTNUMBERING', ('CONS', 0x259) ),
+	( 'BULLETEDLIST', ('CONS', 0x25A) ),
+	( 'PROMOTE', ('CONS', 0x25B) ),
+	( 'DEMOTE', ('CONS', 0x25C) ),
+	( 'YES', ('CONS', 0x25D) ),
+	( 'NO', ('CONS', 0x25E) ),
+	( 'CANCEL', ('CONS', 0x25F) ),
+	( 'CATALOG', ('CONS', 0x260) ),
+	( 'BUYCHECKOUT', ('CONS', 0x261) ),
+	( 'ADDTO_CART', ('CONS', 0x262) ),
+	( 'EXPAND', ('CONS', 0x263) ),
+	( 'EXPANDALL', ('CONS', 0x264) ),
+	( 'COLLAPSE', ('CONS', 0x265) ),
+	( 'COLLAPSEALL', ('CONS', 0x266) ),
+	( 'PRINTPREVIEW', ('CONS', 0x267) ),
+	( 'PASTESPECIAL', ('CONS', 0x268) ),
+	( 'INSERTMODE', ('CONS', 0x269) ),
+	( 'DELETE', ('CONS', 0x26A) ),
+	( 'LOCK', ('CONS', 0x26B) ),
+	( 'UNLOCK', ('CONS', 0x26C) ),
+	( 'PROTECT', ('CONS', 0x26D) ),
+	( 'UNPROTECT', ('CONS', 0x26E) ),
+	( 'ATTACHCOMMENT', ('CONS', 0x26F) ),
+	( 'DELETECOMMENT', ('CONS', 0x270) ),
+	( 'VIEWCOMMENT', ('CONS', 0x271) ),
+	( 'SELECTWORD', ('CONS', 0x272) ),
+	( 'SELECTSENTENCE', ('CONS', 0x273) ),
+	( 'SELECTPARAGRAPH', ('CONS', 0x274) ),
+	( 'SELECTCOLUMN', ('CONS', 0x275) ),
+	( 'SELECTROW', ('CONS', 0x276) ),
+	( 'SELECTTABLE', ('CONS', 0x277) ),
+	( 'SELECTOBJECT', ('CONS', 0x278) ),
+	( 'REDOREPEAT', ('CONS', 0x279) ),
+	( 'SORT', ('CONS', 0x27A) ),
+	( 'SORTASCENDING', ('CONS', 0x27B) ),
+	( 'SORTDESCENDING', ('CONS', 0x27C) ),
+	( 'FILTER', ('CONS', 0x27D) ),
+	( 'SETCLOCK', ('CONS', 0x27E) ),
+	( 'VIEWCLOCK', ('CONS', 0x27F) ),
+	( 'SELECTTIME_ZONE', ('CONS', 0x280) ),
+	( 'EDITTIME_ZONE', ('CONS', 0x281) ),
+	( 'SETALARM', ('CONS', 0x282) ),
+	( 'CLEARALARM', ('CONS', 0x283) ),
+	( 'SNOOZEALARM', ('CONS', 0x284) ),
+	( 'RESETALARM', ('CONS', 0x285) ),
+	( 'SYNCHRONIZE', ('CONS', 0x286) ),
+	( 'SENDRECEIVE', ('CONS', 0x287) ),
+	( 'SENDTO', ('CONS', 0x288) ),
+	( 'REPLY', ('CONS', 0x289) ),
+	( 'REPLYALL', ('CONS', 0x28A) ),
+	( 'FORWARDMSG', ('CONS', 0x28B) ),
+	( 'SEND', ('CONS', 0x28C) ),
+	( 'ATTACHFILE', ('CONS', 0x28D) ),
+	( 'UPLOAD', ('CONS', 0x28E) ),
+	( 'DOWNLOAD', ('CONS', 0x28F) ),
+	( 'SETBORDERS', ('CONS', 0x290) ),
+	( 'INSERTROW', ('CONS', 0x291) ),
+	( 'INSERTCOLUMN', ('CONS', 0x292) ),
+	( 'INSERTFILE', ('CONS', 0x293) ),
+	( 'INSERTPICTURE', ('CONS', 0x294) ),
+	( 'INSERTOBJECT', ('CONS', 0x295) ),
+	( 'INSERTSYMBOL', ('CONS', 0x296) ),
+	( 'SAVEANDCLOSE', ('CONS', 0x297) ),
+	( 'RENAME', ('CONS', 0x298) ),
+	( 'MERGE', ('CONS', 0x299) ),
+	( 'SPLIT', ('CONS', 0x29A) ),
+	( 'DISTRIBUTEHORIZONTALLY', ('CONS', 0x29B) ),
+	( 'DISTRIBUTEVERTICALLY', ('CONS', 0x29C) ),
+	( 'NEXTKEYBOARDLAYOUTSELECT', ('CONS', 0x29D) ),
+# 0x29E-0xFFFF Reserved
+])
+
diff --git a/common/id.py b/common/id.py
new file mode 100644
index 0000000..3337068
--- /dev/null
+++ b/common/id.py
@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+'''
+KLL Id Containers
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+from common.hid_dict import hid_lookup_dictionary
+
+from common.channel  import ChannelList
+from common.modifier import AnimationModifierList, PixelModifierList
+from common.position import Position
+from common.schedule import Schedule
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Id:
+	'''
+	Base container class for various KLL types
+	'''
+	def __init__( self ):
+		self.type = None
+		self.uid = None
+
+
+class HIDId( Id, Schedule ):
+	'''
+	HID/USB identifier container class
+	'''
+	secondary_types = {
+		'USBCode'  : 'USB',
+		'SysCode'  : 'SYS',
+		'ConsCode' : 'CONS',
+		'IndCode'  : 'IND',
+	}
+
+	def __init__( self, type, uid ):
+		'''
+		@param type: String type of the Id
+		@param uid:  Unique integer identifier for the Id
+		'''
+		Id.__init__( self )
+		Schedule.__init__( self )
+		self.type = type
+		self.uid = uid
+
+		# Set secondary type
+		self.second_type = self.secondary_types[ self.type ]
+
+		# TODO Validate uid to make sure it's in the lookup dictionary
+		# TODO Validate HID specifier
+		#print ( "{0} Unknown HID Specifier '{1}'".format( ERROR, type ) )
+		#raise
+
+	def __repr__( self ):
+		'''
+		Use string name instead of integer, easier to debug
+		'''
+		uid = hid_lookup_dictionary[ ( self.second_type, self.uid ) ]
+		schedule = self.strSchedule()
+		if len( schedule ) > 0:
+			schedule = "({0})".format( schedule )
+
+		output = 'HID({0})"{1}"{2}'.format( self.type, uid, schedule )
+		return output
+
+
+class ScanCodeId( Id, Schedule, Position ):
+	'''
+	Scan Code identifier container class
+	'''
+
+	def __init__( self, uid ):
+		Id.__init__( self )
+		Schedule.__init__( self )
+		Position.__init__( self )
+		self.type = 'ScanCode'
+		self.uid = uid
+
+		# By default, interconnect_id of 0
+		# Will be set during the merge process if it needs to change
+		self.interconnect_id = 0
+
+	def unique_key( self ):
+		'''
+		Returns the key string used for datastructure sorting
+		'''
+		# Positions are a special case
+		if self.positionSet():
+			return "P{0}".format( self.uid )
+
+	def __repr__( self ):
+		# Positions are a special case
+		if self.positionSet():
+			return "{0} <= {1}".format( self.unique_key(), self.strPosition() )
+
+		schedule = self.strSchedule()
+		if len( schedule ) > 0:
+			return "S{0}({1})".format( self.uid, schedule )
+		else:
+			return "S{0}".format( self.uid )
+
+
+class AnimationId( Id, AnimationModifierList ):
+	'''
+	Animation identifier container class
+	'''
+	name = None
+
+	def __init__( self, name ):
+		Id.__init__( self )
+		AnimationModifierList.__init__( self )
+		self.name = name
+		self.type = 'Animation'
+
+	def __repr__( self ):
+		if len( self.modifiers ) > 0:
+			return "A[{0}]({1})".format( self.name, self.strModifiers() )
+		return "A[{0}]".format( self.name )
+
+
+class AnimationFrameId( Id, AnimationModifierList ):
+	'''
+	Animation Frame identifier container class
+	'''
+	def __init__( self, name, index ):
+		Id.__init__( self )
+		AnimationModifierList.__init__( self )
+		self.name = name
+		self.index = index
+		self.type = 'AnimationFrame'
+
+	def __repr__( self ):
+		return "AF[{0}, {1}]".format( self.name, self.index )
+
+
+class PixelId( Id, Position, PixelModifierList, ChannelList ):
+	'''
+	Pixel identifier container class
+	'''
+	def __init__( self, uid ):
+		Id.__init__( self )
+		Position.__init__( self )
+		PixelModifierList.__init__( self )
+		ChannelList.__init__( self )
+		self.uid = uid
+		self.type = 'Pixel'
+
+	def unique_key( self ):
+		'''
+		Returns the key string used for datastructure sorting
+		'''
+		return "P{0}".format( self.uid )
+
+	def __repr__( self ):
+		# Positions are a special case
+		if self.positionSet():
+			return "{0} <= {1}".format( self.unique_key(), self.strPosition() )
+
+		extra = ""
+		if len( self.modifiers ) > 0:
+			extra += "({0})".format( self.strModifiers() )
+		if len( self.channels ) > 0:
+			extra += "({0})".format( self.strChannels() )
+		return "{0}{1}".format( self.unique_key(), extra )
+
+
+class PixelLayerId( Id, PixelModifierList ):
+	'''
+	Pixel Layer identifier container class
+	'''
+	def __init__( self, uid ):
+		Id.__init__( self )
+		PixelModifierList.__init__( self )
+		self.uid = uid
+		self.type = 'PixelLayer'
+
+	def __repr__( self ):
+		if len( self.modifiers ) > 0:
+			return "PL{0}({1})".format( self.uid, self.strModifiers() )
+		return "PL{0}".format( self.uid )
+
+
+class CapId( Id ):
+	'''
+	Capability identifier
+	'''
+	def __init__( self, name, type, arg_list=[] ):
+		'''
+		@param name:     Name of capability
+		@param type:     Type of capability definition, string
+		@param arg_list: List of CapArgIds, empty list if there are none
+		'''
+		Id.__init__( self )
+		self.name     = name
+		self.type     = type
+		self.arg_list = arg_list
+
+	def __repr__( self ):
+		# Generate prettified argument list
+		arg_string = ""
+		for arg in self.arg_list:
+			arg_string += "{0},".format( arg )
+		if len( arg_string ) > 0:
+			arg_string = arg_string[:-1]
+
+		return "{0}({1})".format( self.name, arg_string )
+
+	def total_arg_bytes( self ):
+		'''
+		Calculate the total number of bytes needed for the args
+
+		return: Number of bytes
+		'''
+		# Zero if no args
+		total_bytes = 0
+		for arg in self.arg_list:
+			total_bytes += arg.width
+
+		return total_bytes
+
+
+class NoneId( CapId ):
+	'''
+	None identifier
+
+	It's just a capability...that does nothing (instead of infering to do something else)
+	'''
+	def __init__( self ):
+		super().__init__( 'None', 'None' )
+
+	def __repr__( self ):
+		return "None"
+
+
+class CapArgId( Id ):
+	'''
+	Capability Argument identifier
+	'''
+	def __init__( self, name, width=None ):
+		'''
+		@param name:  Name of argument
+		@param width: Byte-width of the argument, if None, this is not port of a capability definition
+		'''
+		Id.__init__( self )
+		self.name = name
+		self.width = width
+		self.type = 'CapArg'
+
+	def __repr__( self ):
+		if self.width is None:
+			return "{0}".format( self.name )
+		else:
+			return "{0}:{1}".format( self.name, self.width )
+
diff --git a/common/modifier.py b/common/modifier.py
new file mode 100644
index 0000000..4420d2a
--- /dev/null
+++ b/common/modifier.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+'''
+KLL Modifier Containers
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class AnimationModifier:
+	'''
+	Animation modification container class
+	'''
+	def __init__( self, name, value=None ):
+		self.name = name
+		self.value = value
+
+	def __repr__( self ):
+		if self.value is None:
+			return "{0}".format( self.name )
+		return "{0}:{1}".format( self.name, self.value )
+
+
+class AnimationModifierList:
+	'''
+	Animation modification container list class
+
+	Contains a list of modifiers, the order does not matter
+	'''
+	def __init__( self ):
+		self.modifiers = []
+
+	def setModifiers( self, modifier_list ):
+		'''
+		Apply modifiers to Animation
+		'''
+		for modifier in modifier_list:
+			self.modifiers.append( AnimationModifier( modifier[0], modifier[1] ) )
+
+	def strModifiers( self ):
+		'''
+		__repr__ of Position when multiple inheritance is used
+		'''
+		output = ""
+		for index, modifier in enumerate( self.modifiers ):
+			if index > 0:
+				output += ","
+			output += "{0}".format( modifier )
+
+		return output
+
+	def __repr__( self ):
+		return self.strModifiers()
+
+
+class PixelModifier:
+	'''
+	Pixel modification container class
+	'''
+	def __init__( self, operator, value ):
+		self.operator = operator
+		self.value = value
+
+	def __repr__( self ):
+		if self.operator is None:
+			return "{0}".format( self.value )
+		return "{0}{1}".format( self.operator, self.value )
+
+
+class PixelModifierList:
+	'''
+	Pixel modification container list class
+
+	Contains a list of modifiers
+	Index 0, corresponds to pixel 0
+	'''
+	def __init__( self ):
+		self.modifiers = []
+
+	def setModifiers( self, modifier_list ):
+		'''
+		Apply modifier to each pixel channel
+		'''
+		for modifier in modifier_list:
+			self.modifiers.append( PixelModifier( modifier[0], modifier[1] ) )
+
+	def strModifiers( self ):
+		'''
+		__repr__ of Position when multiple inheritance is used
+		'''
+		output = ""
+		for index, modifier in enumerate( self.modifiers ):
+			if index > 0:
+				output += ","
+			output += "{0}".format( modifier )
+
+		return output
+
+	def __repr__( self ):
+		return self.strModifiers()
+
diff --git a/common/organization.py b/common/organization.py
new file mode 100644
index 0000000..2d189a3
--- /dev/null
+++ b/common/organization.py
@@ -0,0 +1,614 @@
+#!/usr/bin/env python3
+'''
+KLL Data Organization
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import re
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+ansi_escape = re.compile(r'\x1b[^m]*m')
+
+
+
+### Classes ###
+
+class Data:
+	'''
+	Base class for KLL datastructures
+	'''
+	# Debug output formatters
+	debug_output = {
+		'add' : "\t\033[1;42;37m++\033[0m\033[1mADD KEY\033[1;42;37m++\033[0m \033[1m<==\033[0m {0}",
+		'app' : "\t\033[1;45;37m**\033[0m\033[1mAPP KEY\033[1;45;37m**\033[0m \033[1m<==\033[0m {0}",
+		'mod' : "\t\033[1;44;37m##\033[0m\033[1mMOD KEY\033[1;44;37m##\033[0m \033[1m<==\033[0m {0}",
+		'rem' : "\t\033[1;41;37m--\033[0m\033[1mREM KEY\033[1;41;37m--\033[0m \033[1m<==\033[0m {0}",
+		'drp' : "\t\033[1;43;37m@@\033[0m\033[1mDRP KEY\033[1;43;37m@@\033[0m \033[1m<==\033[0m {0}",
+		'dup' : "\t\033[1;46;37m!!\033[0m\033[1mDUP KEY\033[1;46;37m!!\033[0m \033[1m<==\033[0m {0}",
+	}
+
+	def __init__( self, parent ):
+		'''
+		Initialize datastructure
+
+		@param parent: Parent organization, used to query data from other datastructures
+		'''
+		self.data = {}
+		self.parent = parent
+
+	def add_expression( self, expression, debug ):
+		'''
+		Add expression to data structure
+
+		May have multiple keys to add for a given expression
+
+		@param expression: KLL Expression (fully tokenized and parsed)
+		@param debug:      Enable debug output
+		'''
+		# Lookup unique keys for expression
+		keys = expression.unique_keys()
+
+		# Add/Modify expressions in datastructure
+		for key, uniq_expr in keys:
+			# Check which operation we are trying to do, add or modify
+			if debug[0]:
+				if key in self.data.keys():
+					output = self.debug_output['mod'].format( key )
+				else:
+					output = self.debug_output['add'].format( key )
+				print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+			self.data[ key ] = uniq_expr
+
+	def merge( self, merge_in, debug ):
+		'''
+		Merge in the given datastructure to this datastructure
+
+		This datastructure serves as the base.
+
+		@param merge_in: Data structure from another organization to merge into this one
+		@param debug:    Enable debug out
+		'''
+		# The default case is just to add the expression in directly
+		for key, kll_expression in merge_in.data.items():
+			# Display key:expression being merged in
+			if debug[0]:
+				output = merge_in.elem_str( key, True )
+				print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
+
+			self.add_expression( kll_expression, debug )
+
+	def reduction( self ):
+		'''
+		Simplifies datastructure
+
+		Most of the datastructures don't have a reduction. Just do nothing in this case.
+		'''
+		pass
+
+	def elem_str( self, key, single=False ):
+		'''
+		Debug output for a single element
+
+		@param key:    Index to datastructure
+		@param single: Setting to True will bold the key
+		'''
+		if single:
+			return "\033[1;33m{0: <20}\033[0m \033[1;36;41m>\033[0m {1}\n".format( key, self.data[ key ] )
+		else:
+			return "{0: <20} \033[1;36;41m>\033[0m {1}\n".format( key, self.data[ key ] )
+
+	def __repr__( self ):
+		output = ""
+
+		# Display sorted list of keys, along with the internal value
+		for key in sorted( self.data ):
+			output += self.elem_str( key )
+
+		return output
+
+
+class MappingData( Data ):
+	'''
+	KLL datastructure for data mapping
+
+	ScanCode  trigger -> result
+	USBCode   trigger -> result
+	Animation trigger -> result
+	'''
+	def add_expression( self, expression, debug ):
+		'''
+		Add expression to data structure
+
+		May have multiple keys to add for a given expression
+
+		Map expressions insert into the datastructure according to their operator.
+
+		+Operators+
+		:   Add/Modify
+		:+  Append
+		:-  Remove
+		::  Lazy Add/Modify
+
+		i:  Add/Modify
+		i:+ Append
+		i:- Remove
+		i:: Lazy Add/Modify
+
+		The i or isolation operators are stored separately from the main ones.
+		Each key is pre-pended with an i
+
+		The :: or lazy operators act just like : operators, except that they will be ignore if the evaluation
+		merge cannot resolve a ScanCode.
+
+		@param expression: KLL Expression (fully tokenized and parsed)
+		@param debug:      Enable debug output
+		'''
+		# Lookup unique keys for expression
+		keys = expression.unique_keys()
+
+		# Add/Modify expressions in datastructure
+		for key, uniq_expr in keys:
+			# Determine which the expression operator
+			operator = expression.operator
+
+			# Except for the : operator, all others have delayed action
+			# Meaning, they change behaviour depending on how Contexts are merged
+			# This means we can't simplify yet
+			# In addition, :+ and :- are stackable, which means each key has a list of expressions
+			# We append the operator to differentiate between the different types of delayed operations
+			key = "{0}{1}".format( operator, key )
+
+			# Determine if key exists already
+			exists = key in self.data.keys()
+
+			# Add/Modify
+			if operator in [':', '::', 'i:', 'i::']:
+				debug_tag = exists and 'mod' or 'add'
+
+			# Append/Remove
+			else:
+				# Check to make sure we haven't already appended expression
+				# Use the string representation to do the comparison (general purpose)
+				if exists and "{0}".format( uniq_expr ) in [ "{0}".format( elem ) for elem in self.data[ key ] ]:
+					debug_tag = 'dup'
+
+				# Append
+				elif operator in [':+', 'i:+']:
+					debug_tag = 'app'
+
+				# Remove
+				else:
+					debug_tag = 'rem'
+
+			# Debug output
+			if debug[0]:
+				output = self.debug_output[ debug_tag ].format( key )
+				print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+			# Don't append if a duplicate
+			if debug_tag == 'dup':
+				continue
+
+			# Append, rather than replace
+			if operator in [':+', ':-', 'i:+', 'i:-']:
+				if exists:
+					self.data[ key ].append( uniq_expr )
+
+				# Create initial list
+				else:
+					self.data[ key ] = [ uniq_expr ]
+			else:
+				self.data[ key ] = [ uniq_expr ]
+
+	def set_interconnect_id( self, interconnect_id, triggers ):
+		'''
+		Traverses the sequence of combo of identifiers to set the interconnect_id
+		'''
+		for sequence in triggers:
+			for combo in sequence:
+				for identifier in combo:
+					identifier.interconnect_id = interconnect_id
+
+	def merge( self, merge_in, debug ):
+		'''
+		Merge in the given datastructure to this datastructure
+
+		This datastructure serves as the base.
+
+		Map expressions merge differently than insertions.
+
+		+Operators+
+		:   Add/Modify       - Replace
+		:+  Append           - Add
+		:-  Remove           - Remove
+		::  Lazy Add/Modify  - Replace if found, otherwise drop
+
+		i:  Add/Modify       - Replace
+		i:+ Append           - Add
+		i:- Remove           - Remove
+		i:: Lazy Add/Modify  - Replace if found, otherwise drop
+
+		@param merge_in: Data structure from another organization to merge into this one
+		@param debug:    Enable debug out
+		'''
+		# Check what the current interconnectId is
+		# If not set, we set to 0 (default)
+		# We use this to calculate the scancode during the DataAnalysisStage
+		interconnect_id = 0
+		if 'interconnectId' in self.parent.variable_data.data.keys():
+			interconnect_id = self.parent.variable_data.data['interconnectId']
+
+		# Sort different types of keys
+		cur_keys = merge_in.data.keys()
+
+		# Lazy Set ::
+		lazy_keys = [ key for key in cur_keys if key[0:2] == '::' or key[0:3] == 'i::' ]
+		cur_keys = list( set( cur_keys ) - set( lazy_keys ) )
+
+		# Append :+
+		append_keys = [ key for key in cur_keys if key[0:2] == ':+' or key[0:3] == 'i:+' ]
+		cur_keys = list( set( cur_keys ) - set( append_keys ) )
+
+		# Remove :-
+		remove_keys = [ key for key in cur_keys if key[0:2] == ':-' or key[0:3] == 'i:-' ]
+		cur_keys = list( set( cur_keys ) - set( remove_keys ) )
+
+		# Set :
+		# Everything left is just a set
+		set_keys = cur_keys
+
+
+		# First process the :: (or lazy) operators
+		# We need to read into this datastructure and apply those first
+		# Otherwise we may get undesired behaviour
+		for key in lazy_keys:
+			# Display key:expression being merged in
+			if debug[0]:
+				output = merge_in.elem_str( key, True )
+				print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
+
+			# Construct target key
+			target_key = key[0] == 'i' and "i{0}".format( key[2:] ) or key[1:]
+
+			# If target key exists, replace
+			if target_key in self.data.keys():
+				debug_tag = 'mod'
+			else:
+				debug_tag = 'drp'
+
+			# Debug output
+			if debug[0]:
+				output = self.debug_output[ debug_tag ].format( key )
+				print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+			# Only replace
+			if debug_tag == 'mod':
+				self.data[ target_key ] = merge_in.data[ key ]
+
+		# Then apply : assignment operators
+		for key in set_keys:
+			# Display key:expression being merged in
+			if debug[0]:
+				output = merge_in.elem_str( key, True )
+				print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
+
+			# Construct target key
+			target_key = key
+
+			# Indicate if add or modify
+			if target_key in self.data.keys():
+				debug_tag = 'mod'
+			else:
+				debug_tag = 'add'
+
+			# Debug output
+			if debug[0]:
+				output = self.debug_output[ debug_tag ].format( key )
+				print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+			# Set into new datastructure regardless
+			self.data[ target_key ] = merge_in.data[ key ]
+
+			# Only the : is used to set ScanCodes
+			# We need to set the interconnect_id just in case the base context has it set
+			# and in turn influence the new context as well
+			# This must be done during the merge
+			for elem in self.data[ target_key ]:
+				if elem.type == 'ScanCode':
+					self.set_interconnect_id( interconnect_id, elem.triggers )
+
+		# Now apply append operations
+		for key in append_keys:
+			# Display key:expression being merged in
+			if debug[0]:
+				output = merge_in.elem_str( key, True )
+				print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
+
+			# Construct target key
+			target_key = key[0] == 'i' and "i:{0}".format( key[3:] ) or ":{0}".format( key[2:] )
+
+			# Alwyays appending
+			debug_tag = 'app'
+
+			# Debug output
+			if debug[0]:
+				output = self.debug_output[ debug_tag ].format( key )
+				print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+			# Extend list if it exists
+			if target_key in self.data.keys():
+				self.data[ target_key ].extend( merge_in.data[ key ] )
+			else:
+				self.data[ target_key ] = merge_in.data[ key ]
+
+		# Finally apply removal operations to this datastructure
+		# If the target removal doesn't exist, ignore silently (show debug message)
+		for key in remove_keys:
+			# Display key:expression being merged in
+			if debug[0]:
+				output = merge_in.elem_str( key, True )
+				print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
+
+			# Construct target key
+			target_key = key[0] == 'i' and "i:{0}".format( key[3:] ) or ":{0}".format( key[2:] )
+
+			# Drop right away if target datastructure doesn't have target key
+			if target_key not in self.data.keys():
+				debug_tag = 'drp'
+
+				# Debug output
+				if debug[0]:
+					output = self.debug_output[ debug_tag ].format( key )
+					print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+				continue
+
+			# Compare expressions to be removed with the current set
+			# Use strings to compare
+			remove_expressions = [ "{0}".format( expr ) for expr in merge_in.data[ key ] ]
+			current_expressions = [ ( "{0}".format( expr ), expr ) for expr in self.data[ target_key ] ]
+			for string, expr in current_expressions:
+				debug_tag = 'drp'
+
+				# Check if an expression matches
+				if string in remove_expressions:
+					debug_tag = 'rem'
+
+				# Debug output
+				if debug[0]:
+					output = self.debug_output[ debug_tag ].format( key )
+					print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+				# Remove if found
+				if debug_tag == 'rem':
+					self.data[ target_key ] = [ value for value in self.data.values() if value != expr ]
+
+	def reduction( self ):
+		'''
+		Simplifies datastructure
+
+		Used to replace all trigger HIDCode(USBCode)s with ScanCodes
+
+		NOTE: Make sure to create a new MergeContext before calling this as you lose data and prior context
+		'''
+		scan_code_lookup = {}
+
+		# Build dictionary of single ScanCodes first
+		for key, expr in self.data.items():
+			if expr[0].elems()[0] == 1 and expr[0].triggers[0][0][0].type == 'ScanCode':
+				scan_code_lookup[ key ] = expr
+
+		# Using this dictionary, replace all the trigger USB codes
+		new_data = copy.copy( scan_code_lookup )
+
+		# 1) Single USB Codes trigger results will replace the original ScanCode result
+		# 2) 
+
+		#TODO
+		print("YAY")
+		print( scan_code_lookup )
+
+
+class AnimationData( Data ):
+	'''
+	KLL datastructure for Animation configuration
+
+	Animation -> modifiers
+	'''
+
+
+class AnimationFrameData( Data ):
+	'''
+	KLL datastructure for Animation Frame configuration
+
+	Animation -> Pixel Settings
+	'''
+
+
+class CapabilityData( Data ):
+	'''
+	KLL datastructure for Capability mapping
+
+	Capability -> C Function/Identifier
+	'''
+
+
+class DefineData( Data ):
+	'''
+	KLL datastructure for Define mapping
+
+	Variable -> C Define/Identifier
+	'''
+
+
+class PixelChannelData( Data ):
+	'''
+	KLL datastructure for Pixel Channel mapping
+
+	Pixel -> Channels
+	'''
+
+
+class PixelPositionData( Data ):
+	'''
+	KLL datastructure for Pixel Position mapping
+
+	Pixel -> Physical Location
+	'''
+
+
+class ScanCodePositionData( Data ):
+	'''
+	KLL datastructure for ScanCode Position mapping
+
+	ScanCode -> Physical Location
+	'''
+
+
+class VariableData( Data ):
+	'''
+	KLL datastructure for Variables and Arrays
+
+	Variable -> Data
+	Array    -> Data
+	'''
+
+
+class Organization:
+	'''
+	Container class for KLL datastructures
+
+	The purpose of these datastructures is to symbolically store at first, and slowly solve/deduplicate expressions.
+	Since the order in which the merges occurs matters, this involves a number of intermediate steps.
+	'''
+
+	def __init__( self ):
+		'''
+		Intialize data structure
+		'''
+		# Setup each of the internal sub-datastructures
+		self.animation_data          = AnimationData( self )
+		self.animation_frame_data    = AnimationFrameData( self )
+		self.capability_data         = CapabilityData( self )
+		self.define_data             = DefineData( self )
+		self.mapping_data            = MappingData( self )
+		self.pixel_channel_data      = PixelChannelData( self )
+		self.pixel_position_data     = PixelPositionData( self )
+		self.scan_code_position_data = ScanCodePositionData( self )
+		self.variable_data           = VariableData( self )
+
+		# Expression to Datastructure mapping
+		self.data_mapping = {
+			'AssignmentExpression' : {
+				'Array'    : self.variable_data,
+				'Variable' : self.variable_data,
+			},
+			'DataAssociationExpression' : {
+				'Animation'        : self.animation_data,
+				'AnimationFrame'   : self.animation_frame_data,
+				'PixelPosition'    : self.pixel_position_data,
+				'ScanCodePosition' : self.scan_code_position_data,
+			},
+			'MapExpression' : {
+				'ScanCode'     : self.mapping_data,
+				'USBCode'      : self.mapping_data,
+				'Animation'    : self.mapping_data,
+				'PixelChannel' : self.pixel_channel_data,
+			},
+			'NameAssociationExpression' : {
+				'Capability' : self.capability_data,
+				'Define'     : self.define_data,
+			},
+		}
+
+	def stores( self ):
+		'''
+		Returns list of sub-datastructures
+		'''
+		return [
+			self.animation_data,
+			self.animation_frame_data,
+			self.capability_data,
+			self.define_data,
+			self.mapping_data,
+			self.pixel_channel_data,
+			self.pixel_position_data,
+			self.scan_code_position_data,
+			self.variable_data,
+		]
+
+	def add_expression( self, expression, debug ):
+		'''
+		Add expression to datastructure
+
+		Will automatically determine which type of expression and place in the relevant store
+
+		@param expression: KLL Expression (fully tokenized and parsed)
+		@param debug:      Enable debug output
+		'''
+		# Determine type of of Expression
+		expression_type = expression.__class__.__name__
+
+		# Determine Expression Subtype
+		expression_subtype = expression.type
+
+		# Locate datastructure
+		data = self.data_mapping[ expression_type ][ expression_subtype ]
+
+		# Debug output
+		if debug[0]:
+			output = "\t\033[4m{0}\033[0m".format( data.__class__.__name__ )
+			print( debug[1] and output or ansi_escape.sub( '', output ) )
+
+		# Add expression to determined datastructure
+		data.add_expression( expression, debug )
+
+	def merge( self, merge_in, debug ):
+		'''
+		Merge in the given organization to this organization
+
+		This organization serves as the base.
+
+		@param merge_in: Organization to merge into this one
+		@param debug:    Enable debug out
+		'''
+		# Merge each of the sub-datastructures
+		for this, that in zip( self.stores(), merge_in.stores() ):
+			this.merge( that, debug )
+
+	def reduction( self ):
+		'''
+		Simplifies datastructure
+
+		NOTE: This will remove data, therefore, context is lost
+		'''
+		for store in self.stores():
+			store.reduction()
+
+	def __repr__( self ):
+		return "{0}".format( self.stores() )
+
diff --git a/common/parse.py b/common/parse.py
new file mode 100644
index 0000000..b9ee3f1
--- /dev/null
+++ b/common/parse.py
@@ -0,0 +1,830 @@
+#!/usr/bin/env python3
+'''
+KLL Parsing Expressions
+
+This file contains various parsing rules and processors used by funcparserlib for KLL
+
+REMEMBER: When editing parser BNF-like expressions, order matters. Specifically lexer tokens and parser |
+'''
+
+# Parser doesn't play nice with linters, disable some checks
+# pylint: disable=no-self-argument, too-many-public-methods, no-self-use, bad-builtin
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+from common.hid_dict import kll_hid_lookup_dictionary
+
+from common.id import (
+	AnimationId, AnimationFrameId,
+	CapArgId, CapId,
+	HIDId,
+	NoneId,
+	PixelId, PixelLayerId,
+	ScanCodeId
+)
+from common.modifier import AnimationModifierList
+from common.schedule import AnalogScheduleParam, ScheduleParam, Time
+
+from funcparserlib.lexer  import Token
+from funcparserlib.parser import (some, a, many, oneplus, skip, maybe)
+
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+## Parsing Functions
+
+class Make:
+	'''
+	Collection of parse string interpreters
+	'''
+
+	def scanCode( token ):
+		'''
+		Converts a raw scan code string into an ScanCodeId /w integer
+
+		S0x10 -> 16
+		'''
+		if isinstance( token, int ):
+			return ScanCodeId( token )
+		else:
+			return ScanCodeId( int( token[1:], 0 ) )
+
+	def hidCode( type, token ):
+		'''
+		Convert a given raw hid token string to an integer /w a type
+
+		U"Enter" -> USB, Enter(0x28)
+		'''
+		# If already converted to a HIDId, just return
+		if isinstance( token, HIDId ):
+			return token
+
+		# If first character is a U or I, strip
+		if token[0] == "U" or token[0] == "I":
+			token = token[1:]
+		# CONS specifier
+		elif 'CONS' in token:
+			token = token[4:]
+		# SYS specifier
+		elif 'SYS' in token:
+			token = token[3:]
+
+		# If using string representation of USB Code, do lookup, case-insensitive
+		if '"' in token:
+			try:
+				hidCode = kll_hid_lookup_dictionary[ type ][ token[1:-1].upper() ][1]
+			except LookupError as err:
+				print ( "{0} {1} is an invalid USB HID Code Lookup...".format( ERROR, err ) )
+				raise
+		else:
+			# Already tokenized
+			if (
+				type == 'USBCode' and token[0] == 'USB'
+				or
+				type == 'SysCode' and token[0] == 'SYS'
+				or
+				type == 'ConsCode' and token[0] == 'CONS'
+				or
+				type == 'IndCode' and token[0] == 'IND'
+			):
+				hidCode = token[1]
+			# Convert
+			else:
+				hidCode = int( token, 0 )
+
+		return HIDId( type, hidCode )
+
+
+	def usbCode( token ):
+		'''
+		Convert a given raw USB Keyboard hid token string to an integer /w a type
+
+		U"Enter" -> USB, Enter(0x28)
+		'''
+		return Make.hidCode( 'USBCode', token )
+
+	def consCode( token ):
+		'''
+		Convert a given raw Consumer Control hid token string to an integer /w a type
+		'''
+		return Make.hidCode( 'ConsCode', token )
+
+	def sysCode( token ):
+		'''
+		Convert a given raw System Control hid token string to an integer /w a type
+		'''
+		return Make.hidCode( 'SysCode', token )
+
+	def indCode( token ):
+		'''
+		Convert a given raw Indicator hid token string to an integer /w a type
+		'''
+		return Make.hidCode( 'IndCode', token )
+
+	def animation( name ):
+		'''
+		Converts a raw animation value into an AnimationId /w name
+
+		A"myname" -> myname
+		'''
+		if name[0] == "A":
+			return AnimationId( name[2:-1] )
+		else:
+			return AnimationId( name )
+
+	def animationTrigger( animation, frame_indices ):
+		'''
+		Generate either an AnimationId or an AnimationFrameId
+
+		frame_indices indicate that this is an AnimationFrameId
+		'''
+		trigger_list = []
+		# AnimationFrameId
+		if len( frame_indices ) > 0:
+			for index in frame_indices:
+				trigger_list.append( [ [ AnimationFrameId( animation, index ) ] ] )
+		# AnimationId
+		else:
+			trigger_list.append( [ [ AnimationId( animation ) ] ] )
+
+		return trigger_list
+
+	def animationCapability( animation, modifiers ):
+		'''
+		Apply modifiers to AnimationId
+		'''
+		if modifiers is not None:
+			animation.setModifiers( modifiers )
+		return [ animation ]
+
+	def animationModlist( modifiers ):
+		'''
+		Build an AnimationModifierList
+
+		Only used for animation data association
+		'''
+		modlist = AnimationModifierList()
+		modlist.setModifiers( modifiers )
+		return modlist
+
+	def pixelCapability( pixels, modifiers ):
+		'''
+		Apply modifiers to list of pixels/pixellists
+
+		Results in a combination of pixel capabilities
+		'''
+		pixelcap_list = []
+		for pixel in pixels:
+			pixel.setModifiers( modifiers )
+			pixelcap_list.append( pixel )
+		return pixelcap_list
+
+	def pixel( token ):
+		'''
+		Converts a raw pixel value into a PixelId /w integer
+
+		P0x3 -> 3
+		'''
+		if isinstance( token, int ):
+			return PixelId( token )
+		else:
+			return PixelId( int( token[1:], 0 ) )
+
+	def pixel_list( pixel_list ):
+		'''
+		Converts a list a numbers into a list of PixelIds
+		'''
+		pixels = []
+		for pixel in pixel_list:
+			pixels.append( PixelId( pixel ) )
+		return pixels
+
+	def pixelLayer( token ):
+		'''
+		Converts a raw pixel layer value into a PixelLayerId /w integer
+
+		PL0x3 -> 3
+		'''
+		if isinstance( token, int ):
+			return PixelLayerId( token )
+		else:
+			return PixelLayerId( int( token[2:], 0 ) )
+
+	def pixelLayer_list( layer_list ):
+		'''
+		Converts a list a numbers into a list of PixelLayerIds
+		'''
+		layers = []
+		for layer in layer_list:
+			layers.append( PixelLayerId( layer ) )
+		return layers
+
+	def pixelchan( pixel_list, chans ):
+		'''
+		Apply channels to PixelId
+
+		Only one pixel at a time can be mapped, hence pixel_list[0]
+		'''
+		pixel = pixel_list[0]
+		pixel.setChannels( chans )
+		return pixel
+
+	def pixelmod( pixels, modifiers ):
+		'''
+		Apply modifiers to list of pixels/pixellists
+
+		Results in a combination of pixel capabilities
+		'''
+		pixelcap_list = []
+		for pixel in pixels:
+			pixel.setModifiers( modifiers )
+			pixelcap_list.append( pixel )
+		return pixelcap_list
+
+	def position( token ):
+		'''
+		Physical position split
+
+		x:20 -> (x, 20)
+		'''
+		return token.split(':')
+
+	def usbCode_number( token ):
+		'''
+		USB Keyboard HID Code lookup
+		'''
+		return HIDId( 'USBCode', token )
+
+	def consCode_number( token ):
+		'''
+		Consumer Control HID Code lookup
+		'''
+		return HIDId( 'ConsCode', token )
+
+	def sysCode_number( token ):
+		'''
+		System Control HID Code lookup
+		'''
+		return HIDId( 'SysCode', token )
+
+	def indCode_number( token ):
+		'''
+		Indicator HID Code lookup
+		'''
+		return HIDId( 'IndCode', token )
+
+	def none( token ):
+		'''
+		Replace key-word with NoneId specifier (which indicates a noneOut capability)
+		'''
+		return [[[NoneId()]]]
+
+	def seqString( token ):
+		'''
+		Converts sequence string to a sequence of combinations
+
+		'Ab' -> U"Shift" + U"A", U"B"
+		'''
+		# TODO - Add locale support
+
+		# Shifted Characters, and amount to move by to get non-shifted version
+		# US ANSI
+		shiftCharacters = (
+			( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 0x20 ),
+			( "+",       0x12 ),
+			( "&(",      0x11 ),
+			( "!#$%",    0x10 ),
+			( "*",       0x0E ),
+			( ")",       0x07 ),
+			( '"',       0x05 ),
+			( ":",       0x01 ),
+			( "@",      -0x0E ),
+			( "<>?",    -0x10 ),
+			( "~",      -0x1E ),
+			( "{}|",    -0x20 ),
+			( "^",      -0x28 ),
+			( "_",      -0x32 ),
+		)
+
+		listOfLists = []
+		shiftKey = kll_hid_lookup_dictionary['USBCode']["SHIFT"]
+
+		# Creates a list of USB codes from the string: sequence (list) of combos (lists)
+		for char in token[1:-1]:
+			processedChar = char
+
+			# Whether or not to create a combo for this sequence with a shift
+			shiftCombo = False
+
+			# Depending on the ASCII character, convert to single character or Shift + character
+			for pair in shiftCharacters:
+				if char in pair[0]:
+					shiftCombo = True
+					processedChar = chr( ord( char ) + pair[1] )
+					break
+
+			# Do KLL HID Lookup on non-shifted character
+			# NOTE: Case-insensitive, which is why the shift must be pre-computed
+			usb_code = kll_hid_lookup_dictionary['USBCode'][ processedChar.upper() ]
+
+			# Create Combo for this character, add shift key if shifted
+			charCombo = []
+			if shiftCombo:
+				charCombo = [ [ HIDId( 'USBCode', shiftKey[1] ) ] ]
+			charCombo.append( [ HIDId( 'USBCode', usb_code[1] ) ] )
+
+			# Add to list of lists
+			listOfLists.append( charCombo )
+
+		return listOfLists
+
+	def string( token ):
+		'''
+		Converts a raw string to a Python string
+
+		"this string" -> this string
+		'''
+		return token[1:-1]
+
+	def unseqString( token ):
+		'''
+		Converts a raw sequence string to a Python string
+
+		'this string' -> this string
+		'''
+		return token[1:-1]
+
+	def number( token ):
+		'''
+		Convert string number to Python integer
+		'''
+		return int( token, 0 )
+
+	def timing( token ):
+		'''
+		Convert raw timing parameter to integer time and determine units
+
+		1ms -> 1, ms
+		'''
+		# Find ms, us, or s
+		if 'ms' in token:
+			unit = 'ms'
+			num = token.split('m')[0]
+		elif 'us' in token:
+			unit = 'us'
+			num = token.split('u')[0]
+		elif 'ns' in token:
+			unit = 'ns'
+			num = token.split('n')[0]
+		elif 's' in token:
+			unit = 's'
+			num = token.split('s')[0]
+		else:
+			print ( "{0} cannot find timing unit in token '{1}'".format( ERROR, token ) )
+
+		return Time( float( num ), unit )
+
+	def specifierTiming( timing ):
+		'''
+		When only timing is given, infer state at a later stage from the context of the mapping
+		'''
+		return ScheduleParam( None, timing )
+
+	def specifierState( state, timing=None ):
+		'''
+		Generate a Schedule Parameter
+		Automatically mutates itself into the correct object type
+		'''
+		return ScheduleParam( state, timing )
+
+	def specifierAnalog( value ):
+		'''
+		Generate an Analog Schedule Parameter
+		'''
+		return AnalogScheduleParam( value )
+
+	def specifierUnroll( identifier, schedule_params ):
+		'''
+		Unroll specifiers into the trigger/result identifier
+
+		First, combine all Schedule Parameters into a Schedul
+		Then attach Schedule to the identifier
+
+		If the identifier is a list, then iterate through them
+		and apply the schedule to each
+		'''
+		# Check if this is a list of identifiers
+		if isinstance( identifier, list ):
+			for ident in identifier:
+				ident.setSchedule( schedule_params )
+			return identifier
+		else:
+			identifier.setSchedule( schedule_params )
+
+		return [ identifier ]
+
+
+	# Range can go from high to low or low to high
+	def scanCode_range( rangeVals ):
+		'''
+		Scan Code range expansion
+
+		S[0x10-0x12] -> S0x10, S0x11, S0x12
+		'''
+		start = rangeVals[0]
+		end   = rangeVals[1]
+
+		# Swap start, end if start is greater than end
+		if start > end:
+			start, end = end, start
+
+		# Iterate from start to end, and generate the range
+		values = list( range( start, end + 1 ) )
+
+		# Generate ScanCodeIds
+		return [ ScanCodeId( v ) for v in values ]
+
+	# Range can go from high to low or low to high
+	# Warn on 0-9 for USBCodes (as this does not do what one would expect) TODO
+	# Lookup USB HID tags and convert to a number
+	def hidCode_range( type, rangeVals ):
+		'''
+		HID Code range expansion
+
+		U["A"-"C"] -> U"A", U"B", U"C"
+		'''
+
+		# Check if already integers
+		if isinstance( rangeVals[0], int ):
+			start = rangeVals[0]
+		else:
+			start = Make.hidCode( type, rangeVals[0] ).uid
+
+		if isinstance( rangeVals[1], int ):
+			end = rangeVals[1]
+		else:
+			end = Make.hidCode( type, rangeVals[1] ).uid
+
+		# Swap start, end if start is greater than end
+		if start > end:
+			start, end = end, start
+
+		# Iterate from start to end, and generate the range
+		listRange = list( range( start, end + 1 ) )
+
+		# Convert each item in the list to a tuple
+		for item in range( len( listRange ) ):
+			listRange[ item ] = HIDId( type, listRange[ item ] )
+		return listRange
+
+	def usbCode_range( rangeVals ):
+		'''
+		USB Keyboard HID Code range expansion
+		'''
+		return Make.hidCode_range( 'USBCode', rangeVals )
+
+	def sysCode_range( rangeVals ):
+		'''
+		System Control HID Code range expansion
+		'''
+		return Make.hidCode_range( 'SysCode', rangeVals )
+
+	def consCode_range( rangeVals ):
+		'''
+		Consumer Control HID Code range expansion
+		'''
+		return Make.hidCode_range( 'ConsCode', rangeVals )
+
+	def indCode_range( rangeVals ):
+		'''
+		Indicator HID Code range expansion
+		'''
+		return Make.hidCode_range( 'IndCode', rangeVals )
+
+	def range( start, end ):
+		'''
+		Converts a start and end points of a range to a list of numbers
+
+		Can go low to high or high to low
+		'''
+		# High to low
+		if end < start:
+			return list( range( end, start + 1 ) )
+
+		# Low to high
+		return list( range( start, end + 1 ) )
+
+	def capArg( argument, width=None ):
+		'''
+		Converts a capability argument:width to a CapArgId
+
+		If no width is specified, it is ignored
+		'''
+		return CapArgId( argument, width )
+
+	def capUsage( name, arguments ):
+		'''
+		Converts a capability tuple, argument list to a CapId Usage
+		'''
+		return CapId( name, 'Usage', arguments )
+
+
+
+### Rules ###
+
+## Base Rules
+
+const       = lambda x: lambda _: x
+unarg       = lambda f: lambda x: f(*x)
+flatten     = lambda list: sum( list, [] )
+
+tokenValue  = lambda x: x.value
+tokenType   = lambda t: some( lambda x: x.type == t ) >> tokenValue
+operator    = lambda s: a( Token( 'Operator', s ) ) >> tokenValue
+parenthesis = lambda s: a( Token( 'Parenthesis', s ) ) >> tokenValue
+bracket     = lambda s: a( Token( 'Bracket', s ) ) >> tokenValue
+eol         = a( Token( 'EndOfLine', ';' ) )
+
+def maybeFlatten( items ):
+	'''
+	Iterate through top-level lists
+	Flatten, only if the element is also a list
+
+	[[1,2],3,[[4,5]]] -> [1,2,3,[4,5]]
+	'''
+	new_list = []
+	for elem in items:
+		# Flatten only if a list
+		if isinstance( elem, list ):
+			new_list.extend( elem )
+		else:
+			new_list.append( elem )
+	return new_list
+
+def listElem( item ):
+	'''
+	Convert to a list element
+	'''
+	return [ item ]
+
+def listToTuple( items ):
+	'''
+	Convert list to a tuple
+	'''
+	return tuple( items )
+
+def oneLayerFlatten( items ):
+	'''
+	Flatten only the top layer (list of lists of ...)
+	'''
+	mainList = []
+	for sublist in items:
+		for item in sublist:
+			mainList.append( item )
+
+	return mainList
+
+def optionExpansion( sequences ):
+	'''
+	Expand ranges of values in the 3rd dimension of the list, to a list of 2nd lists
+
+	i.e. [ sequence, [ combo, [ range ] ] ] --> [ [ sequence, [ combo ] ], <option 2>, <option 3> ]
+	'''
+	expandedSequences = []
+
+	# Total number of combinations of the sequence of combos that needs to be generated
+	totalCombinations = 1
+
+	# List of leaf lists, with number of leaves
+	maxLeafList = []
+
+	# Traverse to the leaf nodes, and count the items in each leaf list
+	for sequence in sequences:
+		for combo in sequence:
+			rangeLen = len( combo )
+			totalCombinations *= rangeLen
+			maxLeafList.append( rangeLen )
+
+	# Counter list to keep track of which combination is being generated
+	curLeafList = [0] * len( maxLeafList )
+
+	# Generate a list of permuations of the sequence of combos
+	for count in range( 0, totalCombinations ):
+		expandedSequences.append( [] ) # Prepare list for adding the new combination
+		pos = 0
+
+		# Traverse sequence of combos to generate permuation
+		for sequence in sequences:
+			expandedSequences[ -1 ].append( [] )
+			for combo in sequence:
+				expandedSequences[ -1 ][ -1 ].append( combo[ curLeafList[ pos ] ] )
+				pos += 1
+
+		# Increment combination tracker
+		for leaf in range( 0, len( curLeafList ) ):
+			curLeafList[ leaf ] += 1
+
+			# Reset this position, increment next position (if it exists), then stop
+			if curLeafList[ leaf ] >= maxLeafList[ leaf ]:
+				curLeafList[ leaf ] = 0
+				if leaf + 1 < len( curLeafList ):
+					curLeafList[ leaf + 1 ] += 1
+
+	return expandedSequences
+
+def listit( t ):
+	'''
+	Convert tuple of tuples to list of lists
+	'''
+	return list( map( listit, t ) ) if isinstance( t, ( list, tuple ) ) else t
+
+def tupleit( t ):
+	'''
+	Convert list of lists to tuple of tuples
+	'''
+	return tuple( map( tupleit, t ) ) if isinstance( t, ( tuple, list ) ) else t
+
+
+## Sub Rules
+
+usbCode       = tokenType('USBCode') >> Make.usbCode
+scanCode      = tokenType('ScanCode') >> Make.scanCode
+consCode      = tokenType('ConsCode') >> Make.consCode
+sysCode       = tokenType('SysCode') >> Make.sysCode
+indCode       = tokenType('IndCode') >> Make.indCode
+animation     = tokenType('Animation') >> Make.animation
+pixel         = tokenType('Pixel') >> Make.pixel
+pixelLayer    = tokenType('PixelLayer') >> Make.pixelLayer
+none          = tokenType('None') >> Make.none
+position      = tokenType('Position') >> Make.position
+name          = tokenType('Name')
+number        = tokenType('Number') >> Make.number
+timing        = tokenType('Timing') >> Make.timing
+comma         = tokenType('Comma')
+dash          = tokenType('Dash')
+plus          = tokenType('Plus')
+content       = tokenType('VariableContents')
+string        = tokenType('String') >> Make.string
+unString      = tokenType('String') # When the double quotes are still needed for internal processing
+seqString     = tokenType('SequenceString') >> Make.seqString
+unseqString   = tokenType('SequenceString') >> Make.unseqString # For use with variables
+pixelOperator = tokenType('PixelOperator')
+
+# Code variants
+code_begin = tokenType('CodeBegin')
+code_end   = tokenType('CodeEnd')
+
+# Specifier
+specifier_basic   = ( timing >> Make.specifierTiming ) | ( name >> Make.specifierState )
+specifier_complex = ( name + skip( operator(':') ) + timing ) >> unarg( Make.specifierState )
+specifier_state   = specifier_complex | specifier_basic
+specifier_analog  = number >> Make.specifierAnalog
+specifier_list    = skip( parenthesis('(') ) + many( ( specifier_state | specifier_analog ) + skip( maybe( comma ) ) ) + skip( parenthesis(')') )
+
+# Scan Codes
+scanCode_start     = tokenType('ScanCodeStart')
+scanCode_range     = number + skip( dash ) + number >> Make.scanCode_range
+scanCode_listElem  = number >> Make.scanCode
+scanCode_specifier = ( scanCode_range | scanCode_listElem ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+scanCode_innerList = many( scanCode_specifier + skip( maybe( comma ) ) ) >> flatten
+scanCode_expanded  = skip( scanCode_start ) + scanCode_innerList + skip( code_end ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+scanCode_elem      = scanCode + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+scanCode_combo     = oneplus( ( scanCode_expanded | scanCode_elem ) + skip( maybe( plus ) ) )
+scanCode_sequence  = oneplus( scanCode_combo + skip( maybe( comma ) ) )
+scanCode_single    = ( skip( scanCode_start ) + scanCode_listElem + skip( code_end ) ) | scanCode
+
+# Cons Codes
+consCode_start       = tokenType('ConsCodeStart')
+consCode_number      = number >> Make.consCode_number
+consCode_range       = ( consCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.consCode_range
+consCode_listElemTag = unString >> Make.consCode
+consCode_listElem    = ( consCode_number | consCode_listElemTag )
+consCode_specifier   = ( consCode_range | consCode_listElem ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+consCode_innerList   = oneplus( consCode_specifier + skip( maybe( comma ) ) ) >> flatten
+consCode_expanded    = skip( consCode_start ) + consCode_innerList + skip( code_end ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+consCode_elem        = consCode + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+
+# Sys Codes
+sysCode_start       = tokenType('SysCodeStart')
+sysCode_number      = number >> Make.sysCode_number
+sysCode_range       = ( sysCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.sysCode_range
+sysCode_listElemTag = unString >> Make.sysCode
+sysCode_listElem    = ( sysCode_number | sysCode_listElemTag )
+sysCode_specifier   = ( sysCode_range | sysCode_listElem ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+sysCode_innerList   = oneplus( sysCode_specifier + skip( maybe( comma ) ) ) >> flatten
+sysCode_expanded    = skip( sysCode_start ) + sysCode_innerList + skip( code_end ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+sysCode_elem        = sysCode + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+
+# Indicator Codes
+indCode_start       = tokenType('IndicatorStart')
+indCode_number      = number >> Make.indCode_number
+indCode_range       = ( indCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.indCode_range
+indCode_listElemTag = unString >> Make.indCode
+indCode_listElem    = ( indCode_number | indCode_listElemTag )
+indCode_specifier   = ( indCode_range | indCode_listElem ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+indCode_innerList   = oneplus( indCode_specifier + skip( maybe( comma ) ) ) >> flatten
+indCode_expanded    = skip( indCode_start ) + indCode_innerList + skip( code_end ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+indCode_elem        = indCode + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+
+# USB Codes
+usbCode_start       = tokenType('USBCodeStart')
+usbCode_number      = number >> Make.usbCode_number
+usbCode_range       = ( usbCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.usbCode_range
+usbCode_listElemTag = unString >> Make.usbCode
+usbCode_listElem    = ( usbCode_number | usbCode_listElemTag )
+usbCode_specifier   = ( usbCode_range | usbCode_listElem ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+usbCode_innerList   = oneplus( usbCode_specifier + skip( maybe( comma ) ) ) >> flatten
+usbCode_expanded    = skip( usbCode_start ) + usbCode_innerList + skip( code_end ) + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+usbCode_elem        = usbCode + maybe( specifier_list ) >> unarg( Make.specifierUnroll )
+
+# HID Codes
+hidCode_elem        = usbCode_expanded | usbCode_elem | sysCode_expanded | sysCode_elem | consCode_expanded | consCode_elem | indCode_expanded | indCode_elem
+
+usbCode_combo       = oneplus( hidCode_elem + skip( maybe( plus ) ) ) >> listElem
+usbCode_sequence    = oneplus( ( usbCode_combo | seqString ) + skip( maybe( comma ) ) ) >> oneLayerFlatten
+
+# Pixels
+pixel_start       = tokenType('PixelStart')
+pixel_range       = ( number ) + skip( dash ) + ( number ) >> unarg( Make.range )
+pixel_listElem    = number >> listElem
+pixel_innerList   = many( ( pixel_range | pixel_listElem ) + skip( maybe( comma ) ) ) >> flatten >> Make.pixel_list
+pixel_expanded    = skip( pixel_start ) + pixel_innerList + skip( code_end )
+pixel_elem        = pixel >> listElem
+
+# Pixel Layer
+pixellayer_start     = tokenType('PixelLayerStart')
+pixellayer_range     = ( number ) + skip( dash ) + ( number ) >> unarg( Make.range )
+pixellayer_listElem  = number >> listElem
+pixellayer_innerList = many( ( pixellayer_range | pixellayer_listElem ) + skip( maybe( comma ) ) ) >> flatten >> Make.pixelLayer_list
+pixellayer_expanded  = skip( pixellayer_start ) + pixellayer_innerList + skip( code_end )
+pixellayer_elem      = pixelLayer >> listElem
+
+# Pixel Channels
+pixelchan_chans = many( number + skip( operator(':') ) + number + skip( maybe( comma ) ) )
+pixelchan_elem  = ( pixel_expanded | pixel_elem ) + skip( parenthesis('(') ) + pixelchan_chans + skip( parenthesis(')') ) >> unarg( Make.pixelchan )
+
+# Pixel Mods
+pixelmod_mods  = many( maybe( pixelOperator | plus | dash ) + number + skip( maybe( comma ) ) )
+pixelmod_layer = ( pixellayer_expanded | pixellayer_elem )
+pixelmod_elem  = ( pixel_expanded | pixel_elem | pixelmod_layer ) + skip( parenthesis('(') ) + pixelmod_mods + skip( parenthesis(')') ) >> unarg( Make.pixelmod )
+
+# Pixel Capability
+pixel_capability = pixelmod_elem
+
+# Animations
+animation_start       = tokenType('AnimationStart')
+animation_name        = name
+animation_frame_range = ( number ) + skip( dash ) + ( number ) >> unarg( Make.range )
+animation_name_frame  = many( ( animation_frame_range | number ) + skip( maybe( comma ) ) ) >> maybeFlatten
+animation_def         = skip( animation_start ) + animation_name + skip( code_end ) >> Make.animation
+animation_expanded    = skip( animation_start ) + animation_name + skip( maybe( comma ) ) + animation_name_frame + skip( code_end ) >> unarg( Make.animationTrigger )
+animation_flattened   = animation_expanded >> flatten >> flatten
+animation_elem        = animation
+
+# Animation Modifier
+animation_modifier = many( ( name | number ) + maybe( skip( operator(':') ) + number ) + skip( maybe( comma ) ) )
+animation_modlist = animation_modifier >> Make.animationModlist
+
+# Animation Capability
+animation_capability = ( ( animation_def | animation_elem ) + maybe( skip( parenthesis('(') ) + animation_modifier + skip( parenthesis(')') ) ) ) >> unarg( Make.animationCapability )
+
+# Capabilities
+capFunc_argument  = number >> Make.capArg # TODO Allow for symbolic arguments, i.e. arrays and variables
+capFunc_arguments = many( capFunc_argument + skip( maybe( comma ) ) )
+capFunc_elem      = name + skip( parenthesis('(') ) + capFunc_arguments + skip( parenthesis(')') ) >> unarg( Make.capUsage ) >> listElem
+capFunc_combo     = oneplus( ( hidCode_elem | capFunc_elem | animation_capability | pixel_capability ) + skip( maybe( plus ) ) ) >> listElem
+capFunc_sequence  = oneplus( ( capFunc_combo | seqString ) + skip( maybe( comma ) ) ) >> oneLayerFlatten
+
+# Trigger / Result Codes
+triggerCode_outerList    = scanCode_sequence >> optionExpansion
+triggerUSBCode_outerList = usbCode_sequence >> optionExpansion
+resultCode_outerList     = ( ( capFunc_sequence >> optionExpansion ) | none )
+
+# Positions
+position_list = oneplus( position + skip( maybe( comma ) ) )
+
diff --git a/common/position.py b/common/position.py
new file mode 100644
index 0000000..eaf4831
--- /dev/null
+++ b/common/position.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+'''
+KLL Position Containers
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Position:
+	'''
+	Identifier position
+	Each position can have up to 6 different types of measurements
+
+	Distance:
+	x
+	y
+	z
+
+	Angular:
+	ry
+	ry
+	rz
+	'''
+	_parameters = [ 'x', 'y', 'z', 'rx', 'ry', 'rz' ]
+	x = None
+	y = None
+	z = None
+	rx = None
+	ry = None
+	rz = None
+
+	def __init( self ):
+		# Set all the _parameters to None
+		for param in self._parameters:
+			setattr( self, param, None )
+
+	def positionSet( self ):
+		'''
+		Returns True if any position has been set
+		'''
+		for param in self._parameters:
+			if getattr( self, param ) is not None:
+				return True
+		return False
+
+	def setPosition( self, positions ):
+		'''
+		Applies given list of position measurements
+
+		None signifies an undefined position which may be assigned at a later point.
+		Otherwise, it will be set to 0 at a later stage
+
+		If a position is already set, do not overwrite, expressions are read inside->out
+		'''
+		for position in positions:
+			name = position[0]
+			value = position[1]
+
+			# Check to make sure parameter is valid
+			if name not in self._parameters:
+				print( "{0} '{1}' is not a valid position parameter.".format( ERROR, name ) )
+				continue
+
+			# Only set if None
+			if getattr( self, name ) is None:
+				setattr( self, name, value )
+
+	def strPosition( self ):
+		'''
+		__repr__ of Position when multiple inheritance is used
+		'''
+		output = ""
+
+		# Check each of the position parameters, only show the ones that are not None
+		count = 0
+		for param in self._parameters:
+			value = getattr( self, param )
+			if value is not None:
+				if count > 0:
+					output += ","
+				output += "{0}:{1}".format( param, value )
+				count += 1
+
+		return output
+
+	def __repr__( self ):
+		return self.strPosition()
+
diff --git a/common/schedule.py b/common/schedule.py
new file mode 100644
index 0000000..e0d22e4
--- /dev/null
+++ b/common/schedule.py
@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+'''
+KLL Schedule Containers
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Time:
+	'''
+	Time parameter
+	'''
+	def __init__( self, time, unit ):
+		self.time = time
+		self.unit = unit
+
+	def __repr__( self ):
+		return "{0}{1}".format( self.time, self.unit )
+
+
+class Schedule:
+	'''
+	Identifier schedule
+	Each schedule may have multiple parameters configuring how the element is scheduled
+
+	Used for trigger and result elements
+	'''
+	def __init__( self ):
+		self.parameters = None
+
+	def setSchedule( self, parameters ):
+		'''
+		Applies given list of Schedule Parameters to Schedule
+
+		None signifies an undefined schedule which allows free-form scheduling
+		at either a later stage or at the convenience of the device firmware/driver
+
+		If schedule is already set, do not overwrite, expressions are read inside->out
+		'''
+		# Ignore if already set
+		if self.parameters is not None:
+			return
+
+		self.parameters = parameters
+
+	def strSchedule( self ):
+		'''
+		__repr__ of Schedule when multiple inheritance is used
+		'''
+		output = ""
+		if self.parameters is not None:
+			for index, param in enumerate( self.parameters ):
+				if index > 0:
+					output += ","
+				output += "{0}".format( param )
+		return output
+
+	def __repr__( self ):
+		return self.strSchedule()
+
+
+class ScheduleParam:
+	'''
+	Schedule parameter
+
+	In the case of a Timing parameter, the base type is unknown and must be inferred later
+	'''
+	def __init__( self, state, timing=None ):
+		self.state = state
+		self.timing = timing
+
+		# Mutate class into the desired type
+		if self.state in ['P', 'H', 'R', 'O', 'UP', 'UR']:
+			self.__class__ = ButtonScheduleParam
+		elif self.state in ['A', 'On', 'D', 'Off']:
+			self.__class__ = IndicatorScheduleParam
+		elif self.state is None and self.timing is not None:
+			pass
+		else:
+			print( "{0} Invalid ScheduleParam state '{1}'".format( ERROR, self.state ) )
+
+	def setTiming( self, timing ):
+		'''
+		Set parameter timing
+		'''
+		self.timing = timing
+
+	def __repr__( self ):
+		output = ""
+		if self.state is None and self.timing is not None:
+			output += "{0}".format( self.timing )
+		else:
+			output += "??"
+			print( "{0} Unknown ScheduleParam state '{1}'".format( ERROR, self.state ) )
+		return output
+
+
+class ButtonScheduleParam( ScheduleParam ):
+	'''
+	Button Schedule Parameter
+
+	Accepts:
+	P  - Press
+	H  - Hold
+	R  - Release
+	O  - Off
+	UP - Unique Press
+	UR - Unique Release
+
+	Timing specifiers are valid.
+	Validity of specifiers are context dependent, and may error at a later stage, or be stripped altogether
+	'''
+	def __repr__( self ):
+		output = "{0}".format( self.state )
+		if self.timing is not None:
+			output += ":{0}".format( self.timing )
+		return output
+
+
+class AnalogScheduleParam( ScheduleParam ):
+	'''
+	Analog Schedule Parameter
+
+	Accepts:
+	Value from 0 to 100, indicating a percentage pressed
+
+	XXX: Might be useful to accept decimal percentages
+	'''
+	def __init__( self, state ):
+		self.state = state
+
+	def __repr__( self ):
+		return "Analog({0})".format( self.state )
+
+
+class IndicatorScheduleParam( ScheduleParam ):
+	'''
+	Indicator Schedule Parameter
+
+	Accepts:
+	A   - Activate
+	On
+	D   - Deactivate
+	Off
+
+	Timing specifiers are valid.
+	Validity of specifiers are context dependent, and may error at a later stage, or be stripped altogether
+	'''
+	def __repr__( self ):
+		output = "{0}".format( self.state )
+		if self.timing is not None:
+			output += ":{0}".format( self.timing )
+		return output
+
diff --git a/common/stage.py b/common/stage.py
new file mode 100644
index 0000000..262f010
--- /dev/null
+++ b/common/stage.py
@@ -0,0 +1,2064 @@
+#!/usr/bin/env python3
+'''
+KLL Compiler Stage Definitions
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+from multiprocessing.dummy import Pool as ThreadPool
+
+import io
+import os
+import re
+import sys
+
+import common.context as context
+import common.expression as expression
+import common.file as file
+
+import emitters.emitters as emitters
+
+from funcparserlib.lexer  import make_tokenizer, Token, LexerError
+from funcparserlib.parser import many, oneplus, maybe, skip, NoParseError, Parser_debug
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+ansi_escape = re.compile(r'\x1b[^m]*m')
+
+
+
+### Classes ###
+
+class ControlStage:
+	'''
+	Top-level Stage
+
+	Controls the order in which each stage is processed
+	'''
+	def __init__( self ):
+		'''
+		Initialize stage objects and control variables
+		'''
+
+		# Initialized in process order
+		# NOTE: Only unique classes in this list, otherwise stage() will get confused
+		self.stages = [
+			CompilerConfigurationStage( self ),
+			FileImportStage( self ),
+			PreprocessorStage( self ),
+			OperationClassificationStage( self ),
+			OperationSpecificsStage( self ),
+			OperationOrganizationStage( self ),
+			DataOrganizationStage( self ),
+			DataFinalizationStage( self ),
+			DataAnalysisStage( self ),
+			CodeGenerationStage( self ),
+			#ReportGenerationStage( self ),
+		]
+
+		self.git_rev = None
+		self.git_changes = None
+		self.version = None
+
+	def stage( self, context_str ):
+		'''
+		Returns the stage object of the associated string name of the class
+
+		@param context_str: String name of the class of the stage e.g. CompilerConfigurationStage
+		'''
+		return [ stage for stage in self.stages if type( stage ).__name__ is context_str ][0]
+
+	def command_line_args( self, args ):
+		'''
+		Capture commmand line arguments for each processing stage
+
+		@param args: Name space of processed arguments
+		'''
+		for stage in self.stages:
+			stage.command_line_args( args )
+
+	def command_line_flags( self, parser ):
+		'''
+		Prepare group parser for each processing stage
+
+		@param parser: argparse setup object
+		'''
+		for stage in self.stages:
+			stage.command_line_flags( parser )
+
+	def process( self ):
+		'''
+		Main processing section
+		Initializes each stage in order.
+		Each stage must complete before the next one begins.
+		'''
+		# Run report even if stage doesn't complete
+		run_report = False
+
+		for stage in self.stages:
+			stage.process()
+
+			# Make sure stage has successfully completed
+			if stage.status() != 'Completed':
+				print( "{0} Invalid stage status '{1}' for '{2}'.".format(
+					ERROR,
+					stage.status(),
+					stage.__class__.__name__,
+				) )
+				run_report = True
+				break
+
+		# Only need to explicitly run reports if there was a stage problem
+		# Otherwise reports are run automatically
+		if run_report:
+			# TODO
+			sys.exit( 1 )
+
+
+class Stage:
+	'''
+	Base Stage Class
+	'''
+	def __init__( self, control ):
+		'''
+		Stage initialization
+
+		@param control: ControlStage object, used to access data from other stages
+		'''
+		self.control = control
+		self.color = False
+		self._status = 'Queued'
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.command_line_args.__name__,
+				type( self ).__name__
+			)
+		)
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.command_line_flags.__name__,
+				type( self ).__name__
+			)
+		)
+
+	def process( self ):
+		'''
+		Main procesing section
+		'''
+		self._status = 'Running'
+
+		print( "{0} '{1}' '{2}' has not been implemented yet"
+			.format(
+				WARNING,
+				self.process.__name__,
+				type( self ).__name__
+			)
+		)
+
+		self._status = 'Completed'
+
+	def status( self ):
+		'''
+		Returns the current status of the Stage
+
+		Values:
+		Queued     - Not yet run
+		Running    - Currently running
+		Completed  - Successfully completed
+		Incomplete - Unsuccessfully completed
+		'''
+		return self._status
+
+
+
+class CompilerConfigurationStage( Stage ):
+	'''
+	Compiler Configuration Stage
+
+	* Does initial setup of KLL compiler.
+	* Handles any global configuration that must be done before parsing can begin
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize compiler configuration variables
+		'''
+		super().__init__( control )
+
+		self.color   = "auto"
+		self.jobs    = os.cpu_count()
+		self.pool    = None
+
+		# Build list of emitters
+		self.emitters = emitters.Emitters( control )
+		self.emitter = self.emitters.emitter_default()
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.emitter = args.emitter
+		self.color   = args.color
+		self.jobs    = args.jobs
+
+		# Validate color argument before processing
+		if self.color not in ['auto', 'always', 'never' ]:
+			print( "Invalid color option '{0}'".format( self.color ) )
+			sys.exit( 2 )
+
+		# TODO Detect whether colorization should be used
+		self.color = self.color in ['auto', 'always']
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mCompiler Configuration\033[0m')
+
+		# Optional Arguments
+		group.add_argument( '--emitter', type=str, default=self.emitter,
+			help="Specify target emitter for the KLL compiler.\n"
+			"\033[1mDefault\033[0m: {0}\n"
+			"\033[1mOptions\033[0m: {1}".format( self.emitter, self.emitters.emitter_list() )
+		)
+		group.add_argument( '--color', type=str, default=self.color,
+			help="Specify debug colorizer mode.\n"
+			"\033[1mDefault\033[0m: {0}\n"
+			"\033[1mOptions\033[0m: auto, always, never (auto attempts to detect support)".format( self.color )
+		)
+		group.add_argument( '--jobs', type=int, default=self.jobs,
+			help="Specify max number of threads to use.\n"
+			"\033[1mDefault\033[0m: {0}".format( self.jobs )
+		)
+
+	def process( self ):
+		'''
+		Compiler Configuration Processing
+		'''
+		self._status = 'Running'
+
+		# Initialize thread pool
+		self.pool = ThreadPool( self.jobs )
+
+		self._status = 'Completed'
+
+
+class FileImportStage( Stage ):
+	'''
+	FIle Import Stage
+
+	* Loads text of all files into memory
+	* Does initial sorting of KLL Contexts based upon command line arguments
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize file storage datastructures and variables
+		'''
+		super().__init__( control )
+
+		# These lists are order sensitive
+		self.generic_files = []
+		self.config_files  = []
+		self.base_files    = []
+		self.default_files = []
+
+		# This is a list of lists, each sub list is another layer in order from 1 to max
+		self.partial_files = []
+
+		# List of all files contained in KLLFile objects
+		self.kll_files = []
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.generic_files = args.generic
+		self.config_files  = args.config
+		self.base_files    = args.base
+		self.default_files = args.default
+		self.partial_files = args.partial
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mFile Context Configuration\033[0m')
+
+		# Positional Arguments
+		group.add_argument( 'generic', type=str, nargs='*', default=self.generic_files,
+			help="Auto-detect context of .kll files, defaults to a base map configuration."
+		)
+
+		# Optional Arguments
+		group.add_argument( '--config', type=str, nargs='+', default=self.config_files,
+			help="Specify base configuration .kll files, earliest priority"
+		)
+		group.add_argument( '--base', type=str, nargs='+', default=self.base_files,
+			help="Specify base map configuration, applied after config .kll files.\n"
+			"The base map is applied prior to all default and partial maps and is used as the basis for them."
+		)
+		group.add_argument( '--default', type=str, nargs='+', default=self.default_files,
+			help="Specify .kll files to layer on top of the default map to create a combined map.\n"
+			"Also known as layer 0."
+		)
+		group.add_argument( '--partial', type=str, nargs='+', action='append', default=self.partial_files,
+			help="Specify .kll files to generate partial map, multiple files per flag.\n"
+			"Each -p defines another partial map.\n"
+			"Base .kll files (that define the scan code maps) must be defined for each partial map."
+		)
+
+	def init_kllfile( self, path, file_context ):
+		'''
+		Prepares a KLLFile object with the given context
+
+		@path:         Path to the KLL file
+		@file_context: Type of file context, e.g. DefaultMapContext
+		'''
+		return file.KLLFile( path, file_context )
+
+	def process( self ):
+		'''
+		Process each of the files, sorting them by command line argument context order
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Process each type of file
+		# Iterates over each file in the context list and creates a KLLFile object with a context and path
+		self.kll_files += map(
+			lambda path: self.init_kllfile( path, context.GenericContext() ),
+			self.generic_files
+		)
+		self.kll_files += map(
+			lambda path: self.init_kllfile( path, context.ConfigurationContext() ),
+			self.config_files
+		)
+		self.kll_files += map(
+			lambda path: self.init_kllfile( path, context.BaseMapContext() ),
+			self.base_files
+		)
+		self.kll_files += map(
+			lambda path: self.init_kllfile( path, context.DefaultMapContext() ),
+			self.default_files
+		)
+
+		# Partial Maps require a third parameter which specifies which layer it's in
+		for layer, files in enumerate( self.partial_files ):
+			self.kll_files += map(
+				lambda path: self.init_kllfile( path, context.PartialMapContext( layer ) ),
+				files
+			)
+
+		# Validate that all the file paths exist, exit if any of the checks fail
+		if False in [ path.check() for path in self.kll_files ]:
+			self._status = 'Incomplete'
+			return
+
+		# Now that we have a full list of files and their given context, we can now read the files into memory
+		# Uses the thread pool to speed up processing
+		# Make sure processing was successful before continuing
+		pool = self.control.stage('CompilerConfigurationStage').pool
+		if False in pool.map( lambda kll_file: kll_file.read(), self.kll_files ):
+			self._status = 'Incomplete'
+			return
+
+		self._status = 'Completed'
+
+
+class PreprocessorStage( Stage ):
+	'''
+	Preprocessor Stage
+
+	* Does initial split and decision of contexts
+	* Handles Preprocessor part of KLL
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize preprocessor configuration variables
+		'''
+		super().__init__( control )
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		#group = parser.add_argument_group('\033[1mPreprocessor Configuration\033[0m')
+
+	def seed_context( self, kll_file ):
+		'''
+		Build list of context
+
+		TODO Update later for proper preprocessor
+		Adds data from KLFile into the Context
+		'''
+		kll_file.context.initial_context( kll_file.lines, kll_file.data, kll_file )
+
+	def process( self ):
+		'''
+		Preprocessor Execution
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire thread pool
+		pool = self.control.stage('CompilerConfigurationStage').pool
+
+		# TODO
+		# Once the KLL Spec has preprocessor commands, there may be a risk of infinite/circular dependencies
+		# Please add a non-invasive way to avoid/warn/stop in this case -HaaTa
+
+		# First, since initial contexts have been populated, populate details
+		# TODO
+		# This step will change once preprocessor commands have been added
+
+
+		# Simply, this just takes the imported file data (KLLFile) and puts it in the context container
+		kll_files = self.control.stage('FileImportStage').kll_files
+		if False in pool.map( self.seed_context, kll_files ):
+			self._status = 'Incomplete'
+			return
+
+		# Next, tokenize and parser the preprocessor KLL commands.
+		# NOTE: This may result in having to create more KLL Contexts and tokenize/parse again numerous times over
+		# TODO
+
+		self._status = 'Completed'
+
+
+class OperationClassificationStage( Stage ):
+	'''
+	Operation Classification Stage
+
+	* Sorts operations by type based on operator
+	* Tokenizes only operator pivots and left/right arguments
+	* Further tokenization and parsing occurs at a later stage
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize operation classification stage
+		'''
+		super().__init__( control )
+
+		self.tokenized_data = []
+		self.contexts = []
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		#group = parser.add_argument_group('\033[1mOperation Classification Configuration\033[0m')
+
+	def merge_tokens( self, token_list, token_type ):
+		'''
+		Merge list of tokens into a single token
+
+		@param token_list: List of tokens
+		@param token_type: String name of token type
+		'''
+		# Initial token parameters
+		ret_token = Token( token_type, '' )
+
+		# Set start/end positions of token
+		ret_token.start = token_list[0].start
+		ret_token.end   = token_list[-1].end
+
+		# Build token value
+		for token in token_list:
+			ret_token.value += token.value
+
+		return ret_token
+
+	def tokenize( self, kll_context ):
+		'''
+		Tokenize a single string
+
+		@param kll_context: KLL Context containing file data
+		'''
+		ret = True
+
+		# Basic Tokens Spec
+		spec = [
+			( 'Comment',          ( r' *#.*', ) ),
+			( 'Space',            ( r'[ \t]+', ) ),
+			( 'NewLine',          ( r'[\r\n]+', ) ),
+
+			# Tokens that will be grouped together after tokenization
+			# Ignored at this stage
+			# This is required to isolate the Operator tags
+			( 'Misc',             ( r'r?[xyz]:[0-9]+(.[0-9]+)?', ) ), # Position context
+			( 'Misc',             ( r'\([^\)]*\)', ) ), # Parenthesis context
+			( 'Misc',             ( r'\[[^\]]*\]', ) ), # Square bracket context
+			( 'Misc',             ( r'"[^"]*"', ) ),    # Double quote context
+			( 'Misc',             ( r"'[^']*'", ) ),    # Single quote context
+
+			( 'Operator',         ( r'=>|<=|i:\+|i:-|i::|i:|:\+|:-|::|:|=', ) ),
+			( 'EndOfLine',        ( r';', ) ),
+
+			# Everything else to be ignored at this stage
+			( 'Misc',             ( r'.', ) ),          # Everything else
+		]
+
+		# Tokens to filter out of the token stream
+		#useless = [ 'Space', 'Comment' ]
+		useless = [ 'Comment', 'NewLine' ]
+
+		# Build tokenizer that appends unknown characters to Misc Token groups
+		# NOTE: This is technically slower processing wise, but allows for multi-stage tokenization
+		#       Which in turn allows for parsing and tokenization rules to be simplified
+		tokenizer = make_tokenizer( spec )
+
+		# Tokenize and filter out useless tokens
+		try:
+			tokens = [ x for x in tokenizer( kll_context.data ) if x.type not in useless ]
+		except LexerError as err:
+			print( err )
+			print( "{0} {1}:tokenize -> {2}:{3}".format(
+				ERROR,
+				self.__class__.__name__,
+				kll_context.parent.path,
+				err.place[0],
+			) )
+
+		# Merge Misc tokens delimited by Operator and EndOfLine tokens
+		kll_context.classification_token_data = []
+		new_token = []
+		last_operator = None
+		for token in tokens:
+			# Check for delimiter, append new_token if ready
+			if token.type in ['EndOfLine', 'Operator']:
+				# Determine the token type
+				token_type = 'LOperatorData'
+				if token.type is 'EndOfLine':
+					token_type = 'ROperatorData'
+
+				# If this is a 'misplaced' operator, set as Misc
+				if token_type == last_operator:
+					token.type = 'Misc'
+					new_token.append( token )
+					continue
+
+				if len( new_token ) > 0:
+					# Build new token
+					kll_context.classification_token_data.append(
+						self.merge_tokens( new_token, token_type )
+					)
+					new_token = []
+				kll_context.classification_token_data.append( token )
+				last_operator = token_type
+
+			# Collect Misc tokens
+			elif token.type in ['Misc', 'Space']:
+				new_token.append( token )
+
+			# Invalid token for this stage
+			else:
+				print( "{0} Invalid token '{1}' for '{2}'".format(
+					ERROR,
+					token,
+					type( self ).__name__,
+				) )
+				ret = False
+
+		return ret
+
+	def sort( self, kll_context ):
+		'''
+		Sorts tokenized data into expressions
+		LOperatorData + Operator + ROperatorData + EndOfLine
+
+		@param kll_context: KLL Context, contains tokenized data
+		'''
+		ret = True
+
+		def validate_token( token, token_type ):
+			'''
+			Validate token
+
+			@param token: Given token to validate
+			@param token_type: Token type to validate against
+
+			@return True if the token is correct
+			'''
+			ret = token.type is token_type
+
+			# Error message
+			if not ret:
+				print( "Expected: '{0}' got '{1}':{2} '{3}'".format(
+					token_type,
+					token.type,
+					token._pos_str(),
+					token.value,
+				) )
+
+			return ret
+
+		tokens = kll_context.classification_token_data
+		for index in range( 0, len( tokens ), 4 ):
+			# Make sure enough tokens exist
+			if index + 3 >= len( tokens ):
+				print( "Not enough tokens left: {0}".format( tokens[index:] ) )
+				print( "Expected: LOperatorData, Operator, ROperatorData, EndOfLine" )
+				print( "{0} {1}:sort -> {2}:{3}".format(
+					ERROR,
+					self.__class__.__name__,
+					kll_context.parent.path,
+					tokens[-1].start[0],
+				) )
+				ret = False
+				break
+
+			# Validate the tokens are what was expected
+			ret = validate_token( tokens[index], 'LOperatorData' ) and ret
+			ret = validate_token( tokens[index + 1], 'Operator' ) and ret
+			ret = validate_token( tokens[index + 2], 'ROperatorData' ) and ret
+			ret = validate_token( tokens[index + 3], 'EndOfLine' ) and ret
+
+			# Append expression
+			kll_context.expressions.append(
+				expression.Expression( tokens[index], tokens[index + 1], tokens[index + 2], kll_context )
+			)
+
+		return ret
+
+	def process( self ):
+		'''
+		Compiler Configuration Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire thread pool
+		pool = self.control.stage('CompilerConfigurationStage').pool
+
+		# Get list of KLLFiles
+		kll_files = self.control.stage('FileImportStage').kll_files
+
+		# Build list of contexts
+		self.contexts = [ kll_file.context for kll_file in kll_files ]
+
+		# Tokenize operators
+		# TODO
+		#      Once preprocessor includes are implemented use a second kll_files list
+		#      This way processing doesn't have to be recursive for a few stages -HaaTa
+		if False in pool.map( self.tokenize, self.contexts ):
+			self._status = 'Incomplete'
+			return
+
+		# Sort elements into expressions
+		# LOperatorData + Operator + ROperatorData + EndOfLine
+		if False in pool.map( self.sort, self.contexts ):
+			self._status = 'Incomplete'
+			return
+
+		self._status = 'Completed'
+
+
+class OperationSpecificsStage( Stage ):
+	'''
+	Operation Specifics Stage
+
+	* For each sorted operation, tokenize and parse the left/right arguments
+	* Data is stored with the operation, but no context is given to the data beyond the argument types
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize operation specifics stage
+		'''
+		super().__init__( control )
+
+		self.parser_debug       = False
+		self.parser_token_debug = False
+		self.token_debug        = False
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.parser_debug       = args.parser_debug
+		self.parser_token_debug = args.parser_token_debug
+		self.token_debug        = args.token_debug
+
+		# Auto-set parser_debug if parser_token_debug is set
+		if self.parser_token_debug:
+			self.parser_debug = True
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mOperation Specifics Configuration\033[0m')
+
+		# Optional Arguments
+		group.add_argument( '--parser-debug', action='store_true', default=self.parser_debug,
+			help="Enable parser debug output.\n",
+		)
+		group.add_argument( '--parser-token-debug', action='store_true', default=self.parser_token_debug,
+			help="Enable parser-stage token debug output.\n",
+		)
+		group.add_argument( '--token-debug', action='store_true', default=self.token_debug,
+			help="Enable tokenization debug output.\n",
+		)
+
+	## Tokenizers ##
+	def tokenize_base( self, kll_expression, lspec, rspec ):
+		'''
+		Base tokenization logic for this stage
+
+		@param kll_expression: KLL expression to tokenize
+		@param lspec: Regex tokenization spec for the left parameter
+		@param rspec: Regex tokenization spec for the right parameter
+
+		@return False if a LexerError was detected
+		'''
+		# Build tokenizers for lparam and rparam
+		ltokenizer = make_tokenizer( lspec )
+		rtokenizer = make_tokenizer( rspec )
+
+		# Tokenize lparam and rparam
+		# Ignore the generators, not useful in this case (i.e. use list())
+		err_pos = [] # Error positions
+		try:
+			kll_expression.lparam_sub_tokens = list( ltokenizer( kll_expression.lparam_token.value ) )
+		except LexerError as err:
+			# Determine place in constructed expression
+			err_pos.append( err.place[1] )
+			print( type( err ).__name__, err )
+
+		try:
+			kll_expression.rparam_sub_tokens = list( rtokenizer( kll_expression.rparam_token.value ) )
+		except LexerError as err:
+			# Determine place in constructed expression
+			err_pos.append( err.place[1] + kll_expression.rparam_start() )
+			print( type( err ).__name__, err )
+
+		# Display more information if any errors were detected
+		if len( err_pos ) > 0:
+			print( kll_expression.point_chars( err_pos ) )
+			return False
+
+		return True
+
+	def tokenize_name_association( self, kll_expression ):
+		'''
+		Tokenize lparam and rparam in name association expressions
+		<lparam> => <rparam>;
+		'''
+
+		# Define tokenization regex
+		lspec = [
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+			( 'Space',            ( r'[ \t]+', ) ),
+		]
+
+		rspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+			( 'Parenthesis',      ( r'\(|\)', ) ),
+			( 'Operator',         ( r':', ) ),
+			( 'Comma',            ( r',', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+		]
+
+		# Tokenize, expression stores the result, status is returned
+		return self.tokenize_base( kll_expression, lspec, rspec )
+
+	def tokenize_data_association( self, kll_expression ):
+		'''
+		Tokenize lparam and rparam in data association expressions
+		<lparam> <= <rparam>;
+		'''
+
+		# Define tokenization regex
+		lspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'ScanCode',         ( r'S((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'ScanCodeStart',    ( r'S\[', ) ),
+			( 'Pixel',            ( r'P((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelStart',       ( r'P\[', ) ),
+			( 'Animation',        ( r'A"[^"]+"', ) ),
+			( 'AnimationStart',   ( r'A\[', ) ),
+			( 'CodeBegin',        ( r'\[', ) ),
+			( 'CodeEnd',          ( r'\]', ) ),
+			( 'Position',         ( r'r?[xyz]:[0-9]+(.[0-9]+)?', ) ),
+
+			( 'Comma',            ( r',', ) ),
+			( 'Dash',             ( r'-', ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+		]
+
+		rspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'Pixel',            ( r'P((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelStart',       ( r'P\[', ) ),
+			( 'PixelLayer',       ( r'PL((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelLayerStart',  ( r'PL\[', ) ),
+			( 'Animation',        ( r'A"[^"]+"', ) ),
+			( 'AnimationStart',   ( r'A\[', ) ),
+			( 'CodeBegin',        ( r'\[', ) ),
+			( 'CodeEnd',          ( r'\]', ) ),
+			( 'Position',         ( r'r?[xyz]:[0-9]+(.[0-9]+)?', ) ),
+			( 'PixelOperator',    ( r'(\+:|-:|>>|<<)', ) ),
+
+			( 'Operator',         ( r':', ) ),
+			( 'Comma',            ( r',', ) ),
+			( 'Dash',             ( r'-', ) ),
+			( 'Plus',             ( r'\+', ) ),
+			( 'Parenthesis',      ( r'\(|\)', ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+		]
+
+		# Tokenize, expression stores the result, status is returned
+		return self.tokenize_base( kll_expression, lspec, rspec )
+
+	def tokenize_assignment( self, kll_expression ):
+		'''
+		Tokenize lparam and rparam in assignment expressions
+		<lparam> = <rparam>;
+		'''
+
+		# Define tokenization regex
+		lspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+			( 'CodeBegin',        ( r'\[', ) ),
+			( 'CodeEnd',          ( r'\]', ) ),
+		]
+
+		rspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'String',           ( r'"[^"]*"', ) ),
+			( 'SequenceString',   ( r"'[^']*'", ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+			( 'VariableContents', ( r'''[^"' ;:=>()]+''', ) ),
+		]
+
+		# Tokenize, expression stores the result, status is returned
+		return self.tokenize_base( kll_expression, lspec, rspec )
+
+	def tokenize_mapping( self, kll_expression ):
+		'''
+		Tokenize lparam and rparam in mapping expressions
+
+		<lparam>  :  <rparam>; # Set mapping
+		<lparam>  :+ <rparam>; # Mappping append
+		<lparam>  :- <rparam>; # Mapping removal
+		<lparam>  :: <rparam>; # Replace mapping (does nothing if nothing to replace)
+
+		Isolated versions of mappings
+		When expressions are evalutated during runtime, any non-isolated mapping expressions are cancelled
+		<lparam> i:  <rparam>;
+		<lparam> i:+ <rparam>;
+		<lparam> i:- <rparam>;
+		<lparam> i:: <rparam>;
+		'''
+
+		# Define tokenization regex
+		lspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'USBCode',          ( r'U(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'USBCodeStart',     ( r'U\[', ) ),
+			( 'ConsCode',         ( r'CONS(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'ConsCodeStart',    ( r'CONS\[', ) ),
+			( 'SysCode',          ( r'SYS(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'SysCodeStart',     ( r'SYS\[', ) ),
+			( 'ScanCode',         ( r'S((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'ScanCodeStart',    ( r'S\[', ) ),
+			( 'IndCode',          ( r'I(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'IndicatorStart',   ( r'I\[', ) ),
+			( 'Pixel',            ( r'P((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelStart',       ( r'P\[', ) ),
+			( 'Animation',        ( r'A"[^"]+"', ) ),
+			( 'AnimationStart',   ( r'A\[', ) ),
+			( 'CodeBegin',        ( r'\[', ) ),
+			( 'CodeEnd',          ( r'\]', ) ),
+
+			( 'String',           ( r'"[^"]*"', ) ),
+			( 'SequenceString',   ( r"'[^']*'", ) ),
+
+			( 'Operator',         ( r':', ) ),
+			( 'Comma',            ( r',', ) ),
+			( 'Dash',             ( r'-', ) ),
+			( 'Plus',             ( r'\+', ) ),
+			( 'Parenthesis',      ( r'\(|\)', ) ),
+			( 'Timing',           ( r'[0-9]+(.[0-9]+)?((s)|(ms)|(us)|(ns))', ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+		]
+
+		rspec = [
+			( 'Space',            ( r'[ \t]+', ) ),
+
+			( 'USBCode',          ( r'U(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'USBCodeStart',     ( r'U\[', ) ),
+			( 'ConsCode',         ( r'CONS(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'ConsCodeStart',    ( r'CONS\[', ) ),
+			( 'SysCode',          ( r'SYS(("[^"]+")|(0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'SysCodeStart',     ( r'SYS\[', ) ),
+			( 'ScanCode',         ( r'S((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'ScanCodeStart',    ( r'S\[', ) ),
+			( 'Pixel',            ( r'P((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelStart',       ( r'P\[', ) ),
+			( 'PixelLayer',       ( r'PL((0x[0-9a-fA-F]+)|([0-9]+))', ) ),
+			( 'PixelLayerStart',  ( r'PL\[', ) ),
+			( 'Animation',        ( r'A"[^"]+"', ) ),
+			( 'AnimationStart',   ( r'A\[', ) ),
+			( 'CodeBegin',        ( r'\[', ) ),
+			( 'CodeEnd',          ( r'\]', ) ),
+
+			( 'String',           ( r'"[^"]*"', ) ),
+			( 'SequenceString',   ( r"'[^']*'", ) ),
+
+			( 'None',             ( r'None', ) ),
+
+			( 'Operator',         ( r':', ) ),
+			( 'Comma',            ( r',', ) ),
+			( 'Dash',             ( r'-', ) ),
+			( 'Plus',             ( r'\+', ) ),
+			( 'Parenthesis',      ( r'\(|\)', ) ),
+			( 'Timing',           ( r'[0-9]+(.[0-9]+)?((s)|(ms)|(us)|(ns))', ) ),
+			( 'Number',           ( r'-?(0x[0-9a-fA-F]+)|(0|([1-9][0-9]*))', ) ),
+			( 'Name',             ( r'[A-Za-z_][A-Za-z_0-9]*', ) ),
+		]
+
+		# Tokenize, expression stores the result, status is returned
+		return self.tokenize_base( kll_expression, lspec, rspec )
+
+	## Parsers ##
+	def parse_base( self, kll_expression, parse_expression, quiet ):
+		'''
+		Base parsing logic
+
+		@param kll_expression: Expression being parsed, contains tokens
+		@param parse_expression: Parse tree expression that understands the group of tokens
+		@param quiet: Reduces verbosity, used when re-running an errored command in debug mode
+
+		@return: False if parsing wasn't successful
+		'''
+		ret = True
+
+		try:
+			# Since the expressions have already been pre-organized, we only expect a single expression at a time
+			ret = parse_expression.parse( kll_expression.final_tokens() )
+
+			# Parse intepretation error, more info is provided by the specific parse intepreter
+			if not ret and not quiet:
+				print( kll_expression.final_tokens() )
+
+		except NoParseError as err:
+			if not quiet:
+				print( kll_expression.final_tokens() )
+				print( err )
+			ret = False
+
+		return ret
+
+	def parse_name_association( self, kll_expression, quiet=False ):
+		'''
+		Parse name association expressions
+		<lparam> => <rparam>;
+		'''
+		# Import parse elements/lambda functions
+		from common.parse import (
+			comma,
+			name,
+			number,
+			operator,
+			parenthesis,
+			unarg,
+			Make,
+		)
+
+		# Name Association
+		# <capability name> => <c function>;
+		capability_arguments  = name + skip( operator(':') ) + number + skip( maybe( comma ) ) >> unarg( Make.capArg )
+		capability_expression = name + skip( operator('=>') ) + name + skip( parenthesis('(') ) + many( capability_arguments ) + skip( parenthesis(')') ) >> unarg( kll_expression.capability )
+
+		# Name Association
+		# <define name> => <c define>;
+		define_expression = name + skip( operator('=>') ) + name >> unarg( kll_expression.define )
+
+		# Top-level Parser
+		expr = (
+			capability_expression |
+			define_expression
+		)
+
+		return self.parse_base( kll_expression, expr, quiet )
+
+	def parse_data_association( self, kll_expression, quiet=False ):
+		'''
+		Parse data association expressions
+		<lparam> <= <rparam>;
+		'''
+		from common.parse import (
+			animation_def,
+			animation_elem,
+			animation_flattened,
+			animation_modlist,
+			comma,
+			flatten,
+			operator,
+			pixel_elem,
+			pixel_expanded,
+			pixelmod_elem,
+			position_list,
+			triggerCode_outerList,
+			unarg,
+		)
+
+		# Data Association
+		# <animation>       <= <modifiers>;
+		# <animation frame> <= <modifiers>;
+		animation_expression      = ( animation_elem | animation_def ) + skip( operator('<=') ) + animation_modlist >> unarg( kll_expression.animation )
+		animationFrame_expression = animation_flattened + skip( operator('<=') ) + many( pixelmod_elem + skip( maybe( comma ) ) ) >> unarg( kll_expression.animationFrame )
+
+		# Data Association
+		# <pixel> <= <position>;
+		pixelPosition_expression = ( pixel_expanded | pixel_elem ) + skip( operator('<=') ) + position_list >> unarg( kll_expression.pixelPosition )
+
+		# Data Association
+		# <scancode> <= <position>;
+		scanCodePosition_expression = ( triggerCode_outerList >> flatten >> flatten ) + skip( operator('<=') ) + position_list >> unarg( kll_expression.scanCodePosition )
+
+		# Top-level Parser
+		expr = (
+			animation_expression |
+			animationFrame_expression |
+			pixelPosition_expression |
+			scanCodePosition_expression
+		)
+
+		return self.parse_base( kll_expression, expr, quiet )
+
+	def parse_assignment( self, kll_expression, quiet=False ):
+		'''
+		Parse assignment expressions
+		<lparam> = <rparam>;
+		'''
+		# Import parse elements/lambda functions
+		from common.parse import (
+			code_begin,
+			code_end,
+			comma,
+			content,
+			dash,
+			name,
+			number,
+			operator,
+			string,
+			unarg,
+			unseqString,
+		)
+
+		# Assignment
+		# <variable> = <variable contents>;
+		variable_contents   = name | content | string | number | comma | dash | unseqString
+		variable_expression = name + skip( operator('=') ) + oneplus( variable_contents ) >> unarg( kll_expression.variable )
+
+		# Array Assignment
+		# <variable>[]        = <space> <separated> <list>;
+		# <variable>[<index>] = <index element>;
+		array_expression = name + skip( code_begin ) + maybe( number ) + skip( code_end ) + skip( operator('=') ) + oneplus( variable_contents ) >> unarg( kll_expression.array )
+
+		# Top-level Parser
+		expr = (
+			array_expression |
+			variable_expression
+		)
+
+		return self.parse_base( kll_expression, expr, quiet )
+
+	def parse_mapping( self, kll_expression, quiet=False ):
+		'''
+		Parse mapping expressions
+
+		<lparam>  :  <rparam>; # Set mapping
+		<lparam>  :+ <rparam>; # Mappping append
+		<lparam>  :- <rparam>; # Mapping removal
+		<lparam>  :: <rparam>; # Replace mapping (does nothing if nothing to replace)
+
+		Isolated versions of mappings
+		When expressions are evalutated during runtime, any non-isolated mapping expressions are cancelled
+		<lparam> i:  <rparam>;
+		<lparam> i:+ <rparam>;
+		<lparam> i:- <rparam>;
+		<lparam> i:: <rparam>;
+		'''
+		# Import parse elements/lambda functions
+		from common.parse import (
+			animation_expanded,
+			none,
+			operator,
+			pixelchan_elem,
+			resultCode_outerList,
+			scanCode_single,
+			triggerCode_outerList,
+			triggerUSBCode_outerList,
+			unarg,
+		)
+
+		# Mapping
+		# <trigger> : <result>;
+		operatorTriggerResult = operator(':') | operator(':+') | operator(':-') | operator('::') | operator('i:') | operator('i:+') | operator('i:-') | operator('i::')
+		scanCode_expression   = triggerCode_outerList + operatorTriggerResult + resultCode_outerList >> unarg( kll_expression.scanCode )
+		usbCode_expression    = triggerUSBCode_outerList + operatorTriggerResult + resultCode_outerList >> unarg( kll_expression.usbCode )
+		animation_trigger     = animation_expanded + operatorTriggerResult + resultCode_outerList >> unarg( kll_expression.animationTrigger )
+
+		# Data Association
+		# <pixel chan> : <scanCode>;
+		pixelChan_expression = pixelchan_elem + skip( operator(':') ) + ( scanCode_single | none ) >> unarg( kll_expression.pixelChannels )
+
+
+		# Top-level Parser
+		expr = (
+			scanCode_expression |
+			usbCode_expression |
+			pixelChan_expression |
+			animation_trigger
+		)
+
+		return self.parse_base( kll_expression, expr, quiet )
+
+	## Processing ##
+	def tokenize( self, kll_context ):
+		'''
+		Tokenizes contents of both LOperatorData and ROperatorData
+		LOperatorData and ROperatorData have different contexts, so tokenization can be simplified a bit
+
+		@param context: KLL Context containing file data
+		'''
+		ret = True
+
+		# Tokenizer map, each takes an expression argument
+		tokenizers = {
+			# Name association
+			'=>' : self.tokenize_name_association,
+			# Data association
+			'<=' : self.tokenize_data_association,
+			# Assignment
+			'=' : self.tokenize_assignment,
+			# Mapping
+			# All : based operators have the same structure
+			# The only difference is the application context (handled in a later stage)
+			':' : self.tokenize_mapping,
+		}
+
+		# Tokenize left and right parameters of the expression
+		for kll_expression in kll_context.expressions:
+			# Determine which parser to use
+			token = kll_expression.operator_type()
+
+			# If there was a problem tokenizing, display exprersion info
+			if not tokenizers[ token ]( kll_expression ):
+				ret = False
+				print( "{0} {1}:tokenize -> {2}:{3}".format(
+					ERROR,
+					self.__class__.__name__,
+					kll_context.parent.path,
+					kll_expression.lparam_token.start[0],
+				) )
+
+			# Debug Output
+			# Displays each parsed expression on a single line
+			# Includes <filename>:<line number>
+			if self.token_debug:
+				# Uncolorize if requested
+				output = "\033[1m{0}\033[0m:\033[1;33m{1}\033[0m:\033[1;32m{2}\033[0m\033[1;36;41m>\033[0m {3}".format(
+					os.path.basename( kll_context.parent.path ),
+					kll_expression.lparam_token.start[0],
+					kll_expression.__class__.__name__,
+					kll_expression.final_tokens(),
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+		return ret
+
+	def parse( self, kll_context ):
+		'''
+		Parse the fully tokenized expressions
+
+		@param kll_context: KLL Context which has the fully tokenized expression list
+		'''
+		ret = True
+
+		# Parser map of functions, each takes an expression argument
+		parsers = {
+			# Name association
+			'=>' : self.parse_name_association,
+			# Data association
+			'<=' : self.parse_data_association,
+			# Assignment
+			'=' : self.parse_assignment,
+			# Mapping
+			# All : based operators have the same structure
+			# The only difference is the application context (handled in a later stage)
+			':' : self.parse_mapping,
+		}
+
+		# Parse each expression to extract the data from it
+		for kll_expression in kll_context.expressions:
+			token = kll_expression.operator_type()
+
+			# Assume failed, unless proven otherwise
+			cur_ret = False
+
+			# In some situations we don't want a parser trace, but only disable when we know
+			parser_debug_ignore = False
+
+			# If there was a problem parsing, display expression info
+			# Catch any TypeErrors due to incorrect parsing rules
+			try:
+				cur_ret = parsers[ token ]( kll_expression )
+
+			# Unexpected token (user grammar error), sometimes might be a bug
+			except NoParseError as err:
+				import traceback
+
+				traceback.print_tb( err.__traceback__ )
+				print( type( err ).__name__, err )
+				print( "Bad kll expression, usually a syntax error." )
+
+			# Invalid parsing rules, definitely a bug
+			except TypeError as err:
+				import traceback
+
+				traceback.print_tb( err.__traceback__ )
+				print( type( err ).__name__, err )
+				print( "Bad parsing rule, this is a bug!" )
+
+			# Lookup error, invalid lookup
+			except KeyError as err:
+				import traceback
+
+				print( "".join( traceback.format_tb( err.__traceback__ )[-1:] ), end='' )
+				print( "Invalid dictionary lookup, check syntax." )
+				parser_debug_ignore = True
+
+			# Parsing failed, show more error info
+			if not cur_ret:
+				ret = False
+
+				# We don't always want a full trace of the parser
+				if not parser_debug_ignore:
+					# StringIO stream from funcparserlib parser.py
+					# Command failed, run again, this time with verbose logging enabled
+					# Helps debug erroneous parsing expressions
+					parser_log = io.StringIO()
+
+					# This part is not thread-safe
+					# You must run with --jobs 1 to get 100% valid output
+					Parser_debug( True, parser_log )
+					try:
+						parsers[ token ]( kll_expression, True )
+					except:
+						pass
+					Parser_debug( False )
+
+					# Display
+					print( parser_log.getvalue() )
+
+					# Cleanup StringIO
+					parser_log.close()
+
+				print( "{0} {1}:parse -> {2}:{3}".format(
+					ERROR,
+					self.__class__.__name__,
+					kll_context.parent.path,
+					kll_expression.lparam_token.start[0],
+				) )
+
+			# Debug Output
+			# Displays each parsed expression on a single line
+			# Includes <filename>:<line number>
+			if self.parser_debug:
+				# Uncolorize if requested
+				output = "\033[1m{0}\033[0m:\033[1;33m{1}\033[0m:\033[1;32m{2}\033[0m:\033[1;35m{3}\033[1;36;41m>\033[0m {4}".format(
+					os.path.basename( kll_context.parent.path ),
+					kll_expression.lparam_token.start[0],
+					kll_expression.__class__.__name__,
+					kll_expression.type,
+					kll_expression
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+			if self.parser_token_debug:
+				# Uncolorize if requested
+				output = "\t\033[1;4mTokens\033[0m\033[1;36m:\033[0m {0}".format(
+					[ ( t.type, t.value ) for t in kll_expression.final_tokens() ]
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+		return ret
+
+	def process( self ):
+		'''
+		Compiler Configuration Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire thread pool
+		pool = self.control.stage('CompilerConfigurationStage').pool
+
+		# Get list of KLL contexts
+		contexts = self.control.stage('OperationClassificationStage').contexts
+
+		# Tokenize operators
+		if False in pool.map( self.tokenize, contexts ):
+			self._status = 'Incomplete'
+			return
+
+		# Parse operators
+		if False in pool.map( self.parse, contexts ):
+			self._status = 'Incomplete'
+			return
+
+		self._status = 'Completed'
+
+
+class OperationOrganizationStage( Stage ):
+	'''
+	Operation Organization Stage
+
+	* Using the type of each operation, apply the KLL Context to each operation
+	* This results in various datastructures being populated based upon the context and type of operation
+	* Each Context instance (distinct Context of the same type), remain separate
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize configuration variables
+		'''
+		super().__init__( control )
+
+		self.operation_organization_debug = False
+		self.operation_organization_display = False
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.operation_organization_debug = args.operation_organization_debug
+		self.operation_organization_display = args.operation_organization_display
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mOperation Organization Configuration\033[0m')
+
+		# Optional Arguments
+		group.add_argument(
+			'--operation-organization-debug',
+			action='store_true',
+			default=self.operation_organization_debug,
+			help="Enable operation organization debug output.\n",
+		)
+		group.add_argument(
+			'--operation-organization-display',
+			action='store_true',
+			default=self.operation_organization_display,
+			help="Show datastructure of each context after filling.\n",
+		)
+
+	def organize( self, kll_context ):
+		'''
+		Organize each set of expressions on a context level
+
+		The full layout organization occurs over multiple stages, this is the first one
+		'''
+		# Add each of the expressions to the organization data structure
+		try:
+			for kll_expression in kll_context.expressions:
+				# Debug output
+				if self.operation_organization_debug:
+					# Uncolorize if requested
+					output = "\033[1m{0}\033[0m:\033[1;33m{1}\033[0m:\033[1;32m{2}\033[0m:\033[1;35m{3}\033[1;36;41m>\033[0m {4}".format(
+						os.path.basename( kll_context.parent.path ),
+						kll_expression.lparam_token.start[0],
+						kll_expression.__class__.__name__,
+						kll_expression.type,
+						kll_expression
+					)
+					print( self.color and output or ansi_escape.sub( '', output ) )
+
+				# Add expression
+				kll_context.organization.add_expression(
+					kll_expression,
+					( self.operation_organization_debug, self.color )
+				)
+
+		except Exception as err:
+			import traceback
+
+			traceback.print_tb( err.__traceback__ )
+			print( type( err ).__name__, err )
+			print( "Could not add/modify kll expression in context datastructure." )
+			return False
+
+		return True
+
+	def process( self ):
+		'''
+		Operation Organization Stage Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire thread pool
+		pool = self.control.stage('CompilerConfigurationStage').pool
+
+		# Get list of KLL contexts
+		contexts = self.control.stage('OperationClassificationStage').contexts
+
+		# Add expressions from contexts to context datastructures
+		if False in pool.map( self.organize, contexts ):
+			self._status = 'Incomplete'
+			return
+
+		# Show result of filling datastructure
+		if self.operation_organization_display:
+			for kll_context in contexts:
+				# Uncolorize if requested
+				output = "\033[1m{0}\033[0m:\033[1;33m{1}\033[0m".format(
+					os.path.basename( kll_context.parent.path ),
+					kll_context.__class__.__name__
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+				# Display Table
+				for store in kll_context.organization.stores():
+					# Uncolorize if requested
+					output = "\t\033[1;4;32m{0}\033[0m".format(
+						store.__class__.__name__
+					)
+					print( self.color and output or ansi_escape.sub( '', output ) )
+					print( self.color and store or ansi_escape.sub( '', store ), end="" )
+
+		self._status = 'Completed'
+
+
+class DataOrganizationStage( Stage ):
+	'''
+	Data Organization Stage
+
+	* Using the constructed Context datastructures, merge contexts of the same type together
+	* Precedence/priority is defined by the order each Context was included on the command line
+	* May include datastructure data optimizations
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize configuration variables
+		'''
+		super().__init__( control )
+
+		self.data_organization_debug = False
+		self.data_organization_display = False
+		self.contexts = None
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.data_organization_debug = args.data_organization_debug
+		self.data_organization_display = args.data_organization_display
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mData Organization Configuration\033[0m')
+
+		# Optional Arguments
+		group.add_argument(
+			'--data-organization-debug',
+			action='store_true',
+			default=self.data_organization_debug,
+			help="Show debug info from data organization stage.\n",
+		)
+		group.add_argument(
+			'--data-organization-display',
+			action='store_true',
+			default=self.data_organization_display,
+			help="Show datastructure of each context after merging.\n",
+		)
+
+	def sort_contexts( self, contexts ):
+		'''
+		Returns a dictionary of list of sorted 'like' contexts
+
+		This is used to group the contexts that need merging
+		'''
+		lists = {}
+
+		for kll_context in contexts:
+			name = kll_context.__class__.__name__
+
+			# PartialMapContext's are sorted by name *and* layer number
+			if name == "PartialMapContext":
+				name = "{0}{1}".format( name, kll_context.layer )
+
+			# Add new list if no elements yet
+			if name not in lists.keys():
+				lists[ name ] = [ kll_context ]
+			else:
+				lists[ name ].append( kll_context )
+
+		return lists
+
+	def organize( self, kll_context ):
+		'''
+		Symbolically merge all like Contexts
+
+		The full layout organization occurs over multiple stages, this is the second stage
+		'''
+		# Lookup context name
+		context_name = "{0}".format( kll_context[0].__class__.__name__ )
+
+		# PartialMapContext's are sorted by name *and* layer number
+		if context_name == "PartialMapContext":
+			context_name = "{0}{1}".format( context_name, kll_context[0].layer )
+
+		# Initialize merge context as the first one
+		self.contexts[ context_name ] = context.MergeContext( kll_context[0] )
+
+		# Indicate when a context is skipped as there is only one
+		if self.data_organization_debug:
+			if len( kll_context ) < 2:
+				output = "\033[1;33mSkipping\033[0m\033[1m:\033[1;32m{0}\033[0m".format(
+					context_name
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+				return True
+
+		# The incoming list is ordered
+		# Merge in each of the contexts symbolically
+		for next_context in kll_context[1:]:
+			try:
+				self.contexts[ context_name ].merge(
+					next_context,
+					( self.data_organization_debug, self.color )
+				)
+
+			except Exception as err:
+				import traceback
+
+				traceback.print_tb( err.__traceback__ )
+				print( type( err ).__name__, err )
+				print( "Could not merge '{0}' into '{1}' context.".format(
+					os.path.basename( next_context.parent.path ),
+					context_name
+				) )
+				return False
+
+		return True
+
+	def process( self ):
+		'''
+		Data Organization Stage Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire thread pool
+		pool = self.control.stage('CompilerConfigurationStage').pool
+
+		# Get list of KLL contexts
+		contexts = self.control.stage('OperationClassificationStage').contexts
+
+		# Get sorted list of KLL contexts
+		sorted_contexts = self.sort_contexts( contexts )
+		self.contexts = {}
+
+		# Add expressions from contexts to context datastructures
+		if False in pool.map( self.organize, sorted_contexts.values() ):
+			self._status = 'Incomplete'
+			return
+
+		# Show result of filling datastructure
+		if self.data_organization_display:
+			for key, kll_context in self.contexts.items():
+				# Uncolorize if requested
+				output = "\033[1;33m{0}\033[0m:\033[1m{1}\033[0m".format(
+					key,
+					kll_context.paths(),
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+				# Display Table
+				for store in kll_context.organization.stores():
+					# Uncolorize if requested
+					output = "\t\033[1;4;32m{0}\033[0m".format(
+						store.__class__.__name__
+					)
+					print( self.color and output or ansi_escape.sub( '', output ) )
+					print( self.color and store or ansi_escape.sub( '', store ), end="" )
+
+		self._status = 'Completed'
+
+
+class DataFinalizationStage( Stage ):
+	'''
+	Data Finalization Stage
+
+	* Using the merged Context datastructures, apply the Configuration and BaseMap contexts to the higher
+	level DefaultMap and PartialMap Contexts
+	* First BaseMap is applied on top of Configuration
+	* Next, DefaultMap is applied on top of (Configuration+BaseMap) as well as the PartialMaps
+	* May include datastructure data optimizations
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize configuration variables
+		'''
+		super().__init__( control )
+
+		self.data_finalization_debug = False
+		self.data_finalization_display = False
+		self.base_context = None
+		self.default_context = None
+		self.partial_contexts = None
+		self.full_context = None
+		self.context_list = None
+		self.layer_contexts = None
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.data_finalization_debug = args.data_finalization_debug
+		self.data_finalization_display = args.data_finalization_display
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mData Organization Configuration\033[0m')
+
+		# Optional Arguments
+		group.add_argument(
+			'--data-finalization-debug',
+			action='store_true',
+			default=self.data_finalization_debug,
+			help="Show debug info from data finalization stage.\n",
+		)
+		group.add_argument(
+			'--data-finalization-display',
+			action='store_true',
+			default=self.data_finalization_display,
+			help="Show datastructure of each context after merging.\n",
+		)
+
+	def process( self ):
+		'''
+		Data Organization Stage Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Get context silos
+		contexts = self.control.stage('DataOrganizationStage').contexts
+		self._status = 'Incomplete'
+
+		# Context list
+		self.context_list = []
+
+		# Depending on the calling order, we may need to use a GenericContext or ConfigurationContext as the base
+		# Default to ConfigurationContext first
+		if 'ConfigurationContext' in contexts.keys():
+			self.base_context = context.MergeContext( contexts['ConfigurationContext'] )
+
+			# If we still have GenericContexts around, merge them on top of the ConfigurationContext
+			if 'GenericContext' in contexts.keys():
+				self.base_context.merge(
+					contexts['GenericContext'],
+					( self.data_finalization_debug, self.color )
+				)
+
+		# Otherwise, just use a GenericContext
+		elif 'GenericContext' in contexts.keys():
+			self.base_context = context.MergeContext( contexts['GenericContext'] )
+
+		# Fail otherwise, you *must* have a GenericContext or ConfigurationContext
+		else:
+			print( "{0} Missing a 'GenericContext' and/or 'ConfigurationContext'.".format( ERROR ) )
+			self._status = 'Incomplete'
+			return
+
+		# Next use the BaseMapContext and overlay on ConfigurationContext
+		# This serves as the basis for the next two merges
+		if 'BaseMapContext' in contexts.keys():
+			self.base_context.merge(
+				contexts['BaseMapContext'],
+				( self.data_finalization_debug, self.color )
+			)
+			self.context_list.append( ( 'BaseMapContext', self.base_context ) )
+
+		# Then use the DefaultMapContext as the default keyboard mapping
+		self.default_context = context.MergeContext( self.base_context )
+		if 'DefaultMapContext' in contexts.keys():
+			self.default_context.merge(
+				contexts['DefaultMapContext'],
+				( self.data_finalization_debug, self.color )
+			)
+			self.context_list.append( ( 'DefaultMapContext', self.default_context ) )
+
+		# For convenience build a fully merged dataset
+		# This is usually only required for variables
+		self.full_context = context.MergeContext( self.default_context )
+
+		# Finally setup each of the PartialMapContext groups
+		# Build list of PartialMapContexts and sort by layer before iterating over
+		self.partial_contexts = []
+		partial_context_list = [
+			( item[1].layer, item[1] )
+			for item in contexts.items()
+			if 'PartialMapContext' in item[0]
+		]
+		for layer, partial in sorted( partial_context_list, key=lambda x: x[0] ):
+			self.partial_contexts.append( context.MergeContext( self.base_context ) )
+			self.partial_contexts[ layer ].merge(
+				partial,
+				( self.data_finalization_debug, self.color )
+			)
+			self.context_list.append( ( 'PartialMapContext{0}'.format( layer ), self.default_context ) )
+
+			# Add each partial to the full_context as well
+			self.full_context.merge(
+				partial,
+				( self.data_finalization_debug, self.color )
+			)
+
+		# Build layer context list
+		# Each index of the list corresponds to the keyboard layer
+		self.layer_contexts = [ self.default_context ]
+		self.layer_contexts.extend( self.partial_contexts )
+
+		# Show result of filling datastructure
+		if self.data_finalization_display:
+			for key, kll_context in self.context_list:
+				# Uncolorize if requested
+				output = "*\033[1;33m{0}\033[0m:\033[1m{1}\033[0m".format(
+					key,
+					kll_context.paths(),
+				)
+				print( self.color and output or ansi_escape.sub( '', output ) )
+
+				# Display Table
+				for store in kll_context.organization.stores():
+					# Uncolorize if requested
+					output = "\t\033[1;4;32m{0}\033[0m".format(
+						store.__class__.__name__
+					)
+					print( self.color and output or ansi_escape.sub( '', output ) )
+					print( self.color and store or ansi_escape.sub( '', store ), end="" )
+
+		self._status = 'Completed'
+
+
+class DataAnalysisStage( Stage ):
+	'''
+	Data Analysis Stage
+
+	* Using the completed Context datastructures, do additional analysis that may be required for Code Generation
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize configuration variables
+		'''
+		super().__init__( control )
+
+		self.layer_contexts = None
+		self.full_context = None
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		#group = parser.add_argument_group('\033[1mData Analysis Configuration\033[0m')
+
+	def reduction( self ):
+		'''
+		Builds a new reduced_contexts list
+
+		For each of the layers, evaluate triggers into ScanCodes (USBCode to ScanCodes)
+		(all other triggers don't require reductions)
+		'''
+		self.reduced_contexts = []
+
+		for layer in self.layer_contexts:
+			reduced = context.MergeContext( layer )
+			reduced.reduction()
+			self.reduced_contexts.append( reduced )
+
+	def generate_mapping_indices( self ):
+		'''
+		For each trigger:result pair generate a unique index
+
+		The triggers and results are first sorted alphabetically
+		'''
+		# Build list of map expressions
+		expressions = []
+		# Gather list of expressions
+		for layer in self.layer_contexts:
+			expressions.extend( layer.organization.mapping_data.data.items() )
+
+		# Sort expressions by trigger, there may be *duplicate* triggers however don't reduce yet
+		# we need the result mappings as well
+		trigger_sorted = sorted( expressions, key=lambda x: x[1][0].trigger_str() )
+		trigger_filtered = [ elem for elem in trigger_sorted if not elem[1][0].type == 'USBCode' ]
+		#print( trigger_filtered )
+
+
+		# Sort expressions by result, there may be *duplicate* results however don't reduce yet
+		# we need the result mappings as well
+		result_sorted = sorted( expressions, key=lambda x: x[1][0].result_str() )
+		#print( result_sorted )
+
+		# Build List of Triggers and sort by string contents
+		# XXX Only scan codes right now
+		#     This will need to expand to a
+		#TODO
+
+		# Build List of Results and sort by string contents
+		# TODO
+
+	def sort_map_index_lists( self ):
+		'''
+		'''
+
+	def generate_map_offset_table( self ):
+		'''
+		'''
+
+	def generate_trigger_lists( self ):
+		'''
+		'''
+
+	def analyze( self ):
+		'''
+		Analyze the set of configured contexts
+
+		TODO: Perhaps use emitters or something like it for this code? -HaaTa
+		'''
+		# Reduce Contexts
+		# Convert all trigger USBCodes to ScanCodes
+		self.reduction()
+
+		# Generate Indices
+		# Assigns a sequential index (starting from 0) for each map expresssion
+		self.generate_mapping_indices()
+
+		# Sort Index Lists
+		# Using indices sort Trigger and Results macros
+		self.sort_map_index_lists()
+
+		# Generate Offset Table
+		# This is needed for interconnect devices
+		self.generate_map_offset_table()
+
+		# Generate Trigger Lists
+		self.generate_trigger_lists()
+
+	def process( self ):
+		'''
+		Data Analysis Stage Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Acquire list of contexts
+		self.layer_contexts = self.control.stage('DataFinalizationStage').layer_contexts
+		self.full_context = self.control.stage('DataFinalizationStage').full_context
+
+		# Analyze set of contexts
+		self.analyze()
+
+		self._status = 'Completed'
+
+
+class CodeGenerationStage( Stage ):
+	'''
+	Code Generation Stage
+
+	* Generates code for the given firmware backend
+	* Backend is selected in the Compiler Configuration Stage
+	* Uses the specified emitter to generate the code
+	'''
+	def __init__( self, control ):
+		'''
+		Initialize configuration variables
+		'''
+		super().__init__( control )
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.control.stage('CompilerConfigurationStage').emitters.command_line_args( args )
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		#group = parser.add_argument_group('\033[1mCode Generation Configuration\033[0m')
+
+		# Create options groups for each of the Emitters
+		self.control.stage('CompilerConfigurationStage').emitters.command_line_flags( parser )
+
+	def process( self ):
+		'''
+		Data Organization Stage Processing
+		'''
+		self._status = 'Running'
+
+		# Determine colorization setting
+		self.color = self.control.stage('CompilerConfigurationStage').color
+
+		# Get Emitter object
+		self.emitter = self.control.stage('CompilerConfigurationStage').emitters.emitter(
+			self.control.stage('CompilerConfigurationStage').emitter
+		)
+
+		# Call Emitter
+		self.emitter.process()
+
+		# Generate Outputs using Emitter
+		self.emitter.output()
+
+		self._status = 'Completed'
+
+
+class ReportGenerationStage( Stage ):
+	'''
+	Report Generation Stage
+
+	* Using the datastructures and analyzed data, generate a compiler report
+	* TODO
+	'''
+
diff --git a/emitters/__init__.py b/emitters/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/emitters/emitters.py b/emitters/emitters.py
new file mode 100644
index 0000000..2de83d9
--- /dev/null
+++ b/emitters/emitters.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+'''
+KLL Emitters Container Classes
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import emitters.kiibohd.kiibohd as kiibohd
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Emitters:
+	'''
+	Container class for KLL emitters
+
+	NOTES: To add a new emitter
+	- Add a new directory for your emitter (e.g. kiibohd)
+	- Add at least two files in this directory (<name>.py and __init__.py)
+	- In <name>.py have one class that inherits the Emitter class from common.emitter
+	- Add to list of emitters below
+	- Add import statement to the top of this file
+	- The control object allows access to the entire set of KLL datastructures
+	'''
+
+	def __init__( self, control ):
+		'''
+		Emitter initialization
+
+		@param control: ControlStage object, used to access data from other stages
+		'''
+		# Default emitter
+		self.default = "kiibohd"
+
+		# Dictionary of Emitters
+		self.emitters = {
+			'kiibohd' : kiibohd.Kiibohd( control )
+		}
+
+	def emitter_default( self ):
+		'''
+		Returns string name of default emitter
+		'''
+		return self.default
+
+	def emitter_list( self ):
+		'''
+		List of emitters available
+		'''
+		return list( self.emitters.keys() )
+
+	def emitter( self, emitter ):
+		'''
+		Returns an emitter object
+		'''
+		return self.emitters[ emitter ]
+
+	def command_line_args( self, args ):
+		'''
+		Group parser fan-out for emitter command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		# Always process command line args in the same order
+		for key, emitter in sorted( self.emitters.items(), key=lambda x: x[0] ):
+			emitter.command_line_args( args )
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser fan-out for emitter for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Always process command line flags in the same order
+		for key, emitter in sorted( self.emitters.items(), key=lambda x: x[0] ):
+			emitter.command_line_flags( parser )
+
+
diff --git a/emitters/kiibohd/__init__.py b/emitters/kiibohd/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/emitters/kiibohd/kiibohd.py b/emitters/kiibohd/kiibohd.py
new file mode 100644
index 0000000..906630a
--- /dev/null
+++ b/emitters/kiibohd/kiibohd.py
@@ -0,0 +1,466 @@
+#!/usr/bin/env python3
+'''
+KLL Kiibohd .h File Emitter
+'''
+
+# Copyright (C) 2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import re
+import sys
+
+from datetime import date
+
+from common.emitter import Emitter, TextEmitter
+from common.hid_dict import kll_hid_lookup_dictionary
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+
+### Classes ###
+
+class Kiibohd( Emitter, TextEmitter ):
+	'''
+	Kiibohd .h file emitter for KLL
+	'''
+
+	# List of required capabilities
+	requiredCapabilities = {
+		'CONS' : 'consCtrlOut',
+		'NONE' : 'noneOut',
+		'SYS'  : 'sysCtrlOut',
+		'USB'  : 'usbKeyOut',
+	}
+
+	def __init__( self, control ):
+		'''
+		Emitter initialization
+
+		@param control: ControlStage object, used to access data from other stages
+		'''
+		Emitter.__init__( self, control )
+		TextEmitter.__init__( self )
+
+		# Defaults
+		self.map_template = "templates/kiibohdKeymap.h"
+		self.def_template = "templates/kiibohdDefs.h"
+		self.map_output = "generatedKeymap.h"
+		self.def_output = "kll_defs.h"
+
+		self.fill_dict = {}
+
+	def command_line_args( self, args ):
+		'''
+		Group parser for command line arguments
+
+		@param args: Name space of processed arguments
+		'''
+		self.def_template = args.def_template
+		self.map_template = args.map_template
+		self.def_output = args.def_output
+		self.map_output = args.map_output
+
+	def command_line_flags( self, parser ):
+		'''
+		Group parser for command line options
+
+		@param parser: argparse setup object
+		'''
+		# Create new option group
+		group = parser.add_argument_group('\033[1mKiibohd Emitter Configuration\033[0m')
+
+		group.add_argument( '--def-template', type=str, default=self.def_template,
+			help="Specify KLL define .h file template.\n"
+			"\033[1mDefault\033[0m: {0}\n".format( self.def_template )
+		)
+		group.add_argument( '--map-template', type=str, default=self.map_template,
+			help="Specify KLL map .h file template.\n"
+			"\033[1mDefault\033[0m: {0}\n".format( self.map_template )
+		)
+		group.add_argument( '--def-output', type=str, default=self.def_output,
+			help="Specify KLL define .h file output.\n"
+			"\033[1mDefault\033[0m: {0}\n".format( self.def_output )
+		)
+		group.add_argument( '--map-output', type=str, default=self.map_output,
+			help="Specify KLL map .h file output.\n"
+			"\033[1mDefault\033[0m: {0}\n".format( self.map_output )
+		)
+
+	def output( self ):
+		'''
+		Final Stage of Emitter
+
+		Generate desired outputs from templates
+		'''
+		# Load define template and generate
+		self.load_template( self.def_template )
+		self.generate( self.def_output )
+
+		# Load keymap template and generate
+		self.load_template( self.map_template )
+		self.generate( self.map_output )
+
+	def process( self ):
+		'''
+		Emitter Processing
+
+		Takes KLL datastructures and Analysis results then populates the fill_dict
+		The fill_dict is used populate the template files.
+		'''
+		# Acquire Datastructures
+		early_contexts = self.control.stage('DataOrganizationStage').contexts
+		base_context = self.control.stage('DataFinalizationStage').base_context
+		default_context = self.control.stage('DataFinalizationStage').default_context
+		partial_contexts = self.control.stage('DataFinalizationStage').partial_contexts
+		full_context = self.control.stage('DataFinalizationStage').full_context
+
+
+		# Build string list of compiler arguments
+		compilerArgs = ""
+		for arg in sys.argv:
+			if "--" in arg or ".py" in arg:
+				compilerArgs += "//    {0}\n".format( arg )
+			else:
+				compilerArgs += "//      {0}\n".format( arg )
+
+
+		# Build a string of modified files, if any
+		gitChangesStr = "\n"
+		if len( self.control.git_changes ) > 0:
+			for gitFile in self.control.git_changes:
+				gitChangesStr += "//    {0}\n".format( gitFile )
+		else:
+			gitChangesStr = "    None\n"
+
+
+		# Prepare BaseLayout and Layer Info
+		configLayoutInfo = ""
+		if 'ConfigurationContext' in early_contexts.keys():
+			contexts = early_contexts['ConfigurationContext'].query_contexts( 'AssignmentExpression', 'Array' )
+			for sub in contexts:
+				name = sub[0].data['Name'].value
+				configLayoutInfo += "//    {0}\n//      {1}\n".format( name, sub[1].parent.path )
+
+		genericLayoutInfo = ""
+		if 'GenericContext' in early_contexts.keys():
+			contexts = early_contexts['GenericContext'].query_contexts( 'AssignmentExpression', 'Array' )
+			for sub in contexts:
+				name = sub[0].data['Name'].value
+				genericLayoutInfo += "//    {0}\n//      {1}\n".format( name, sub[1].parent.path )
+
+		baseLayoutInfo = ""
+		if 'BaseMapContext' in early_contexts.keys():
+			contexts = early_contexts['BaseMapContext'].query_contexts( 'AssignmentExpression', 'Array' )
+			for sub in contexts:
+				name = sub[0].data['Name'].value
+				baseLayoutInfo += "//    {0}\n//      {1}\n".format( name, sub[1].parent.path )
+
+		defaultLayerInfo = ""
+		if 'DefaultMapContext' in early_contexts.keys():
+			contexts = early_contexts['DefaultMapContext'].query_contexts( 'AssignmentExpression', 'Array' )
+			for sub in contexts:
+				name = sub[0].data['Name'].value
+				defaultLayerInfo += "//    {0}\n//      {1}\n".format( name, sub[1].parent.path )
+
+		partialLayersInfo = ""
+		partial_context_list = [
+			( item[1].layer, item[0] )
+			for item in early_contexts.items()
+			if 'PartialMapContext' in item[0]
+		]
+		for layer, tag in sorted( partial_context_list, key=lambda x: x[0] ):
+			partialLayersInfo += "//    Layer {0}\n".format( layer + 1 )
+			contexts = early_contexts[ tag ].query_contexts( 'AssignmentExpression', 'Array' )
+			for sub in contexts:
+				name = sub[0].data['Name'].value
+				partialLayersInfo += "//     {0}\n//       {1}\n".format( name, sub[1].parent.path )
+
+
+		## Information ##
+		self.fill_dict['Information']  = "// This file was generated by the kll compiler, DO NOT EDIT.\n"
+		self.fill_dict['Information'] += "// Generation Date:    {0}\n".format( date.today() )
+		self.fill_dict['Information'] += "// KLL Emitter:        {0}\n".format(
+			self.control.stage('CompilerConfigurationStage').emitter
+		)
+		self.fill_dict['Information'] += "// KLL Version:        {0}\n".format( self.control.version )
+		self.fill_dict['Information'] += "// KLL Git Changes:{0}".format( gitChangesStr )
+		self.fill_dict['Information'] += "// Compiler arguments:\n{0}".format( compilerArgs )
+		self.fill_dict['Information'] += "//\n"
+		self.fill_dict['Information'] += "// - Configuration File -\n{0}".format( configLayoutInfo )
+		self.fill_dict['Information'] += "// - Generic Files -\n{0}".format( genericLayoutInfo )
+		self.fill_dict['Information'] += "// - Base Layer -\n{0}".format( baseLayoutInfo )
+		self.fill_dict['Information'] += "// - Default Layer -\n{0}".format( defaultLayerInfo )
+		self.fill_dict['Information'] += "// - Partial Layers -\n{0}".format( partialLayersInfo )
+
+
+		## Defines ##
+		self.fill_dict['Defines'] = ""
+
+		# Iterate through defines and lookup the variables
+		defines = full_context.query( 'NameAssociationExpression', 'Define' )
+		variables = full_context.query( 'AssignmentExpression', 'Variable' )
+		for dkey, dvalue in sorted( defines.data.items() ):
+			if dvalue.name in variables.data.keys():
+				self.fill_dict['Defines'] += "\n#define {0} {1}".format(
+					dvalue.association,
+					variables.data[ dvalue.name ].value.replace( '\n', ' \\\n' ),
+				)
+			else:
+				print( "{0} '{1}' not defined...".format( WARNING, dvalue.name ) )
+
+
+		## Capabilities ##
+		self.fill_dict['CapabilitiesFuncDecl'] = ""
+		self.fill_dict['CapabilitiesList'] = "const Capability CapabilitiesList[] = {\n"
+		self.fill_dict['CapabilitiesIndices'] = "typedef enum CapabilityIndex {\n"
+
+		# Keys are pre-sorted
+		capabilities = full_context.query( 'NameAssociationExpression', 'Capability' )
+		for dkey, dvalue in sorted( capabilities.data.items() ):
+			funcName = dvalue.association.name
+			argByteWidth = dvalue.association.total_arg_bytes()
+
+			self.fill_dict['CapabilitiesList'] += "\t{{ {0}, {1} }},\n".format( funcName, argByteWidth )
+			self.fill_dict['CapabilitiesFuncDecl'] += \
+				"void {0}( uint8_t state, uint8_t stateType, uint8_t *args );\n".format( funcName )
+			self.fill_dict['CapabilitiesIndices'] += "\t{0}_index,\n".format( funcName )
+
+		self.fill_dict['CapabilitiesList'] += "};"
+		self.fill_dict['CapabilitiesIndices'] += "} CapabilityIndex;"
+		return
+
+
+		## Results Macros ##
+		self.fill_dict['ResultMacros'] = ""
+
+		# Iterate through each of the result macros
+		for result in range( 0, len( macros.resultsIndexSorted ) ):
+			self.fill_dict['ResultMacros'] += "Guide_RM( {0} ) = {{ ".format( result )
+
+			# Add the result macro capability index guide (including capability arguments)
+			# See kiibohd controller Macros/PartialMap/kll.h for exact formatting details
+			for sequence in range( 0, len( macros.resultsIndexSorted[ result ] ) ):
+				# If the sequence is longer than 1, prepend a sequence spacer
+				# Needed for USB behaviour, otherwise, repeated keys will not work
+				if sequence > 0:
+					# <single element>, <usbCodeSend capability>, <USB Code 0x00>
+					self.fill_dict['ResultMacros'] += "1, {0}, 0x00, ".format( capabilities.getIndex( self.capabilityLookup('USB') ) )
+
+				# For each combo in the sequence, add the length of the combo
+				self.fill_dict['ResultMacros'] += "{0}, ".format( len( macros.resultsIndexSorted[ result ][ sequence ] ) )
+
+				# For each combo, add each of the capabilities used and their arguments
+				for combo in range( 0, len( macros.resultsIndexSorted[ result ][ sequence ] ) ):
+					resultItem = macros.resultsIndexSorted[ result ][ sequence ][ combo ]
+
+					# Add the capability index
+					self.fill_dict['ResultMacros'] += "{0}, ".format( capabilities.getIndex( resultItem[0] ) )
+
+					# Add each of the arguments of the capability
+					for arg in range( 0, len( resultItem[1] ) ):
+						# Special cases
+						if isinstance( resultItem[1][ arg ], str ):
+							# If this is a CONSUMER_ element, needs to be split into 2 elements
+							# AC_ and AL_ are other sections of consumer control
+							if re.match( r'^(CONSUMER|AC|AL)_', resultItem[1][ arg ] ):
+								tag = resultItem[1][ arg ].split( '_', 1 )[1]
+								if '_' in tag:
+									tag = tag.replace( '_', '' )
+								try:
+									lookupNum = kll_hid_lookup_dictionary['ConsCode'][ tag ][1]
+								except KeyError as err:
+									print ( "{0} {1} Consumer HID kll bug...please report.".format( ERROR, err ) )
+									raise
+								byteForm = lookupNum.to_bytes( 2, byteorder='little' ) # XXX Yes, little endian from how the uC structs work
+								self.fill_dict['ResultMacros'] += "{0}, {1}, ".format( *byteForm )
+								continue
+
+							# None, fall-through disable
+							elif resultItem[0] is self.capabilityLookup('NONE'):
+								continue
+
+						self.fill_dict['ResultMacros'] += "{0}, ".format( resultItem[1][ arg ] )
+
+			# If sequence is longer than 1, append a sequence spacer at the end of the sequence
+			# Required by USB to end at sequence without holding the key down
+			if len( macros.resultsIndexSorted[ result ] ) > 1:
+				# <single element>, <usbCodeSend capability>, <USB Code 0x00>
+				self.fill_dict['ResultMacros'] += "1, {0}, 0x00, ".format( capabilities.getIndex( self.capabilityLookup('USB') ) )
+
+			# Add list ending 0 and end of list
+			self.fill_dict['ResultMacros'] += "0 };\n"
+		self.fill_dict['ResultMacros'] = self.fill_dict['ResultMacros'][:-1] # Remove last newline
+
+
+		## Result Macro List ##
+		self.fill_dict['ResultMacroList'] = "const ResultMacro ResultMacroList[] = {\n"
+
+		# Iterate through each of the result macros
+		for result in range( 0, len( macros.resultsIndexSorted ) ):
+			self.fill_dict['ResultMacroList'] += "\tDefine_RM( {0} ),\n".format( result )
+		self.fill_dict['ResultMacroList'] += "};"
+
+
+		## Result Macro Record ##
+		self.fill_dict['ResultMacroRecord'] = "ResultMacroRecord ResultMacroRecordList[ ResultMacroNum ];"
+
+
+		## Trigger Macros ##
+		self.fill_dict['TriggerMacros'] = ""
+
+		# Iterate through each of the trigger macros
+		for trigger in range( 0, len( macros.triggersIndexSorted ) ):
+			self.fill_dict['TriggerMacros'] += "Guide_TM( {0} ) = {{ ".format( trigger )
+
+			# Add the trigger macro scan code guide
+			# See kiibohd controller Macros/PartialMap/kll.h for exact formatting details
+			for sequence in range( 0, len( macros.triggersIndexSorted[ trigger ][0] ) ):
+				# For each combo in the sequence, add the length of the combo
+				self.fill_dict['TriggerMacros'] += "{0}, ".format( len( macros.triggersIndexSorted[ trigger ][0][ sequence ] ) )
+
+				# For each combo, add the key type, key state and scan code
+				for combo in range( 0, len( macros.triggersIndexSorted[ trigger ][0][ sequence ] ) ):
+					triggerItemId = macros.triggersIndexSorted[ trigger ][0][ sequence ][ combo ]
+
+					# Lookup triggerItem in ScanCodeStore
+					triggerItemObj = macros.scanCodeStore[ triggerItemId ]
+					triggerItem = triggerItemObj.offset( macros.interconnectOffset )
+
+					# TODO Add support for Analog keys
+					# TODO Add support for LED states
+					self.fill_dict['TriggerMacros'] += "0x00, 0x01, 0x{0:02X}, ".format( triggerItem )
+
+			# Add list ending 0 and end of list
+			self.fill_dict['TriggerMacros'] += "0 };\n"
+		self.fill_dict['TriggerMacros'] = self.fill_dict['TriggerMacros'][ :-1 ] # Remove last newline
+
+
+		## Trigger Macro List ##
+		self.fill_dict['TriggerMacroList'] = "const TriggerMacro TriggerMacroList[] = {\n"
+
+		# Iterate through each of the trigger macros
+		for trigger in range( 0, len( macros.triggersIndexSorted ) ):
+			# Use TriggerMacro Index, and the corresponding ResultMacro Index
+			self.fill_dict['TriggerMacroList'] += "\tDefine_TM( {0}, {1} ),\n".format( trigger, macros.triggersIndexSorted[ trigger ][1] )
+		self.fill_dict['TriggerMacroList'] += "};"
+
+
+		## Trigger Macro Record ##
+		self.fill_dict['TriggerMacroRecord'] = "TriggerMacroRecord TriggerMacroRecordList[ TriggerMacroNum ];"
+
+
+		## Max Scan Code ##
+		self.fill_dict['MaxScanCode'] = "#define MaxScanCode 0x{0:X}".format( macros.overallMaxScanCode )
+
+
+		## Interconnect ScanCode Offset List ##
+		self.fill_dict['ScanCodeInterconnectOffsetList'] = "const uint8_t InterconnectOffsetList[] = {\n"
+		for offset in range( 0, len( macros.interconnectOffset ) ):
+			self.fill_dict['ScanCodeInterconnectOffsetList'] += "\t0x{0:02X},\n".format( macros.interconnectOffset[ offset ] )
+		self.fill_dict['ScanCodeInterconnectOffsetList'] += "};"
+
+
+		## Max Interconnect Nodes ##
+		self.fill_dict['InterconnectNodeMax'] = "#define InterconnectNodeMax 0x{0:X}\n".format( len( macros.interconnectOffset ) )
+
+
+		## Default Layer and Default Layer Scan Map ##
+		self.fill_dict['DefaultLayerTriggerList'] = ""
+		self.fill_dict['DefaultLayerScanMap'] = "const nat_ptr_t *default_scanMap[] = {\n"
+
+		# Iterate over triggerList and generate a C trigger array for the default map and default map array
+		for triggerList in range( macros.firstScanCode[0], len( macros.triggerList[0] ) ):
+			# Generate ScanCode index and triggerList length
+			self.fill_dict['DefaultLayerTriggerList'] += "Define_TL( default, 0x{0:02X} ) = {{ {1}".format( triggerList, len( macros.triggerList[0][ triggerList ] ) )
+
+			# Add scanCode trigger list to Default Layer Scan Map
+			self.fill_dict['DefaultLayerScanMap'] += "default_tl_0x{0:02X}, ".format( triggerList )
+
+			# Add each item of the trigger list
+			for triggerItem in macros.triggerList[0][ triggerList ]:
+				self.fill_dict['DefaultLayerTriggerList'] += ", {0}".format( triggerItem )
+
+			self.fill_dict['DefaultLayerTriggerList'] += " };\n"
+		self.fill_dict['DefaultLayerTriggerList'] = self.fill_dict['DefaultLayerTriggerList'][:-1] # Remove last newline
+		self.fill_dict['DefaultLayerScanMap'] = self.fill_dict['DefaultLayerScanMap'][:-2] # Remove last comma and space
+		self.fill_dict['DefaultLayerScanMap'] += "\n};"
+
+
+		## Partial Layers and Partial Layer Scan Maps ##
+		self.fill_dict['PartialLayerTriggerLists'] = ""
+		self.fill_dict['PartialLayerScanMaps'] = ""
+
+		# Iterate over each of the layers, excluding the default layer
+		for layer in range( 1, len( macros.triggerList ) ):
+			# Prepare each layer
+			self.fill_dict['PartialLayerScanMaps'] += "// Partial Layer {0}\n".format( layer )
+			self.fill_dict['PartialLayerScanMaps'] += "const nat_ptr_t *layer{0}_scanMap[] = {{\n".format( layer )
+			self.fill_dict['PartialLayerTriggerLists'] += "// Partial Layer {0}\n".format( layer )
+
+			# Iterate over triggerList and generate a C trigger array for the layer
+			for triggerList in range( macros.firstScanCode[ layer ], len( macros.triggerList[ layer ] ) ):
+				# Generate ScanCode index and triggerList length
+				self.fill_dict['PartialLayerTriggerLists'] += "Define_TL( layer{0}, 0x{1:02X} ) = {{ {2}".format( layer, triggerList, len( macros.triggerList[ layer ][ triggerList ] ) )
+
+				# Add scanCode trigger list to Default Layer Scan Map
+				self.fill_dict['PartialLayerScanMaps'] += "layer{0}_tl_0x{1:02X}, ".format( layer, triggerList )
+
+				# Add each item of the trigger list
+				for trigger in macros.triggerList[ layer ][ triggerList ]:
+					self.fill_dict['PartialLayerTriggerLists'] += ", {0}".format( trigger )
+
+				self.fill_dict['PartialLayerTriggerLists'] += " };\n"
+			self.fill_dict['PartialLayerTriggerLists'] += "\n"
+			self.fill_dict['PartialLayerScanMaps'] = self.fill_dict['PartialLayerScanMaps'][:-2] # Remove last comma and space
+			self.fill_dict['PartialLayerScanMaps'] += "\n};\n\n"
+		self.fill_dict['PartialLayerTriggerLists'] = self.fill_dict['PartialLayerTriggerLists'][:-2] # Remove last 2 newlines
+		self.fill_dict['PartialLayerScanMaps'] = self.fill_dict['PartialLayerScanMaps'][:-2] # Remove last 2 newlines
+
+
+		## Layer Index List ##
+		self.fill_dict['LayerIndexList'] = "const Layer LayerIndex[] = {\n"
+
+		# Iterate over each layer, adding it to the list
+		for layer in range( 0, len( macros.triggerList ) ):
+			# Lookup first scancode in map
+			firstScanCode = macros.firstScanCode[ layer ]
+
+			# Generate stacked name
+			stackName = ""
+			if '*NameStack' in variables.layerVariables[ layer ].keys():
+				for name in range( 0, len( variables.layerVariables[ layer ]['*NameStack'] ) ):
+					stackName += "{0} + ".format( variables.layerVariables[ layer ]['*NameStack'][ name ] )
+				stackName = stackName[:-3]
+
+			# Default map is a special case, always the first index
+			if layer == 0:
+				self.fill_dict['LayerIndexList'] += '\tLayer_IN( default_scanMap, "D: {1}", 0x{0:02X} ),\n'.format( firstScanCode, stackName )
+			else:
+				self.fill_dict['LayerIndexList'] += '\tLayer_IN( layer{0}_scanMap, "{0}: {2}", 0x{1:02X} ),\n'.format( layer, firstScanCode, stackName )
+		self.fill_dict['LayerIndexList'] += "};"
+
+
+		## Layer State ##
+		self.fill_dict['LayerState'] = "uint8_t LayerState[ LayerNum ];"
+
diff --git a/examples/assignment.kll b/examples/assignment.kll
new file mode 100644
index 0000000..c4794c1
--- /dev/null
+++ b/examples/assignment.kll
@@ -0,0 +1,5 @@
+Variable = 1;
+Array[] = a b c "b c" 3;
+Index[5] = "this text" thing; # Single element
+Index[6] = moar;
+
diff --git a/examples/defaultMapExample.kll b/examples/defaultMapExample.kll
index 8d2207e..270a0df 100644
--- a/examples/defaultMapExample.kll
+++ b/examples/defaultMapExample.kll
@@ -8,7 +8,7 @@ Date = 2014-06-12;
 
 S0x40 : U"Backspace";
 
-S0x42 : U"}";
+S0x42 : U"]";
 S0x43 : U"Delete";
 S0x44 : U"Enter";
 
@@ -16,7 +16,7 @@ S0x46 : U"RShift";
 S0x47 : U"RCtrl";
 S0x48 : U"=";
 S0x49 : U"-";
-S0x4A : U"{";
+S0x4A : U"[";
 S0x4B : U"\";
 S0x4C : U"'";
 S0x4D : U"/";
diff --git a/examples/example.kll b/examples/example.kll
index 22f6ed7..882d47b 100644
--- a/examples/example.kll
+++ b/examples/example.kll
@@ -10,25 +10,25 @@ test => myCFunc( dat : 1 );
 
 U"A" : U"B";
 # Top row
-#'e' : 'f';
-#'r' : 'p';
-#'t' : 'g';
-#'y' : 'j';
-#'u' : 'l';
-#'i' : 'u';
-#'o' : 'y';
-#'p' : ';';
+'e' : 'f';
+'r' : 'p';
+'t' : 'g';
+'y' : 'j';
+'u' : 'l';
+'i' : 'u';
+'o' : 'y';
+'p' : ';';
 
 # Middle Row
-#'s' : 'r';
-#'d' : 's';
-#'f' : 't';
-#'g' : 'd';
-#'j' : 'n';
-#'k' : 'e';
-#'l' : 'i';
-#';' : 'o';
+'s' : 'r';
+'d' : 's';
+'f' : 't';
+'g' : 'd';
+'j' : 'n';
+'k' : 'e';
+'l' : 'i';
+';' : 'o';
 
 # Bottom Row
-#'n' : 'k';
+'n' : 'k';
 
diff --git a/examples/hhkbpro2.kll b/examples/hhkbpro2.kll
index 6f99653..f05d0fc 100644
--- a/examples/hhkbpro2.kll
+++ b/examples/hhkbpro2.kll
@@ -27,7 +27,7 @@ U"Tab" : U"Capslock";
 U"I" : U"PrintScreen";
 U"O" : U"ScrollLock";
 U"P" : U"Pause";
-U"{" : U"Up";
+U"[" : U"Up";
 
 # Middle Row
 U"A" : U"VolumeDown";
diff --git a/examples/leds.kll b/examples/leds.kll
index 673ce57..2dd51bb 100644
--- a/examples/leds.kll
+++ b/examples/leds.kll
@@ -12,15 +12,19 @@ myarray[4] = test;
 # Key Positioning
 S120 <= x:20, rx:15;
 S121 <= x:20, y:10, z:2, rx:15, ry:12, rz:39;
+S[122-125] <= x:20, rx:15;
 
 # Pixel Positioning
+P19 <= x:21, rx:16;
 P[20] <= x:20, rx:15;
 P[21] <= x:20, y:10, z:2, rx:15, ry:12, rz:39;
+P[22-25] <= x:20, rx:15;
 
 # Pixel Channel Mapping
 P[5](4:8, 5:8, 12:8) : None;
 P[4](3:8) : S0x31;
 P[12](40:8, 50:8, 120:8) : S59;
+P[12](12:8, 13:8, 14:8) : S[40];
 
 # Animation
 A[BLEEdsing] <= loop:3,frame:2;
@@ -34,6 +38,9 @@ A[BLEEdsing, 3] <= P[4](-:32);
 A[BLEEdsing, 4] <= P[4](+:400);
 A[BLEEdsing, 5] <= P[4](<<2);
 A[BLEEdsing, 6] <= P[4](>>1);
+A[BLEEdsing, 7-9] <= P[4](+32);
+A[BLEEdsing, 10, 12] <= P[4](+32);
+A[BLEEdsing, 11, 13-15] <= P[4-10](+32);
 
 A[BLEEdsing2, 0] <= PL[0](127, 30, 40), P[5](20, 30, 40);
 A[BLEEdsing2, 1] <= P[1-20,40](40,50,0x60);
@@ -41,10 +48,20 @@ A[BLEEdsing2, 1] <= P[1-20,40](40,50,0x60);
 # Animation Triggers
 myCapability  => myFunc( myArg1 : 1, myArg2 : 4 );
 A[BLEEdsing, 3] : myCapability( 0x8, 0x25 );
+A[BLEEdsing, 4-6] : myCapability( 0x8, 0x25 );
+A[BLEEdsing, 7, 9] : myCapability( 0x8, 0x25 );
 A[BLEEdsing2] : myCapability( 0x8, 0x25 );
 
 # Animation Results
-U0x40 : A[BLEEdsing];
+S[0x37, 0x38] : A"BLEEdsing";
+S0x39 : A"BLEEdsing", A"BLEEdsing2";
+S0x40 : A[BLEEdsing];
 S0x41 : A[BLEEdsing](loop:2);
-S0x43 : PL[0](0xFF,0xFF,244), P[1-3](20,40,60);
+S0x42 : A[BLEEdsing](loop:2,div:3);
+S0x43 : PL[0](0xFF,0xFF,244) + P[1-3](20,40,60);
+S0x44 : PL[0-2](0xFF,0xFF,244);
+S0x44 : PL1(0xFF,0xFF,244);
+S0x45 : PL[2](0x1F,0x2F,0x3F);
+S0x46 : P[0](11,23,45);
+S0x47 : P1(11,23,45);
 
diff --git a/examples/mapping.kll b/examples/mapping.kll
new file mode 100644
index 0000000..f4285a4
--- /dev/null
+++ b/examples/mapping.kll
@@ -0,0 +1,57 @@
+Name = mapping test;
+Author = "HaaTa (Jacob Alexander) 2016";
+KLL = 0.5b;
+
+# Mapping Operators ##
+
+S0x01 :  U"A";
+S0x01 :  U"A";
+
+# Must include file twice for this case to work
+S0x02 :  U"B";
+U"B"  :: U"C";
+
+S0x03 :+ U"D";
+
+S0x04 :  U"E";
+S0x04 :+ U"F";
+S0x04 :+ U"F";
+S0x04 :+ U"L";
+
+S0x06 :  U"G";
+S0x06 :+ U"H";
+S0x06 :- U"G";
+
+S0x07 + S0x08 : U"H";
+S0x09, S0x0A  : U"I";
+
+S[0x0B, 0x0B, 0x0C] : U"J";
+
+S0x0D :- U"K";
+
+
+## Isolation Mappings ##
+
+S0x10 i:  U"M";
+S0x10 i:  U"M";
+
+# Must include file twice for this case to work
+S0x11 i:  U"N";
+U"N"  i:: U"O";
+
+S0x12 i:+ U"P";
+
+S0x13 i:  U"Q";
+S0x13 i:+ U"R";
+
+S0x14 i:  U"S";
+S0x14 i:+ U"T";
+S0x14 i:- U"S";
+
+S0x15 + S0x16 i: U"U";
+S0x17, S0x18  i: U"V";
+
+S[0x19, 0x1A] i: U"W";
+
+S0x1B i:- U"X";
+
diff --git a/examples/simple1.kll b/examples/simple1.kll
index 1ce1b4d..d6ba21d 100644
--- a/examples/simple1.kll
+++ b/examples/simple1.kll
@@ -41,6 +41,6 @@ S[ 0x7 - 0x9 ] : U"6";
 S[ 0x2 - 0x9, 0x10 ] : U"r";
 S[ 0x2 - 0x9, 0x10 ]+S[0x5 - 0x6, 0x9],S0xA+S0xB : U"r";
 
-S0x42 : U"}";
+S0x42 : U"]";
 S0x42 : U"Esc";
 
diff --git a/examples/simple2.kll b/examples/simple2.kll
index 9e03c46..65de783 100644
--- a/examples/simple2.kll
+++ b/examples/simple2.kll
@@ -18,17 +18,18 @@ myCapability3 => myFunc3( myArg1 : 2 );
 myCapability  => myFunc( myArg1 : 1, myArg2 : 4 );
 
 S0x3 : myCapability2();
-S0x4 : myCapability( 0x8, 0x25 );
+S[0x4] : myCapability( 0x8, 0x25 );
+S[ 0x7 - 0x9 ] : U"6";
+S0x40 : U[0x1-0x4];
 S0x12 : U[122] + U[123];
 S0x6 : 'abcdDfF'; # TODO
 S0x40 : U[0x1];
-S0x40 : U[0x1-0x4];
 S0x0B : U["Esc"];
 S0x0B :+ U["Q"];
-S[ 0x7 - 0x9 ] : U"6";
 S[ 0x7 - 0x9 ], S[0x2,0x3] : U"6";
 S[ 0x2 - 0x9, 0x10 ] :+ U"r";
 S0x0B :- U["Esc"];
+S[ 0x3 - 0x4 ] + S[ 0x10 ], S[ 0x20 ] : U"Enter";
 S127 + S128 : U"0";
 
 S0x41 : CONS[0x30];
@@ -39,5 +40,10 @@ S0x45 : SYS[0xA0];
 S0x46 : SYS["UnDock"];
 S0x47 : SYS0xA2;
 
-S0x48 : None;
+S[0x48] : None;
+S0x30(P) : U"A";
+S0x29(P:10ms) : U"A";
+S0x28(20) : U"A";
+S0x31(H:20ms, R:1s) : U"B";
+S0x32(P,H,R) : U"B";
 
diff --git a/examples/simpleExample.kll b/examples/simpleExample.kll
index 560432e..b4fd94b 100644
--- a/examples/simpleExample.kll
+++ b/examples/simpleExample.kll
@@ -3,9 +3,9 @@ Author = "HaaTa (Jacob Alexander) 2014-2015";
 KLL = 0.3a;
 
 usbKeyOut => Output_usbCodeSend_capability( usbCode : 1 );
-#S0x40 : U0x43;
+S0x40 : U0x43;
 S0x40 : U"Backspace";
 
-S0x42 : U"}";
+S0x42 : U"]";
 S0x42 : U"Esc";
 
diff --git a/examples/state_scheduling.kll b/examples/state_scheduling.kll
new file mode 100644
index 0000000..24c28ff
--- /dev/null
+++ b/examples/state_scheduling.kll
@@ -0,0 +1,53 @@
+Name = "State Scheduling";
+Author = "HaaTa (Jacob Alexander) 2016";
+KLL = 0.4;
+mydefine = "stuffs here";
+mydefine2 = '"stuffs here"'; # For outputting c define strings
+mynumber = 414;
+
+# State Scheduling
+S0x43 : U"Enter";
+S[0x43(P,UP,UR)] : U"Enter";
+S0x44(P) : U"Enter";
+S0x45(UP) : U"Enter";
+S0x46(UR) : U"Enter";
+S0x46(R) : U"Enter";
+
+S0x47(H) + S0x48 : U"Enter";
+S0x49(O) + S0x50 : U"Enter";
+
+# Timing Triggers
+U"t"(300ms) : 'duuude';
+U"t"(30.2ms) : 'duuude';
+U"i"(200) : 'duuude1';
+U"u"(1s) : 'duuud2e';
+U"m"(40us) : 'duuu3de';
+
+U"a" + U"b"(P:1s) : 'slow';
+U"a" + U"b"(P:50ms,H:100ms,R:200ms) : 'fast';
+
+# Timing Results
+U"x" : U"a"(300ms);
+U"v" : U"a"(P,H:300ms,R);
+
+# Analog
+S0x2A(10) : U"B";
+S0x2A(80) : U"C";
+S[34-52](22) : 'boo';
+S[34-52(88)](22) : 'beh';
+S[34-52(88), 78](30) : 'joe';
+U"A"(0)   : U"A"; # Pulse
+U"A"(42)  : U"Q";
+U["1"-"5"(42), "Tab"](30) : 'mac';
+
+
+# Indicators
+I"NumLock" : U"Space";
+I"NumLock"(A) : U"Space";
+I"NumLock"(D) : U"Z";
+I2 : U"G"; # CapsLock
+
+U"a" + I"NumLock"(Off) : U"Q";
+U"a" + I"NumLock"(On) : U"W";
+
+
diff --git a/funcparserlib/parser.py b/funcparserlib/parser.py
index c92db00..061206d 100644
--- a/funcparserlib/parser.py
+++ b/funcparserlib/parser.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2008/2013 Andrey Vlasovskikh
-# Small Python 3 modifications by Jacob Alexander 2014
+# Modifications by Jacob Alexander 2014, 2016
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -69,11 +69,30 @@ __all__ = [
 
 import logging
 
-log = logging.getLogger('funcparserlib')
 
+log = logging.getLogger('funcparserlib')
 debug = False
 
 
+def Parser_debug(enable, stream=None):
+    '''
+    Enables/Disables debug logger for parser.py
+
+    NOTE: This is not really multi-thread friendly
+
+    @param stream: StringIO stream to use
+    @param enable: Enable/disable debug stream
+    '''
+    global debug
+    debug = enable
+
+    if enable:
+        logging.raiseExceptions = False
+        log.setLevel(logging.DEBUG)
+        ch = logging.StreamHandler(stream)
+        log.addHandler(ch)
+
+
 class Parser(object):
     """A wrapper around a parser function that defines some operators for parser
     composition.
@@ -103,7 +122,12 @@ class Parser(object):
         Runs a parser wrapped into this object.
         """
         if debug:
-            log.debug('trying %s' % self.name)
+            # Truncate at 500 characters
+            # Any longer isn't that useful and makes the output hard to read
+            output = 'trying %s' % self.name
+            if len( output ) > 500:
+                output = output[:250] + '   ... [truncated] ...   ' + output[-250:]
+            log.debug(output)
         return self._run(tokens, s)
 
     def _run(self, tokens, s):
@@ -234,7 +258,7 @@ class State(object):
         self.max = max
 
     def __str__(self):
-        return unicode((self.pos, self.max))
+        return str((self.pos, self.max))
 
     def __repr__(self):
         return 'State(%r, %r)' % (self.pos, self.max)
diff --git a/kll b/kll
new file mode 100755
index 0000000..391c5d7
--- /dev/null
+++ b/kll
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+'''
+KLL Compiler
+Keyboard Layout Langauge
+'''
+
+# Copyright (C) 2014-2016 by Jacob Alexander
+#
+# This file is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This file is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+### Imports ###
+
+import argparse
+import importlib
+import os
+import sys
+
+import common.stage as stage
+
+
+
+### Decorators ###
+
+## Print Decorator Variables
+ERROR = '\033[5;1;31mERROR\033[0m:'
+WARNING = '\033[5;1;33mWARNING\033[0m:'
+
+
+## Python Text Formatting Fixer...
+##  Because the creators of Python are averse to proper capitalization.
+textFormatter_lookup = {
+	"usage: "            : "Usage: ",
+	"optional arguments" : "\033[1mOptional Arguments\033[0m",
+}
+
+def textFormatter_gettext( s ):
+	return textFormatter_lookup.get( s, s )
+
+argparse._ = textFormatter_gettext
+
+
+
+### Misc Utility Functions ###
+
+def git_revision( kllPath ):
+	import subprocess
+
+	# Change the path to where kll.py is
+	origPath = os.getcwd()
+	os.chdir( kllPath )
+
+	# Just in case git can't be found
+	try:
+		# Get hash of the latest git commit
+		revision = subprocess.check_output( ['git', 'rev-parse', 'HEAD'] ).decode()[:-1]
+
+		# Get list of files that have changed since the commit
+		changed = subprocess.check_output( ['git', 'diff-index', '--name-only', 'HEAD', '--'] ).decode().splitlines()
+
+		# Get commit date
+		date = subprocess.check_output( ['git', 'show', '-s', '--format=%ci'] ).decode()[:-1]
+	except:
+		revision = "<no git>"
+		changed = []
+		date = "<no date>"
+
+	# Change back to the old working directory
+	os.chdir( origPath )
+
+	return revision, changed, date
+
+
+
+### Argument Parsing ###
+
+def checkFileExists( filename ):
+	if not os.path.isfile( filename ):
+		print ( "{0} {1} does not exist...".format( ERROR, filename ) )
+		sys.exit( 1 )
+
+def command_line_args( control ):
+	'''
+	Initialize argparse and process all command line arguments
+
+	@param control: ControlStage object which has access to all the group argument parsers
+	'''
+	# Setup argument processor
+	parser = argparse.ArgumentParser(
+		usage="%(prog)s [options..] [<generic>..]",
+		description="KLL Compiler - Generates specified output from KLL .kll files.",
+		epilog="Example: {0} TODO".format( os.path.basename( sys.argv[0] ) ),
+		formatter_class=argparse.RawTextHelpFormatter,
+		add_help=False,
+	)
+
+	# Get git information
+	control.git_rev, control.git_changes, control.git_date = git_revision(
+		os.path.dirname( os.path.realpath( __file__ ) )
+	)
+	control.version = "ALPHA 0.5c.{0} - {1}".format( control.git_rev, control.git_date )
+
+	# Optional Arguments
+	parser.add_argument(
+		'-h', '--help',
+		action="help",
+		help="This message."
+	)
+	parser.add_argument(
+		'-v', '--version',
+		action="version",
+		version="%(prog)s {0}".format( control.version ),
+		help="Show program's version number and exit"
+	)
+
+	# Add stage arguments
+	control.command_line_flags( parser )
+
+	# Process Arguments
+	args = parser.parse_args()
+
+	# Utilize parsed arguments in each of the stages
+	control.command_line_args( args )
+
+
+
+### Main Entry Point ###
+
+if __name__ == '__main__':
+	# Initialize Control Stages
+	control = stage.ControlStage()
+
+	# Process Command-Line Args
+	command_line_args( control )
+
+	# Process Control Stages
+	control.process()
+
+	# Successful Execution
+	sys.exit( 0 )
+
diff --git a/kll.py b/kll.py
index 6f69dad..27170f1 100755
--- a/kll.py
+++ b/kll.py
@@ -41,12 +41,12 @@ from funcparserlib.parser import (some, a, many, oneplus, skip, finished, maybe,
 
 ### Decorators ###
 
- ## Print Decorator Variables
+## Print Decorator Variables
 ERROR = '\033[5;1;31mERROR\033[0m:'
 
 
- ## Python Text Formatting Fixer...
- ##  Because the creators of Python are averse to proper capitalization.
+## Python Text Formatting Fixer...
+##  Because the creators of Python are averse to proper capitalization.
 textFormatter_lookup = {
 	"usage: "            : "Usage: ",
 	"optional arguments" : "Optional Arguments",
@@ -181,13 +181,13 @@ def tokenize( string ):
 
 ### Parsing ###
 
- ## Map Arrays
+## Map Arrays
 macros_map        = Macros()
 variables_dict    = Variables()
 capabilities_dict = Capabilities()
 
 
- ## Parsing Functions
+## Parsing Functions
 
 class Make:
 	def scanCode( token ):
@@ -333,7 +333,7 @@ class Make:
 	def indCode_number( token ):
 		return Make.hidCode_number( 'IndCode', token )
 
-	   # Replace key-word with None specifier (which indicates a noneOut capability)
+	# Replace key-word with None specifier (which indicates a noneOut capability)
 	def none( token ):
 		return [[[('NONE', 0)]]]
 
@@ -436,7 +436,7 @@ class Make:
 		print( value )
 		return [ value[0] ]
 
-	  # Range can go from high to low or low to high
+	# Range can go from high to low or low to high
 	def scanCode_range( rangeVals ):
 		start = rangeVals[0]
 		end   = rangeVals[1]
@@ -448,9 +448,9 @@ class Make:
 		# Iterate from start to end, and generate the range
 		return list( range( start, end + 1 ) )
 
-	  # Range can go from high to low or low to high
-	  # Warn on 0-9 for USBCodes (as this does not do what one would expect) TODO
-	  # Lookup USB HID tags and convert to a number
+	# Range can go from high to low or low to high
+	# Warn on 0-9 for USBCodes (as this does not do what one would expect) TODO
+	# Lookup USB HID tags and convert to a number
 	def hidCode_range( type, rangeVals ):
 		# Check if already integers
 		if isinstance( rangeVals[0], int ):
@@ -493,7 +493,7 @@ class Make:
 		return ""
 
 
- ## Base Rules
+## Base Rules
 
 const       = lambda x: lambda _: x
 unarg       = lambda f: lambda x: f(*x)
@@ -512,7 +512,7 @@ def listElem( item ):
 def listToTuple( items ):
 	return tuple( items )
 
-  # Flatten only the top layer (list of lists of ...)
+# Flatten only the top layer (list of lists of ...)
 def oneLayerFlatten( items ):
 	mainList = []
 	for sublist in items:
@@ -521,7 +521,7 @@ def oneLayerFlatten( items ):
 
 	return mainList
 
-  # Capability arguments may need to be expanded (e.g. 1 16 bit argument needs to be 2 8 bit arguments for the state machine)
+# Capability arguments may need to be expanded (e.g. 1 16 bit argument needs to be 2 8 bit arguments for the state machine)
 def capArgExpander( items ):
 	newArgs = []
 	# For each defined argument in the capability definition
@@ -536,8 +536,8 @@ def capArgExpander( items ):
 
 	return tuple( [ items[0], tuple( newArgs ) ] )
 
-  # Expand ranges of values in the 3rd dimension of the list, to a list of 2nd lists
-  # i.e. [ sequence, [ combo, [ range ] ] ] --> [ [ sequence, [ combo ] ], <option 2>, <option 3> ]
+# Expand ranges of values in the 3rd dimension of the list, to a list of 2nd lists
+# i.e. [ sequence, [ combo, [ range ] ] ] --> [ [ sequence, [ combo ] ], <option 2>, <option 3> ]
 def optionExpansion( sequences ):
 	expandedSequences = []
 
@@ -612,7 +612,7 @@ def tupleit( t ):
 	return tuple( map( tupleit, t ) ) if isinstance( t, ( tuple, list ) ) else t
 
 
- ## Evaluation Rules
+## Evaluation Rules
 
 class Eval:
 	def scanCode( triggers, operator, results ):
@@ -746,7 +746,7 @@ class Set:
 	variable         = unarg( Eval.variable )
 
 
- ## Sub Rules
+## Sub Rules
 
 usbCode       = tokenType('USBCode') >> Make.usbCode
 scanCode      = tokenType('ScanCode') >> Make.scanCode
@@ -771,16 +771,16 @@ seqString     = tokenType('SequenceString') >> Make.seqString
 unseqString   = tokenType('SequenceString') >> Make.unseqString # For use with variables
 pixelOperator = tokenType('PixelOperator')
 
-  # Code variants
+# Code variants
 code_begin = tokenType('CodeBegin')
 code_end   = tokenType('CodeEnd')
 
-  # Specifier
+# Specifier
 specifier_state  = ( name + skip( operator(':') ) + timing ) | ( name + skip( operator(':') ) + timing ) | timing | name >> Make.specifierState
 specifier_analog = number >> Make.specifierAnalog
 specifier_list   = skip( parenthesis('(') ) + many( ( specifier_state | specifier_analog ) + skip( maybe( comma ) ) ) + skip( parenthesis(')') )
 
-  # Scan Codes
+# Scan Codes
 scanCode_start     = tokenType('ScanCodeStart')
 scanCode_range     = number + skip( dash ) + number >> Make.scanCode_range
 scanCode_listElem  = number >> listElem
@@ -791,7 +791,7 @@ scanCode_elem      = scanCode + maybe( specifier_list ) >> Make.specifierUnroll
 scanCode_combo     = oneplus( ( scanCode_expanded | scanCode_elem ) + skip( maybe( plus ) ) )
 scanCode_sequence  = oneplus( scanCode_combo + skip( maybe( comma ) ) )
 
-  # Cons Codes
+# Cons Codes
 consCode_start       = tokenType('ConsCodeStart')
 consCode_number      = number >> Make.consCode_number
 consCode_range       = ( consCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.consCode_range
@@ -802,7 +802,7 @@ consCode_innerList   = oneplus( consCode_specifier + skip( maybe( comma ) ) ) >>
 consCode_expanded    = skip( consCode_start ) + consCode_innerList + skip( code_end )
 consCode_elem        = consCode + maybe( specifier_list ) >> Make.specifierUnroll >> listElem
 
-  # Sys Codes
+# Sys Codes
 sysCode_start       = tokenType('SysCodeStart')
 sysCode_number      = number >> Make.sysCode_number
 sysCode_range       = ( sysCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.sysCode_range
@@ -813,7 +813,7 @@ sysCode_innerList   = oneplus( sysCode_specifier + skip( maybe( comma ) ) ) >> f
 sysCode_expanded    = skip( sysCode_start ) + sysCode_innerList + skip( code_end )
 sysCode_elem        = sysCode + maybe( specifier_list ) >> Make.specifierUnroll >> listElem
 
-  # Indicator Codes
+# Indicator Codes
 indCode_start       = tokenType('IndicatorStart')
 indCode_number      = number >> Make.indCode_number
 indCode_range       = ( indCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.indCode_range
@@ -824,7 +824,7 @@ indCode_innerList   = oneplus( indCode_specifier + skip( maybe( comma ) ) ) >> f
 indCode_expanded    = skip( indCode_start ) + indCode_innerList + skip( code_end )
 indCode_elem        = indCode + maybe( specifier_list ) >> Make.specifierUnroll >> listElem
 
-  # USB Codes
+# USB Codes
 usbCode_start       = tokenType('USBCodeStart')
 usbCode_number      = number >> Make.usbCode_number
 usbCode_range       = ( usbCode_number | unString ) + skip( dash ) + ( number | unString ) >> Make.usbCode_range
@@ -835,13 +835,13 @@ usbCode_innerList   = oneplus( usbCode_specifier + skip( maybe( comma ) ) ) >> f
 usbCode_expanded    = skip( usbCode_start ) + usbCode_innerList + skip( code_end )
 usbCode_elem        = usbCode + maybe( specifier_list ) >> Make.specifierUnroll >> listElem
 
-  # HID Codes
+# HID Codes
 hidCode_elem        = usbCode_expanded | usbCode_elem | sysCode_expanded | sysCode_elem | consCode_expanded | consCode_elem | indCode_expanded | indCode_elem
 
 usbCode_combo       = oneplus( hidCode_elem + skip( maybe( plus ) ) ) >> listElem
 usbCode_sequence    = oneplus( ( usbCode_combo | seqString ) + skip( maybe( comma ) ) ) >> oneLayerFlatten
 
-  # Pixels
+# Pixels
 pixel_start       = tokenType('PixelStart')
 pixel_number      = number
 pixel_range       = ( pixel_number ) + skip( dash ) + ( number ) >> Make.range
@@ -850,25 +850,25 @@ pixel_innerList   = many( ( pixel_range | pixel_listElem ) + skip( maybe( comma
 pixel_expanded    = skip( pixel_start ) + pixel_innerList + skip( code_end )
 pixel_elem        = pixel >> listElem
 
-  # Pixel Layer
+# Pixel Layer
 pixellayer_start    = tokenType('PixelLayerStart')
 pixellayer_number   = number
 pixellayer_expanded = skip( pixellayer_start ) + pixellayer_number + skip( code_end )
 pixellayer_elem     = pixelLayer >> listElem
 
-  # Pixel Channels
+# Pixel Channels
 pixelchan_chans = many( number + skip( operator(':') ) + number + skip( maybe( comma ) ) ) >> Make.pixelchans
 pixelchan_elem  = ( pixel_expanded | pixel_elem ) + skip( parenthesis('(') ) + pixelchan_chans + skip( parenthesis(')') ) >> Make.pixelchan_elem
 
-  # Pixel Mods
+# Pixel Mods
 pixelmod_mods  = many( maybe( pixelOperator | plus | dash ) + number + skip( maybe( comma ) ) ) >> Make.pixelmods
 pixelmod_layer = ( pixellayer_expanded | pixellayer_elem ) >> Make.pixellayer
 pixelmod_elem  = ( pixel_expanded | pixel_elem | pixelmod_layer ) + skip( parenthesis('(') ) + pixelmod_mods + skip( parenthesis(')') )
 
-  # Pixel Capability
+# Pixel Capability
 pixel_capability = pixelmod_elem >> Make.pixelCapability
 
-  # Animations
+# Animations
 animation_start       = tokenType('AnimationStart')
 animation_name        = name
 animation_frame_range = ( number ) + skip( dash ) + ( number ) >> Make.range
@@ -877,28 +877,28 @@ animation_def         = skip( animation_start ) + animation_name + skip( code_en
 animation_expanded    = skip( animation_start ) + animation_name + skip( comma ) + animation_name_frame + skip( code_end )
 animation_elem        = animation >> listElem
 
-  # Animation Modifier
+# Animation Modifier
 animation_modifier = many( ( name | number ) + maybe( skip( operator(':') ) + number ) + skip( maybe( comma ) ) )
 
-  # Animation Capability
+# Animation Capability
 animation_capability = ( animation_def | animation_elem ) + maybe( skip( parenthesis('(') + animation_modifier + skip( parenthesis(')') ) ) ) >> Make.animationCapability
 
-  # Capabilities
+# Capabilities
 capFunc_arguments = many( number + skip( maybe( comma ) ) ) >> listToTuple
 capFunc_elem      = name + skip( parenthesis('(') ) + capFunc_arguments + skip( parenthesis(')') ) >> capArgExpander >> listElem
 capFunc_combo     = oneplus( ( hidCode_elem | capFunc_elem | animation_capability | pixel_capability ) + skip( maybe( plus ) ) ) >> listElem
 capFunc_sequence  = oneplus( ( capFunc_combo | seqString ) + skip( maybe( comma ) ) ) >> oneLayerFlatten
 
-  # Trigger / Result Codes
+# Trigger / Result Codes
 triggerCode_outerList    = scanCode_sequence >> optionExpansion
 triggerUSBCode_outerList = usbCode_sequence >> optionExpansion >> hidCodeToCapability
 resultCode_outerList     = ( ( capFunc_sequence >> optionExpansion ) | none ) >> hidCodeToCapability
 
-  # Positions
+# Positions
 position_list = oneplus( position + skip( maybe( comma ) ) )
 
 
- ## Main Rules
+## Main Rules
 
 #| Assignment
 #| <variable> = <variable contents>;
diff --git a/kll_lib/containers.py b/kll_lib/containers.py
index 814cd5c..9b0d79e 100644
--- a/kll_lib/containers.py
+++ b/kll_lib/containers.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # KLL Compiler Containers
 #
-# Copyright (C) 2014-2015 by Jacob Alexander
+# Copyright (C) 2014-2016 by Jacob Alexander
 #
 # This file is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -24,7 +24,7 @@ import copy
 
 ### Decorators ###
 
- ## Print Decorator Variables
+## Print Decorator Variables
 ERROR = '\033[5;1;31mERROR\033[0m:'
 
 
@@ -32,7 +32,7 @@ ERROR = '\033[5;1;31mERROR\033[0m:'
 ### Parsing ###
 
 
- ## Containers
+## Containers
 
 class ScanCode:
 	# Container for ScanCodes
diff --git a/templates/kiibohdDefs.h b/templates/kiibohdDefs.h
index 259de78..7649998 100644
--- a/templates/kiibohdDefs.h
+++ b/templates/kiibohdDefs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2014-2015 by Jacob Alexander
+/* Copyright (C) 2014-2016 by Jacob Alexander
  *
  * This file is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/templates/kiibohdKeymap.h b/templates/kiibohdKeymap.h
index bb78ede..15ffe4e 100644
--- a/templates/kiibohdKeymap.h
+++ b/templates/kiibohdKeymap.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2014-2015 by Jacob Alexander
+/* Copyright (C) 2014-2016 by Jacob Alexander
  *
  * This file is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by